text:
using namespace std;

namespace NLP { namespace Extract {

// length of current word is 1-14 and 15 and above ("0" ensures array is indexed by the length)
const static char *const lengths[] = { "0", "1", "2", "3", "4", "5", "6", "7",
                                       "8", "9", "10", "11", "12", "13", "14", "15" };

// private implementation, which is shared
class NER::_Impl: public _TaggerImpl {
protected:
  template <class TC>
  void _add_surrounding_words(TC &tc, const Sentence &sent, ulong i);
  template <class TC>
  void _add_surrounding_pos(TC &tc, const Sentence &sent, ulong i);
  template <class TC>
  void _add_surrounding_chunks(TC &tc, const Sentence &sent, ulong i);
  template <class TC>
  void _add_history(TC &tc, const Sentence &sent, ulong i);

  template <class TC>
  void _add_prefixes(TC &tc, const Sentence &sent, ulong i);
  template <class TC>
  void _add_suffixes(TC &tc, const Sentence &sent, ulong i);
  template <class TC>
  void _add_special(TC &tc, const Sentence &sent, ulong i);
  template <class TC>
  void _add_last(TC &tc, const Sentence &sent, ulong i);
  template <class TC>
  void _add_gazetteers(TC &tc, const Sentence &sentence, ulong i);
  template <class TC>
  void _add_prev_gazetteers(TC &tc, const Sentence &sent, ulong i);
  template <class TC>
  void _add_next_gazetteers(TC &tc, const Sentence &sent, ulong i);

  template <class TC>
  void _add_unigrams(TC &tc, const Sentence &sentence, ulong i);
  template <class TC>
  void _add_wordtypes(TC &tc, const Sentence &sentence, ulong i);

  template <class TC>
  void _generate(TC &tc, const Sentence &sent, ulong i);

  void _generate_counts(const Sentence &sent);
  void _generate_features(const Sentence &sent);
  void _generate_contexts(const Sentence &sent);
  void _make_unknowns(void) const;

  void _pass1(NLP::IO::Reader &reader);
  void _pass2(NLP::IO::Reader &reader);
  void _pass3(NLP::IO::Reader &reader);
public:
  NLP::Tagger::NER::Config &cfg;
  const Types types;

  NLP::Tagger::TagHist last_klass;
  NLP::Tagger::Unigram unigrams;
  NLP::Gazetteers gaz;

  Lexicon poscounts;
  Lexicon chunkcounts;

  _Impl(NLP::Tagger::NER::Config &cfg, const std::string &PREFACE, bool VERBOSE);
  virtual ~_Impl(void);
};

// count 1--4 character prefix features
template <class TC>
void
NER::_Impl::_add_prefixes(TC &tc, const NLP::Sentence &sent, ulong i){
  if(!types.use_prefix())
    return;

  const std::string &word = sent.words[i];
  std::string::const_iterator j = word.begin();

  std::string affix;
  attributes(tc, Types::pref, affix += *j);
  if(++j == word.end())
    return;
  attributes(tc, Types::pref, affix += *j);
  if(++j == word.end())
    return;
  attributes(tc, Types::pref, affix += *j);
  if(++j == word.end())
    return;
  attributes(tc, Types::pref, affix += *j);
}

// count 1--4 character suffix features
template <class TC>
void
NER::_Impl::_add_suffixes(TC &tc, const NLP::Sentence &sent, ulong i){
  if(!types.use_suffix())
    return;

  const std::string &word = sent.words[i];
  std::string::const_reverse_iterator j = word.rbegin();

  std::string affix;
  attributes(tc, Types::suff, affix += *j);
  if(++j == word.rend())
    return;
  attributes(tc, Types::suff, affix += *j);
  if(++j == word.rend())
    return;
  attributes(tc, Types::suff, affix += *j);
  if(++j == word.rend())
    return;
  attributes(tc, Types::suff, affix += *j);
}

// add surrounding word features (2 words to left and right) to the context
template <class TC>
void
NER::_Impl::_add_surrounding_words(TC &tc, const Sentence &sent, ulong i){
  if(!types.use_words())
    return;

  if(i > 0){
    attributes(tc, Types::pw, sent.words[i - 1]);
    if(i > 1)
      attributes(tc, Types::ppw, sent.words[i - 2]);
    else
      attributes(tc, Types::ppw, SENTINEL);
  }else{
    attributes(tc, Types::pw, SENTINEL);
    attributes(tc, Types::ppw, SENTINEL);
  }

  size_t last = sent.words.size() - 1;
  if(i < last){
    attributes(tc, Types::nw, sent.words[i + 1]);
    --last;
    if(i < last)
      attributes(tc, Types::nnw, sent.words[i + 2]);
    else
      attributes(tc, Types::nnw, SENTINEL);
  }else{
    attributes(tc, Types::nw, SENTINEL);
    attributes(tc, Types::nnw, SENTINEL);
  }
}

// add surrounding POS tag features (2 tags to left and right) to the context
template <class TC>
void
NER::_Impl::_add_surrounding_pos(TC &tc, const Sentence &sent, ulong i){
  if(!types.use_pos())
    return;

  if(i > 0){
    attributes(tc, Types::pt, sent.pos[i - 1]);
    if(i > 1)
      attributes(tc, Types::ppt, sent.pos[i - 2]);
    else
      attributes(tc, Types::ppt, SENTINEL);
  }else{
    attributes(tc, Types::pt, SENTINEL);
    attributes(tc, Types::ppt, SENTINEL);
  }

  size_t last = sent.pos.size() - 1;
  if(i < last){
    attributes(tc, Types::nt, sent.pos[i + 1]);
    --last;
    if(i < last)
      attributes(tc, Types::nnt, sent.pos[i + 2]);
    else
      attributes(tc, Types::nnt, SENTINEL);
  }else{
    attributes(tc, Types::nt, SENTINEL);
    attributes(tc, Types::nnt, SENTINEL);
  }
}

// add surrounding chunk tag features (2 chunks to left and right) to the context
template <class TC>
void
NER::_Impl::_add_surrounding_chunks(TC &tc, const Sentence &sent, ulong i){
  if(!types.use_chunks())
    return;

  if(i > 0){
    attributes(tc, Types::pc, sent.chunks[i - 1]);
    if(i > 1)
      attributes(tc, Types::ppc, sent.chunks[i - 2]);
    else
      attributes(tc, Types::ppc, SENTINEL);
  }else{
    attributes(tc, Types::pc, SENTINEL);
    attributes(tc, Types::ppc, SENTINEL);
  }

  size_t last = sent.chunks.size() - 1;
  if(i < last){
    attributes(tc, Types::nc, sent.chunks[i + 1]);
    --last;
    if(i < last)
      attributes(tc, Types::nnc, sent.chunks[i + 2]);
    else
      attributes(tc, Types::nnc, SENTINEL);
  }else{
    attributes(tc, Types::nc, SENTINEL);
    attributes(tc, Types::nnc, SENTINEL);
  }
}

// count a range of orthographic features including length
// has hyphen, has period, has punctuation, has digit
// digit patterns, is number, is alphanumeric, is roman numerals
// case features, etc
// uses the NLP::Analyser to efficiently extract features
template <class TC>
void
NER::_Impl::_add_special(TC &tc, const Sentence &sent, ulong i){
  Analyser a(sent.words[i]);

  if(types.use_length()){
    if(a.len < 16)
      attributes(tc, Types::length, lengths[a.len]);
    else
      attributes(tc, Types::length, "m");
  }

  if(a.nhyphens && types.use_has_hyphen())
    attributes(tc, Types::has_hyphen, NONE);

  if(a.nperiods && types.use_has_period())
    attributes(tc, Types::has_period, NONE);

  if(a.npunct && types.use_has_punct())
    attributes(tc, Types::has_punct, NONE);

  if(a.ndigits){
    if(types.use_has_digit())
      attributes(tc, Types::has_digit, NONE);

    if(a.is_digits()){
      switch(a.len){
        case 1: if(types.use_one_digit()) attributes(tc, Types::digits, "1"); break;
        case 2: if(types.use_two_digits()) attributes(tc, Types::digits, "2"); break;
        case 3: if(types.use_three_digits()) attributes(tc, Types::digits, "3"); break;
        case 4: if(types.use_four_digits()) attributes(tc, Types::digits, "4"); break;
        default: if(types.use_digits()) attributes(tc, Types::digits, "m"); break;
      }
      if(types.use_number())
        attributes(tc, Types::number, NONE);
      return;
    }

    if(a.is_number()){
      if(types.use_number())
        attributes(tc, Types::number, NONE);
      return;
    }

    if(a.is_alphanum()){
      if(types.use_alphanum())
        attributes(tc, Types::alphanum, NONE);
      return;
    }
  }

  if(a.is_roman() && types.use_roman())
    attributes(tc, Types::roman, NONE);

  if(a.nupper){
    if(types.use_has_uppercase())
      attributes(tc, Types::has_uppercase, NONE);

    if(types.use_case()){
      if(a.fupper){
        if(a.uc())
          attributes(tc, Types::kase, "uc");
        else if(a.tc())
          attributes(tc, Types::kase, "tc");
        else if(a.mc())
          attributes(tc, Types::kase, "mc");
      }
    }

    if(a.is_initial()){
      if(types.use_initial())
        attributes(tc, Types::initial, NONE);
    }else if(a.is_acronym()){
      if(types.use_acronym())
        attributes(tc, Types::acronym, NONE);
    }
  }else if(a.lc() && types.use_case())
    attributes(tc, Types::kase, "lc");
}

// count previously assigned tag features
// for the previous tag and the bigram (previous tag, prev-prev tag)
template <class TC>
void
NER::_Impl::_add_history(TC &tc, const Sentence &sent, ulong i){
  if(!types.use_history())
    return;

  if(i > 0){
    attributes(tc, Types::pne, sent.entities[i - 1]);
    if(i > 1)
      attributes(tc, Types::ppne, sent.entities[i - 2], sent.entities[i - 1]);
    else
      attributes(tc, Types::ppne, SENTINEL, sent.entities[i - 1]);
  }else{
    attributes(tc, Types::pne, SENTINEL);
    attributes(tc, Types::ppne, SENTINEL2);
  }
}

// add the 'history' feature (the tag this word was last assigned in the document)
template <class TC>
void
NER::_Impl::_add_last(TC &tc, const Sentence &sent, ulong i){
  Tag tag = last_klass[sent.words[i]];
  if(tag.value())
    attributes(tc, Types::last, klasses[tag]);
}

// count current word gazetteer features
// there are several feature types here:

// is the current word more frequently seen in lowercase than other case forms
// and the same with a marker indicating whether we are at the beginning
// of the sentence or not

// gazetteer features for first and last name
// three gazetteer features for three different location gazetteers
// if other gazetteers are loaded, then they will need to be added
// as features to this function

// this should really be generalised since we can now add new gazetteers
// without modifying any code
template <class TC>
void
NER::_Impl::_add_gazetteers(TC &tc, const Sentence &sent, ulong i){
  const std::string &word = sent.words[i];

  ulong flags = gaz.lower(word);
  if(flags & Gazetteers::COMMON){
    if(types.use_gaz_common())
      attributes(tc, Types::gaz_common, NONE);

    if(types.use_composites()){
        if(i == 0)
          attributes(tc, Types::xcommon_bs, NONE);
        else
          attributes(tc, Types::xcommon_ms, NONE);
    }
  }

  flags = gaz[word];
  if(types.use_gaz_first() && (flags & Gazetteers::FIRST))
    attributes(tc, Types::gaz_first, NONE);
  if(types.use_gaz_last() && (flags & Gazetteers::LAST))
    attributes(tc, Types::gaz_last, NONE);
}

// same as above for counting the previous word (except for leaving out
// the complex common gazetteer features)
template <class TC>
void
NER::_Impl::_add_prev_gazetteers(TC &tc, const Sentence &sent, ulong i){
  const std::string &word = sent.words[i];

  ulong flags = gaz.lower(word);
  if(types.use_gaz_common() && (flags & Gazetteers::COMMON))
    attributes(tc, Types::pgaz_common, NONE);

  flags = gaz[word];
  if(types.use_gaz_first() && (flags & Gazetteers::FIRST))
    attributes(tc, Types::pgaz_first, NONE);

  if(types.use_gaz_last() && (flags & Gazetteers::LAST))
    attributes(tc, Types::pgaz_last, NONE);
}

// counting next word gazetteer features
template <class TC>
void
NER::_Impl::_add_next_gazetteers(TC &tc, const Sentence &sent, ulong i){
  const std::string &word = sent.words[i];

  ulong flags = gaz.lower(word);
  if(types.use_gaz_common() && (flags & Gazetteers::COMMON))
    attributes(tc, Types::ngaz_common, NONE);

  flags = gaz[word];
  if(types.use_gaz_first() && (flags & Gazetteers::FIRST))
    attributes(tc, Types::ngaz_first, NONE);
  if(types.use_gaz_last() && (flags & Gazetteers::LAST))
    attributes(tc, Types::ngaz_last, NONE);
}

// counting forward looking unigram features
// i.e. the most frequently seen tag for the next word
// we look at the next word and the next-next word
template <class TC>
void
NER::_Impl::_add_unigrams(TC &tc, const Sentence &sent, ulong i){
  size_t last = sent.words.size() - 1;
  if(i < last){
    if(types.use_nu())
      attributes(tc, Types::nu, klasses[unigrams[lexicon[sent.words[i + 1]]]]);
    if(types.use_nnu()){
      if(i < last - 1)
        attributes(tc, Types::nnu, klasses[unigrams[lexicon[sent.words[i + 2]]]]);
      else
        attributes(tc, Types::nnu, SENTINEL);
    }
  }else{
    if(types.use_nu())
      attributes(tc, Types::nu, SENTINEL);
    if(types.use_nnu())
      attributes(tc, Types::nnu, SENTINEL);
  }
}

// count all word-type features around the current word in one go
// including single word, bigram and trigram word types
// the NLP::WordType class creates a word-type representation
// for these directly, so adding bigrams and trigrams is simple
template <class TC>
void
NER::_Impl::_add_wordtypes(TC &tc, const Sentence &sent, ulong i){
  if(!types.use_wordtypes())
    return;

  WordType WT;

  attributes(tc, Types::wt, WT(sent.words[i]));

  if(i > 0){
    attributes(tc, Types::pwt, WT(sent.words[i - 1]));
    if(types.use_bitypes())
      attributes(tc, Types::pbt, WT(sent.words[i - 1], sent.words[i]));
    if(i > 1){
      attributes(tc, Types::ppwt, WT(sent.words[i - 2]));
      if(types.use_bitypes())
        attributes(tc, Types::ppbt, WT(sent.words[i - 2], sent.words[i - 1]));
      if(types.use_tritypes() && i > 2)
        attributes(tc, Types::ptt, WT(sent.words[i - 3], sent.words[i - 2], sent.words[i - 1]));
    }
  }

  size_t last = sent.words.size() - 1;
  if(i < last){
    attributes(tc, Types::nwt, WT(sent.words[i + 1]));
    if(types.use_bitypes()){
      attributes(tc, Types::nbt, WT(sent.words[i], sent.words[i + 1]));
      if(i > 0)
        attributes(tc, Types::bt, WT(sent.words[i - 1], sent.words[i + 1]));
    }
    if(i < last - 1){
      attributes(tc, Types::nnwt, WT(sent.words[i + 2]));
      if(types.use_bitypes())
        attributes(tc, Types::nnbt, WT(sent.words[i + 1], sent.words[i + 2]));
      if(types.use_tritypes() && i < last - 2)
        attributes(tc, Types::ntt, WT(sent.words[i + 1], sent.words[i + 2], sent.words[i + 3]));
    }
  }
}

// count the number of tags, words and word/tag pairs in the given sentence
void
NER::_Impl::_generate_counts(const NLP::Sentence &sent){
  for(ulong i = 0; i < sent.words.size(); ++i){
    lexicon.add(sent.words[i], 1);
    if(types.use_pos())
      poscounts.add(sent.pos[i], 1);
    if(types.use_chunks())
      chunkcounts.add(sent.chunks[i], 1);
    counts.add(sent.entities[i], 1);

    // build a word-POS tag pair to add to the tag dictionary
    tagdict.add(sent.words[i] + ' ' + sent.entities[i], 1);
  }
  nevents += sent.words.size();
}

template <class TC>
void
NER::_Impl::_generate(TC &tc, const Sentence &sent, ulong i){
  const ulong last = sent.words.size() - 1;

  // rare word features only switch on for infrequent words
  if(lexicon.freq(sent.words[i]) < cfg.rare_cutoff()){
    _add_prefixes(tc, sent, i);
    _add_suffixes(tc, sent, i);
    _add_special(tc, sent, i);
  }

  if(types.use_words())
    attributes(tc, Types::w, sent.words[i]);

  if(types.use_last())
    _add_last(tc, sent, i);

  if(types.use_pos())
    attributes(tc, Types::t, sent.pos[i]);

  if(types.use_chunks())
    attributes(tc, Types::c, sent.chunks[i]);

  if(types.use_gazetteers())
    _add_gazetteers(tc, sent, i);
  if(types.use_prev_gazetteers() && i > 0)
    _add_prev_gazetteers(tc, sent, i - 1);
  if(types.use_next_gazetteers() && i < last)
    _add_next_gazetteers(tc, sent, i + 1);

  _add_surrounding_words(tc, sent, i);
  _add_surrounding_pos(tc, sent, i);
  _add_surrounding_chunks(tc, sent, i);

  _add_unigrams(tc, sent, i);
  _add_history(tc, sent, i);
  _add_wordtypes(tc, sent, i);
}

// count the features for each training sentence in the given sentence
void
NER::_Impl::_generate_features(const Sentence &sent){
  for(ulong i = 0; i < sent.words.size(); ++i){
    Tag klass = klasses[sent.entities[i]];

    _generate(klass, sent, i);

    last_klass.add(sent.words[i], klass);
  }
  nevents += sent.words.size();
}

// add the features for each training instance to the context
// and dump it model/contexts for the given sentence
void
NER::_Impl::_generate_contexts(const NLP::Sentence &sent){
  for(ulong i = 0; i < sent.words.size(); ++i){
    context.resize(0);

    Tag klass = klasses[sent.entities[i]];

    _generate(context, sent, i);

    if(context.size() > 0){
      std::sort(context.begin(), context.end());
      contexts.add(klass, context);
    }

    last_klass.add(sent.words[i], klass);
  }
  nevents += sent.words.size();
}

void
NER::_Impl::_make_unknowns(void) const {
  ofstream stream(cfg.unknowns().c_str());
  if(!stream)
    throw NLP::IOException("could not open unknown_tags file for writing", cfg.unknowns());

  stream << PREFACE << '\n';
}

void
NER::_Impl::_pass1(NLP::IO::Reader &reader){
  _TaggerImpl::_pass1(reader);

  // POS tags are sorted alphabetically and dumped
  poscounts.sort_by_alpha();
  poscounts.save(cfg.postags(), PREFACE);

  // postag dictionary is sorted alphabetically on postag-tag pairs and dumped
  chunkcounts.sort_by_alpha();
  chunkcounts.save(cfg.chunktags(), PREFACE);
}

// count the number of features and attributes extracted from the training data
// dump out to model/features and model/attributes
void
NER::_Impl::_pass2(NLP::IO::Reader &reader){
  // load the counts from pass1 back into klasses and unigrams
  unigrams.load(cfg.tagdict());
  last_klass.clear();
  _TaggerImpl::_pass2(reader);
}

// extract features, translate them to attribute IDs for context vectors
// dump context vectors to model/contexts and compress to merge duplicates
void
NER::_Impl::_pass3(NLP::IO::Reader &reader){
  last_klass.clear();
  _TaggerImpl::_pass3(reader);
}

NER::_Impl::_Impl(NLP::Tagger::NER::Config &cfg, const std::string &PREFACE, bool VERBOSE)
  : _TaggerImpl(cfg, PREFACE, VERBOSE), cfg(cfg), types(cfg.types),
    last_klass("last_klass"), unigrams("unigrams", klasses, lexicon),
    gaz("gazetteers", cfg.path(), cfg.gazetteers()),
    poscounts("poscounts"), chunkcounts("chunkcounts"){}

NER::_Impl::~_Impl(void) {}

NER::NER(NLP::Tagger::NER::Config &cfg, const std::string &PREFACE, bool VERBOSE)
  : _impl(new _Impl(cfg, PREFACE, VERBOSE)){}

NER::NER(const NER &other): _impl(share(other._impl)){}

NER::~NER(void){
  release(_impl);
}

ulong NER::nevents(void) const { return _impl->nevents; };
ulong NER::ncontexts(void) const { return _impl->ncontexts; };

TagSet NER::tagset(void) const { return _impl->klasses; };
Lexicon NER::lexicon(void) const { return _impl->lexicon; };

void NER::extract(NLP::IO::Reader &reader){ _impl->extract(reader, true); }

} }


text:
ACCEPTED

#### According to
Integrated Taxonomic Information System

#### Published in
Sida 5:47. 1972

#### Original name
null

### Remarks
null

redpajama_set_name: RedPajamaGithub


text:
package chart

import (
	"github.com/ghodss/yaml"
)

// Merges source and destination map, preferring values from the source map
func MergeValues(dest map[string]interface{}, src map[string]interface{}) map[string]interface{} {
	for k, v := range src {
		// If the key doesn't exist already, then just set the key to that value
		if _, exists := dest[k]; !exists {
			dest[k] = v
			continue
		}
		nextMap, ok := v.(map[string]interface{})
		// If it isn't another map, overwrite the value
		if !ok {
			dest[k] = v
			continue
		}
		// If the key doesn't exist already, then just set the key to that value
		if _, exists := dest[k]; !exists {
			dest[k] = nextMap
			continue
		}
		// Edge case: If the key exists in the destination, but isn't a map
		destMap, isMap := dest[k].(map[string]interface{})
		// If the source map has a map for this key, prefer it
		if !isMap {
			dest[k] = v
			continue
		}
		// If we got to this point, it is a map in both, so merge them
		dest[k] = MergeValues(destMap, nextMap)
	}
	return dest
}

func CreateValuesYaml(cs map[string]interface{}) ([]byte, error) {
	base := map[string]interface{}{}
	for k, v := range cs {
		base[k] = v
	}

	return yaml.Marshal(base)
}


text:
#!/usr/bin/env python

# (C) Copyright IBM Corporation 2005
# All Rights Reserved.
#
# Permission is hereby granted, free of charge, to any person obtaining a
# copy of this software and associated documentation files (the "Software"),
# to deal in the Software without restriction, including without limitation
# on the rights to use, copy, modify, merge, publish, distribute, sub
# license, and/or sell copies of the Software, and to permit persons to whom
# the Software is furnished to do so, subject to the following conditions:
#
# The above copyright notice and this permission notice (including the next
# paragraph) shall be included in all copies or substantial portions of the
# Software.
#
# THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
# IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
# FITNESS FOR A PARTICULAR PURPOSE AND NON-INFRINGEMENT.  IN NO EVENT SHALL
# IBM AND/OR ITS SUPPLIERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
# LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
# FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
# IN THE SOFTWARE.
#
# Authors:
#    Ian Romanick <idr@us.ibm.com>

import gl_XML
import license
import sys, getopt, string

vtxfmt = [
    "ArrayElement", \
    "Color3f", \
    "Color3fv", \
    "Color4f", \
    "Color4fv", \
    "EdgeFlag", \
    "EdgeFlagv", \
    "EvalCoord1f", \
    "EvalCoord1fv", \
    "EvalCoord2f", \
    "EvalCoord2fv", \
    "EvalPoint1", \
    "EvalPoint2", \
    "FogCoordfEXT", \
    "FogCoordfvEXT", \
    "Indexf", \
    "Indexfv", \
    "Materialfv", \
    "MultiTexCoord1fARB", \
    "MultiTexCoord1fvARB", \
    "MultiTexCoord2fARB", \
    "MultiTexCoord2fvARB", \
    "MultiTexCoord3fARB", \
    "MultiTexCoord3fvARB", \
    "MultiTexCoord4fARB", \
    "MultiTexCoord4fvARB", \
    "Normal3f", \
    "Normal3fv", \
    "SecondaryColor3fEXT", \
    "SecondaryColor3fvEXT", \
    "TexCoord1f", \
    "TexCoord1fv", \
    "TexCoord2f", \
    "TexCoord2fv", \
    "TexCoord3f", \
    "TexCoord3fv", \
    "TexCoord4f", \
    "TexCoord4fv", \
    "Vertex2f", \
    "Vertex2fv", \
    "Vertex3f", \
    "Vertex3fv", \
    "Vertex4f", \
    "Vertex4fv", \
    "CallList", \
    "CallLists", \
    "Begin", \
    "End", \
    "VertexAttrib1fNV", \
    "VertexAttrib1fvNV", \
    "VertexAttrib2fNV", \
    "VertexAttrib2fvNV", \
    "VertexAttrib3fNV", \
    "VertexAttrib3fvNV", \
    "VertexAttrib4fNV", \
    "VertexAttrib4fvNV", \
    "VertexAttrib1fARB", \
    "VertexAttrib1fvARB", \
    "VertexAttrib2fARB", \
    "VertexAttrib2fvARB", \
    "VertexAttrib3fARB", \
    "VertexAttrib3fvARB", \
    "VertexAttrib4fARB", \
    "VertexAttrib4fvARB", \
    "Rectf", \
    "DrawArrays", \
    "DrawElements", \
    "DrawRangeElements", \
    "EvalMesh1", \
    "EvalMesh2", \
]

def all_entrypoints_in_abi(f, abi, api):
	for n in f.entry_points:
		[category, num] = api.get_category_for_name( n )
		if category not in abi:
			return 0

	return 1

def any_entrypoints_in_abi(f, abi, api):
	for n in f.entry_points:
		[category, num] = api.get_category_for_name( n )
		if category in abi:
			return 1

	return 0

def condition_for_function(f, abi, all_not_in_ABI):
	"""Create a C-preprocessor condition for the function.

	There are two modes of operation.  If all_not_in_ABI is set, a
	condition is only created is all of the entry-point names for f are
	not in the selected ABI.  If all_not_in_ABI is not set, a condition
	is created if any entryp-point name is not in the selected ABI.
	"""

	condition = []
	for n in f.entry_points:
		[category, num] = api.get_category_for_name( n )
		if category not in abi:
			condition.append( 'defined(need_%s)' % (gl_XML.real_category_name( category )) )
		elif all_not_in_ABI:
			return []

	return condition

class PrintGlExtensionGlue(gl_XML.gl_print_base):
	def __init__(self):
		gl_XML.gl_print_base.__init__(self)

		self.name = "extension_helper.py (from Mesa)"
		self.license = license.bsd_license_template % ("(C) Copyright IBM Corporation 2005", "IBM")
		return

	def printRealHeader(self):
		print '#include "utils.h"'
		print '#include "main/dispatch.h"'
		print ''
		return

	def printBody(self, api):
		abi = [ "1.0", "1.1", "1.2", "GL_ARB_multitexture" ]

		category_list = {}

		print '#ifndef NULL'
		print '# define NULL 0'
		print '#endif'
		print ''

		for f in api.functionIterateAll():
			condition = condition_for_function(f, abi, 0)
			if len(condition):
				print '#if %s' % (string.join(condition, " || "))
				print 'static const char %s_names[] =' % (f.name)

				parameter_signature = ''
				for p in f.parameterIterator():
					if p.is_padding:
						continue

					# FIXME: This is a *really* ugly hack. :(

					tn = p.type_expr.get_base_type_node()
					if p.is_pointer():
						parameter_signature += 'p'
					elif tn.integer:
						parameter_signature += 'i'
					elif tn.size == 4:
						parameter_signature += 'f'
					else:
						parameter_signature += 'd'

				print '    "%s\\0" /* Parameter signature */' % (parameter_signature)

				for n in f.entry_points:
					print '    "gl%s\\0"' % (n)

					[category, num] = api.get_category_for_name( n )
					if category not in abi:
						c = gl_XML.real_category_name(category)
						if not category_list.has_key(c):
							category_list[ c ] = []

						category_list[ c ].append( f )

				print '    "";'
				print '#endif'
				print ''

		keys = category_list.keys()
		keys.sort()

		for category in keys:
			print '#if defined(need_%s)' % (category)
			print 'static const struct dri_extension_function %s_functions[] = {' % (category)

			for f in category_list[ category ]:
				# A function either has an offset that is
				# assigned by the ABI, or it has a remap
				# index.
				if any_entrypoints_in_abi(f, abi, api):
					index_name = "-1"
					offset = f.offset
				else:
					index_name = "%s_remap_index" % (f.name)
					offset = -1

				print '    { %s_names, %s, %d },' % (f.name, index_name, offset)

			print '    { NULL, 0, 0 }'
			print '};'
			print '#endif'
			print ''

		return

class PrintInitDispatch(gl_XML.gl_print_base):
	def __init__(self):
		gl_XML.gl_print_base.__init__(self)

		self.name = "extension_helper.py (from Mesa)"
		self.license = license.bsd_license_template % ("(C) Copyright IBM Corporation 2005", "IBM")
		return

	def do_function_body(self, api, abi, vtxfmt_only):
		last_condition_string = None
		for f in api.functionIterateByOffset():
			if (f.name in vtxfmt) and not vtxfmt_only:
				continue

			if (f.name not in vtxfmt) and vtxfmt_only:
				continue

			condition = condition_for_function(f, abi, 1)
			condition_string = string.join(condition, " || ")

			if condition_string != last_condition_string:
				if last_condition_string:
					print '#endif /* %s */' % (last_condition_string)

				if condition_string:
					print '#if %s' % (condition_string)

			if vtxfmt_only:
				print '   disp->%s = vfmt->%s;' % (f.name, f.name)
			else:
				print '   disp->%s = _mesa_%s;' % (f.name, f.name)

			last_condition_string = condition_string

		if last_condition_string:
			print '#endif /* %s */' % (last_condition_string)

	def printBody(self, api):
		abi = [ "1.0", "1.1", "1.2", "GL_ARB_multitexture" ]

		print 'void driver_init_exec_table(struct _glapi_table *disp)'
		print '{'
		self.do_function_body(api, abi, 0)
		print '}'
		print ''
		print 'void driver_install_vtxfmt(struct _glapi_table *disp, const GLvertexformat *vfmt)'
		print '{'
		self.do_function_body(api, abi, 1)
		print '}'

		return

def show_usage():
	print "Usage: %s [-f input_file_name] [-m output_mode]" % sys.argv[0]
	print "    -m output_mode   Output mode can be one of 'extensions' or 'exec_init'."
	sys.exit(1)

if __name__ == '__main__':
	file_name = "gl_API.xml"

	try:
		(args, trail) = getopt.getopt(sys.argv[1:], "f:m:")
	except Exception,e:
		show_usage()

	mode = "extensions"
	for (arg,val) in args:
		if arg == "-f":
			file_name = val
		if arg == '-m':
			mode = val

	api = gl_XML.parse_GL_API( file_name )

	if mode == "extensions":
		printer = PrintGlExtensionGlue()
	elif mode == "exec_init":
		printer = PrintInitDispatch()
	else:
		show_usage()

	printer.Print( api )


text:
#!/System/Library/Frameworks/Ruby.framework/Versions/1.8/usr/bin/ruby -W0

require "yaml"
require "rails_bundle_tools"
require "progress"
require "current_word"

module TextMate
  class ListColumns
    CACHE_DIR      = File.join(TextMate.project_directory, "tmp", "textmate")
    CACHE_FILE     = File.join(CACHE_DIR, "cache.yml")
    RELOAD_MESSAGE = "Reload database schema..."
    RAILS_REGEX    = /^Rails (\d\.?){3}(\w+)?$/

    def run!
      TextMate.exit_show_tool_tip("Place cursor on class name (or variation) to show its schema") if current_word.nil? || current_word.empty?
      # TextMate.exit_show_tool_tip("You don't have Rails installed in this gemset.") unless rails_present?

      klass = Inflector.singularize(Inflector.underscore(current_word))

      if cache[klass]
        display_menu(klass)
      elsif cache[klass_without_undescore = klass.split('_').last]
        display_menu(klass_without_undescore)
      else
        options = [
          @error || "'#{Inflector.camelize(klass)}' is not an Active Record derived class or was not recognised as a class.",
          nil,
          cache.keys.map { |model_name| "Use #{Inflector.camelize(model_name)}..." }.sort,
          nil,
          RELOAD_MESSAGE
        ].flatten
        selected = TextMate::UI.menu(options)

        return if selected.nil?

        case options[selected]
        when options.first
          if @error && @error =~ /^#{TextMate.project_directory}(.+?)[:]?(\d+)/
            TextMate.open(File.join(TextMate.project_directory, $1), $2.to_i)
          else
            klass_file = File.join(TextMate.project_directory, "/app/models/#{klass}.rb")
            TextMate.open(klass_file) if File.exist?(klass_file)
          end
        when RELOAD_MESSAGE
          cache_attributes and run!
        else
          klass = Inflector.singularize(Inflector.underscore(options[selected].split[1].delete('...')))
          clone_cache(klass, current_word) and display_menu(current_word)
        end
      end
    end

   private
    def clone_cache(klass, new_word)
      cached_model = cache[klass]
      cache[new_word] = cached_model

      File.open(CACHE_FILE, 'w') { |out| YAML.dump(cache, out ) }
    end

    def display_menu(klass)
      columns      = cache[klass][:columns]
      associations = cache[klass][:associations]

      options = associations.empty? ? [] : associations + [nil]
      options += columns + [nil, RELOAD_MESSAGE]

      selected = TextMate::UI.menu(options)
      return if selected.nil?

      if options[selected] == RELOAD_MESSAGE
        cache_attributes and run!
      else
        TextMate.exit_insert_text(options[selected])
      end
    end

    def cache
      Dir.mkdir(CACHE_DIR) unless File.exists?(CACHE_DIR)
      @cache ||= File.exist?(CACHE_FILE) ? YAML.load(File.read(CACHE_FILE)) : cache_attributes
    end

    def cache_attributes
      _cache = {}
      File.delete(CACHE_FILE) if File.exists?(CACHE_FILE)

      TextMate.call_with_progress(:title => "Contacting database", :message => "Fetching database schema...") do
        begin
          require "#{TextMate.project_directory}/config/environment"

          Dir.glob(File.join(Rails.root, "app/models/**/*.rb")) do |file|
            klass = File.basename(file, '.*').camelize.constantize rescue nil

            if klass and klass.class.is_a?(Class) and klass.ancestors.include?(ActiveRecord::Base)
              _cache[klass.name.underscore] = { :associations => klass.reflections.stringify_keys.keys, :columns => klass.column_names }
            end
          end

          File.open(CACHE_FILE, 'w') { |out| YAML.dump(_cache, out ) }

        rescue Exception => e
          @error_message = "Fix it: #{e.message}"
        end
      end

      return _cache
    end

    def current_word
      @current_word ||= Word.current_word('a-zA-Z0-9.', :left).split('.').last
    end

    def rails_present?
      rails_version_command = "rails -v 2> /dev/null"
      return `#{rails_version_command}` =~ RAILS_REGEX || `bundle exec #{rails_version_command}` =~ RAILS_REGEX
    end

  end
end

TextMate::ListColumns.new.run!


text:
/**
 * Created by z.stefano.imparato on 07/03/2015.
 */
var src2config = require(__dirname+"\\lib\\src-to-config", {
        nojs: true
    })(),
    fs = require("fs"),
    args = process.argv,
    file = args[2];

    if(args.length < 2){
        console.error("Not enough arguments. Run 'node app.js file-path/file.extension' ");
        if(!file) console.log("No files passed");
    }

    fs.readFile(file, "utf-8", function(err, data){
        if(err) console.error("Something wrong while reading file" + err);
        src2config.convert(data);
    })


text:
using System;
using System.Collections.Generic;
using System.Diagnostics;
using System.Linq;
using System.Threading.Tasks;
using DataSphere.Plugins.RandomGeneratorExample;
using Newtonsoft.Json;
using Tweetinvi;
using Tweetinvi.Models;

namespace DataSphere.Plugins.Twitter
{
    public class Program
    {
        public static void Main(string[] args)
        {
            string filter = String.Empty;
            while (String.IsNullOrWhiteSpace(filter))
            {
                Console.WriteLine("What do you want to display? ");
                filter = Console.ReadLine();
            }

            Common.DataSphereClient client = new Common.DataSphereClient("127.0.0.1", 9001);
            Auth.SetUserCredentials(args[0], args[1], args[2], args[3]);

            var stream = Stream.CreateFilteredStream();
            stream.AddTrack(filter);
            stream.MatchingTweetReceived += (sender, message) =>
            {
                //Console.WriteLine("A tweet containing " + filter + " has been found; the tweet is '" + message.Tweet + "'");
                var tweet = JsonConvert.DeserializeObject<TweetViewModel>(message.Json);
                if (tweet?.place?.boundingBox != null)
                {
                    foreach (var box in tweet.place.boundingBox.coordinates)
                    {
                        foreach (var coordinate in box)
                        {
                            SubmitMessage(client, coordinate);
                            break;
                        }
                    }
                }
                //foreach (var location in message.MatchingLocations)
                //{
                //    SubmitMessage(client, location.Coordinate1);
                //    SubmitMessage(client, location.Coordinate2);
                //}
            };
            stream.StartStreamMatchingAllConditions();

            while (true)
            {
                Task.Delay(1000);
                Console.WriteLine("Waiting...");
            }
        }

        private static void SubmitMessage(Common.DataSphereClient client, double[] coordinate)
        {
            if (coordinate != null)
            {
                Console.WriteLine("GRAPHING COORDINATE: " + coordinate);
                var dataPoint = new DataPointViewModel()
                {
                    color = new DataPointColor(),
                    declination = (float) coordinate[0]/360.0f,
                    rightAscension = (float) (coordinate[1])/90.0f
                };
                var message = JsonConvert.SerializeObject(dataPoint);
                client.SendMessageToServerTaskAsync(message);
            }
        }
    }
}


text:
<!DOCTYPE HTML PUBLIC "-//W3C//DTD HTML 4.01 Transitional//EN" "http://www.w3.org/TR/html4/loose.dtd">

<TITLE>
Uses of Package net.authorize.aim (Authorize.Net Java SDK)
</TITLE>

<META NAME="date" CONTENT="2011-07-18">

<LINK REL ="stylesheet" TYPE="text/css" HREF="../../../stylesheet.css" TITLE="Style">

      Overview
      Package
      Class
    Use
      Tree
      Deprecated
      Index
      Help

 PREV
 NEXT

  FRAMES
 NO FRAMES

  All Classes

Uses of Package
net.authorize.aim

Packages that use net.authorize.aim

net.authorize

net.authorize.aim

Classes in net.authorize.aim used by net.authorize

Transaction

          Container to hold all payment related information that gets passed back and
 forth to the payment gateway.

Classes in net.authorize.aim used by net.authorize.aim

Result

          Extends the core net.authorize.xml.Result for specific AIM result data.

Transaction

          Container to hold all payment related information that gets passed back and
 forth to the payment gateway.

      Overview
      Package
      Class
    Use
      Tree
      Deprecated
      Index
      Help

 PREV
 NEXT

  FRAMES
 NO FRAMES

  All Classes


text:
.class public interface abstract Lcom/android/settings/network/MobilePlanPreferenceController$MobilePlanPreferenceHost;
.super Ljava/lang/Object;
.source "MobilePlanPreferenceController.java"

# annotations
.annotation system Ldalvik/annotation/EnclosingClass;
    value = Lcom/android/settings/network/MobilePlanPreferenceController;
.end annotation

.annotation system Ldalvik/annotation/InnerClass;
    accessFlags = 0x609
    name = "MobilePlanPreferenceHost"
.end annotation

# virtual methods
.method public abstract showMobilePlanMessageDialog()V
.end method


text:
// Copyright 2009 The Closure Library Authors. All Rights Reserved.
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
//      http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS-IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.

/**
 * @fileoverview provides a reusable youtube UI component given a youtube data
 * model.
 *
 * goog.ui.media.Youtube is actually a {@link goog.ui.ControlRenderer}, a
 * stateless class - that could/should be used as a Singleton with the static
 * method {@code goog.ui.media.Youtube.getInstance} -, that knows how to render
 * youtube videos. It is designed to be used with a {@link goog.ui.Control},
 * which will actually control the media renderer and provide the
 * {@link goog.ui.Component} base. This design guarantees that all different
 * types of medias will behave alike but will look different.
 *
 * goog.ui.media.Youtube expects {@code goog.ui.media.YoutubeModel} on
 * {@code goog.ui.Control.getModel} as data models, and render a flash object
 * that will play that URL.
 *
 * Example of usage:
 *
 *

 *   var video = goog.ui.media.YoutubeModel.newInstance(
 *       'http://www.youtube.com/watch?v=ddl5f44spwQ');
 *   goog.ui.media.Youtube.newControl(video).render();
 *

 *
 * youtube medias currently support the following states:
 *
 *

 *
 {@link goog.ui.Component.State.DISABLED}: shows 'flash not available'
 *
 {@link goog.ui.Component.State.HOVER}: mouse cursor is over the video
 *
 {@link !goog.ui.Component.State.SELECTED}: a static thumbnail is shown
 *
 {@link goog.ui.Component.State.SELECTED}: video is playing
 *

 *
 * Which can be accessed by
 *

 *   youtube.setEnabled(true);
 *   youtube.setHighlighted(true);
 *   youtube.setSelected(true);
 *

 *
 * This package also provides a few static auxiliary methods, such as:
 *
 *

 * var videoId = goog.ui.media.Youtube.parseUrl(
 *     'http://www.youtube.com/watch?v=ddl5f44spwQ');
 *

 *
 *
 * @supported IE6, FF2+, Safari. Requires flash to actually work.
 *
 * TODO(user): test on other browsers
 */

goog.provide('goog.ui.media.Youtube');
goog.provide('goog.ui.media.YoutubeModel');

goog.require('goog.dom.TagName');
goog.require('goog.html.uncheckedconversions');
goog.require('goog.string');
goog.require('goog.ui.Component');
goog.require('goog.ui.media.FlashObject');
goog.require('goog.ui.media.Media');
goog.require('goog.ui.media.MediaModel');
goog.require('goog.ui.media.MediaRenderer');

/**
 * Subclasses a goog.ui.media.MediaRenderer to provide a Youtube specific media
 * renderer.
 *
 * This class knows how to parse youtube urls, and render the DOM structure
 * of youtube video players and previews. This class is meant to be used as a
 * singleton static stateless class, that takes {@code goog.ui.media.Media}
 * instances and renders it. It expects {@code goog.ui.media.Media.getModel} to
 * return a well formed, previously constructed, youtube video id, which is the
 * data model this renderer will use to construct the DOM structure.
 * {@see goog.ui.media.Youtube.newControl} for a example of constructing a
 * control with this renderer.
 *
 * goog.ui.media.Youtube currently supports all {@link goog.ui.Component.State}.
 * It will change its DOM structure between SELECTED and !SELECTED, and rely on
 * CSS definitions on the others. On !SELECTED, the renderer will render a
 * youtube static , with a thumbnail of the video. On SELECTED, the
 * renderer will append to the DOM a flash object, that contains the youtube
 * video.
 *
 * This design is patterned after http://go/closure_control_subclassing
 *
 * It uses {@link goog.ui.media.FlashObject} to embed the flash object.
 *
 * @constructor
 * @extends {goog.ui.media.MediaRenderer}
 * @final
 */
goog.ui.media.Youtube = function() {
  goog.ui.media.MediaRenderer.call(this);
};
goog.inherits(goog.ui.media.Youtube, goog.ui.media.MediaRenderer);
goog.addSingletonGetter(goog.ui.media.Youtube);

/**
 * A static convenient method to construct a goog.ui.media.Media control out of
 * a youtube model. It sets it as the data model goog.ui.media.Youtube renderer
 * uses, sets the states supported by the renderer, and returns a Control that
 * binds everything together. This is what you should be using for constructing
 * Youtube videos, except if you need finer control over the configuration.
 *
 * @param {goog.ui.media.YoutubeModel} youtubeModel The youtube data model.
 * @param {goog.dom.DomHelper=} opt_domHelper Optional DOM helper, used for
 *     document interaction.
 * @return {!goog.ui.media.Media} A Control binded to the youtube renderer.
 */
goog.ui.media.Youtube.newControl = function(youtubeModel, opt_domHelper) {
  var control = new goog.ui.media.Media(
      youtubeModel, goog.ui.media.Youtube.getInstance(), opt_domHelper);
  control.setStateInternal(goog.ui.Component.State.ACTIVE);
  return control;
};

/**
 * Default CSS class to be applied to the root element of components rendered
 * by this renderer.
 * @type {string}
 */
goog.ui.media.Youtube.CSS_CLASS = goog.getCssName('goog-ui-media-youtube');

/**
 * Changes the state of a {@code control}. Currently only changes the DOM
 * structure when the youtube movie is SELECTED (by default fired by a MOUSEUP
 * on the thumbnail), which means we have to embed the youtube flash video and
 * play it.
 *
 * @param {goog.ui.Control} c The media control.
 * @param {goog.ui.Component.State} state The state to be set or cleared.
 * @param {boolean} enable Whether the state is enabled or disabled.
 * @override
 */
goog.ui.media.Youtube.prototype.setState = function(c, state, enable) {
  var control = /** @type {goog.ui.media.Media} */ (c);
  goog.ui.media.Youtube.superClass_.setState.call(this, control, state, enable);

  // control.createDom has to be called before any state is set.
  // Use control.setStateInternal if you need to set states
  if (!control.getElement()) {
    throw Error(goog.ui.Component.Error.STATE_INVALID);
  }

  var domHelper = control.getDomHelper();
  var dataModel =
      /** @type {goog.ui.media.YoutubeModel} */ (control.getDataModel());

  if (!!(state & goog.ui.Component.State.SELECTED) && enable) {
    var flashEls = domHelper.getElementsByTagNameAndClass(
        goog.dom.TagName.DIV, goog.ui.media.FlashObject.CSS_CLASS,
        control.getElement());
    if (flashEls.length > 0) {
      return;
    }
    var youtubeFlash = new goog.ui.media.FlashObject(
        dataModel.getPlayer().getTrustedResourceUrl(), domHelper);
    control.addChild(youtubeFlash, true);
  }
};

/**
 * Returns the CSS class to be applied to the root element of components
 * rendered using this renderer.
 *
 * @return {string} Renderer-specific CSS class.
 * @override
 */
goog.ui.media.Youtube.prototype.getCssClass = function() {
  return goog.ui.media.Youtube.CSS_CLASS;
};

/**
 * The {@code goog.ui.media.Youtube} media data model. It stores a required
 * {@code videoId} field, sets the youtube URL, and allows a few optional
 * parameters.
 *
 * @param {string} videoId The youtube video id.
 * @param {string=} opt_caption An optional caption of the youtube video.
 * @param {string=} opt_description An optional description of the youtube
 *     video.
 * @constructor
 * @extends {goog.ui.media.MediaModel}
 * @final
 */
goog.ui.media.YoutubeModel = function(videoId, opt_caption, opt_description) {
  goog.ui.media.MediaModel.call(
      this, goog.ui.media.YoutubeModel.buildUrl(videoId), opt_caption,
      opt_description, goog.ui.media.MediaModel.MimeType.FLASH);

  /**
   * The Youtube video id.
   * @type {string}
   * @private
   */
  this.videoId_ = videoId;

  this.setThumbnails([new goog.ui.media.MediaModel.Thumbnail(
      goog.ui.media.YoutubeModel.getThumbnailUrl(videoId))]);

  this.setPlayer(
      new goog.ui.media.MediaModel.Player(
          goog.ui.media.YoutubeModel.getFlashUrl(videoId, true)));
};
goog.inherits(goog.ui.media.YoutubeModel, goog.ui.media.MediaModel);

/**
 * A youtube regular expression matcher. It matches the VIDEOID of URLs like
 * http://www.youtube.com/watch?v=VIDEOID. Based on:
 * googledata/contentonebox/opencob/specs/common/YTPublicExtractorCard.xml
 * @type {RegExp}
 * @private
 * @const
 */
// Be careful about the placement of the dashes in the character classes. Eg,
// use "[\\w=-]" instead of "[\\w-=]" if you mean to include the dash as a
// character and not create a character range like "[a-f]".
goog.ui.media.YoutubeModel.MATCHER_ = new RegExp(
    // Lead in.
    'https?://(?:[a-zA-Z]{1,3}\\.)?' +
        // Watch short URL prefix. This should handle URLs of the form:
        // https://youtu.be/jqxENMKaeCU?cgiparam=value
        '(?:(?:youtu\\.be/([\\w-]+)(?:\\?[\\w=&-]+)?)|' +
        // Watch URL prefix.  This should handle new URLs of the form:
        // http://www.youtube.com/watch#!v=jqxENMKaeCU&feature=related
        // where the parameters appear after "#!" instead of "?".
        '(?:youtube\\.com/watch)' +
        // Get the video id:
        // The video ID is a parameter v=[videoid] either right after the "?"
        // or after some other parameters.
        '(?:\\?(?:[\\w=-]+&(?:amp;)?)*v=([\\w-]+)' +
        '(?:&(?:amp;)?[\\w=-]+)*)?' +
        // Get any extra arguments in the URL's hash part.
        '(?:#[!]?(?:' +
        // Video ID from the v=[videoid] parameter, optionally surrounded by
        // other
        // & separated parameters.
        '(?:(?:[\\w=-]+&(?:amp;)?)*(?:v=([\\w-]+))' +
        '(?:&(?:amp;)?[\\w=-]+)*)' +
        '|' +
        // Continue supporting "?" for the video ID
        // and "#" for other hash parameters.
        '(?:[\\w=&-]+)' +
        '))?)' +
        // Should terminate with a non-word, non-dash (-) character.
        '[^\\w-]?',
    'i');

/**
 * A auxiliary static method that parses a youtube URL, extracting the ID of the
 * video, and builds a YoutubeModel.
 *
 * @param {string} youtubeUrl A youtube URL.
 * @param {string=} opt_caption An optional caption of the youtube video.
 * @param {string=} opt_description An optional description of the youtube
 *     video.
 * @return {!goog.ui.media.YoutubeModel} The data model that represents the
 *     youtube URL.
 * @see goog.ui.media.YoutubeModel.getVideoId()
 * @throws Error in case the parsing fails.
 */
goog.ui.media.YoutubeModel.newInstance = function(
    youtubeUrl, opt_caption, opt_description) {
  var extract = goog.ui.media.YoutubeModel.MATCHER_.exec(youtubeUrl);
  if (extract) {
    var videoId = extract[1] || extract[2] || extract[3];
    return new goog.ui.media.YoutubeModel(
        videoId, opt_caption, opt_description);
  }

  throw Error('failed to parse video id from youtube url: ' + youtubeUrl);
};

/**
 * The opposite of {@code goog.ui.media.Youtube.newInstance}: it takes a videoId
 * and returns a youtube URL.
 *
 * @param {string} videoId The youtube video ID.
 * @return {string} The youtube URL.
 */
goog.ui.media.YoutubeModel.buildUrl = function(videoId) {
  return 'http://www.youtube.com/watch?v=' + goog.string.urlEncode(videoId);
};

/**
 * A static auxiliary method that builds a static image URL with a preview of
 * the youtube video.
 *
 * NOTE(user): patterned after Gmail's gadgets/youtube,
 *
 * TODO(user): how do I specify the width/height of the resulting image on the
 * url ? is there an official API for http://ytimg.com ?
 *
 * @param {string} youtubeId The youtube video ID.
 * @return {string} An URL that contains an image with a preview of the youtube
 *     movie.
 */
goog.ui.media.YoutubeModel.getThumbnailUrl = function(youtubeId) {
  return 'http://i.ytimg.com/vi/' + youtubeId + '/default.jpg';
};

/**
 * A static auxiliary method that builds URL of the flash movie to be embedded,
 * out of the youtube video id.
 *
 * @param {string} videoId The youtube video ID.
 * @param {boolean=} opt_autoplay Whether the flash movie should start playing
 *     as soon as it is shown, or if it should show a 'play' button.
 * @return {!goog.html.TrustedResourceUrl} The flash URL to be embedded on the
 *     page.
 */
goog.ui.media.YoutubeModel.getFlashUrl = function(videoId, opt_autoplay) {
  var autoplay = opt_autoplay ? '&autoplay=1' : '';
  // YouTube video ids are extracted from youtube URLs, which are user
  // generated input. the video id is later used to embed a flash object,
  // which is generated through HTML construction. We goog.string.urlEncode
  // the video id to make sure the URL is safe to be embedded.
  return goog.html.uncheckedconversions.
      trustedResourceUrlFromStringKnownToSatisfyTypeContract(
          goog.string.Const.from('Fixed domain, encoded path.'),
          'http://www.youtube.com/v/' + goog.string.urlEncode(videoId) +
              '&hl=en&fs=1' + autoplay);
};

/**
 * Gets the Youtube video id.
 * @return {string} The Youtube video id.
 */
goog.ui.media.YoutubeModel.prototype.getVideoId = function() {
  return this.videoId_;
};


text:
/*
 * Auth* provider and manager
 **/
module.exports = rbac_setup

function rbac_setup(cfg){
var dir, rbac_api, fs = require('fs')

    rbac_api = {
        fuses_can: null,// permission fuses
        can: null, roles: null, users: null,// rbac data
        merge: merge_rbac_from_others,
        // API: manager for UI
        mwRBAC: mwRBAC
    }

    default_access_data()
    expand_can_arrays()

    dir = process.cwd() + cfg.data + '/rbac'

    fs.stat(dir,
    function stat_um_data_rbac_dir(err, d){
        if(err){
            require('mkdirp').mkdirp(dir,
            function mkdirp_um_data_rbac_dir(err){
                if(err) throw(err)
                //load_api()
            }
            )
            return
        }
        if(!d.isDirectory()){
            throw new Error('Is not a directory: ' + dir)
        }
        //load_api()// init api
    }
    )

    return rbac_api

    function default_access_data(){
    var fuse, backend_js_class, backend_js_api

        fuse = rbac_api.fuses_can = rbac_api_fuses_can_setup()
        /* Protection of permissions */
        // this module can be implemented or copied by third party
        // this is just an example of permissions protection
        backend_js_class = 'App.backend.JS'// depends on `pingback` app_module
        backend_js_api = '/pingback'
        fuse(backend_js_class, true)// setup fuse permissions
        fuse(backend_js_api, true)
        fuse('module.*', true)
        /* set of permissions */
        rbac_api.can = {
            backend:[// union of permissions to be expanded in role by auth
                'App.view.desktop.BackendTools'// UI classes
                ,fuse(backend_js_class)// annotated secure permission used
                ,fuse(backend_js_api)// annotated secure permission used
            ]
           ,'App.um.wes': true// `wes` UI + API are included by default in roles
           ,'/um/lib/wes': true
           ,userman:[
                '/um/',// all backend API calls (URL based)
                'App.um.controller.Userman',// simple single permissions
                'App.um.view.Userman'
            ]
           ,chat:[
                '/um/lib/chat'// backend API calls (URL based)
                ,'App.um.wes', '/um/lib/wes'// NOTE: include this for any role
                //NOTE: 'App.um.model.chatUser' is accessible if not listed here
                ,'App.um.view.Chat'
                ,'App.um.controller.Chat'
           ]
            //// simple permissions, e.g.:
            //,'App.um.view.Chat': true
            //// has no practical use, because they are duplicated in roles

           ,Static:{
            // by default deny access to Class or other files by `initAuth()`
            }
           ,API:[ ]// by default deny access to API calls (iterate array of subsets)
        }
        /* set of roles */
        rbac_api.roles = {// 'role': new Array(of `can`s)
            'developer.local':[
                rbac_api.can.backend// can do all from specified `can` block
               ,rbac_api.can.chat
               ,rbac_api.can.userman
               ,'App.view.Window->tools.refresh'// developer's stuff
               ,fuse('module.*')// allow any app module to load
            ]
           ,'admin.local':[
                'App.view.desktop.BackendTools',
                'module.example',// if enabled in config will be allowed
                'module.enjsms',
                rbac_api.can.chat
           ]
           ,'enjsms+chat':[
                'module.enjsms',// order is not followed in shortcuts
                //'/um/lib/rbac', allow e.g. `App.backend.req('/um/lib/rbac/can')`
                rbac_api.can.chat
           ]
           //,'developer':[ fuse(backend_js_class) ]
        }
        fuse(backend_js_class, false)// deny access by this permission for others
        fuse(backend_js_api, false)// deny access by this permission for others
        fuse('module.*', false)
        /* set of users */
        rbac_api.users = {
            dev:{
                id: 'dev',
                // require('crypto').createHash('sha1').update(pass).digest('hex')
                pass: '9d4e1e23bd5b727046a9e3b4b7db57bd8d6ee684',
                roles:[ 'developer.local', 'admin.local' ],
                name: 'full dev login'
            }
            ,admin:{
                id: 'admin',
                pass: '9d4e1e23bd5b727046a9e3b4b7db57bd8d6ee684',
                roles:[ 'admin.local' ],
                name: 'admin login'
            }
            ,test:{
                id: 'test',
                pass: '9d4e1e23bd5b727046a9e3b4b7db57bd8d6ee684',
                roles:[ 'enjsms+chat' ],
                name: 'test login'
            }
        }
    }

    function expand_can_arrays(){
    var a, p, i, can

        can = rbac_api.can
        secure = rbac_api.fuses_can
        for(p in can){
console.log('eca p: ' + p)
            if(Array.isArray(a = can[p])){
console.log('eca a: ', a)
                for(i = 0; i < a.length; ++i){
                    can[a[i]] = true// secured permissions are in general list also
                }
            }
        }
    }

    function rbac_api_fuses_can_setup(){
   /*
    * Fuse annotations of the permissions means they can be defined only in
    * arrays of permissions i.e.:
    *
    *    fuse('permission_name', true)
    *    rbac_api.can = {
    *        backend:[// a block of permissions
    *            'App.view.desktop.BackendTools'// UI classes
    *            ,fuse('permission_name')// special annotated permission
    *        ]
    *    }
    *    fuse('permission_name', false)// lock it
    *
    * then all added permissions from all sources are being checked against
    * this secure list thus preventing them to appear in `rbac_api.can` and
    * allow anything
    **/
    var fuses_can = {/*// check for this in auth; examples:
            'module.*': true
           ,'App.backend.JS': true// depends on `pingback` app_module */
        }
        return function rbac_api_fuses_can(id, val){// closesure with `fuses_can`
            // assign value to permission; if it is false then permission
            // is disabled and denied further (for some reason)
            if('undefined' != typeof val){// don't override false permission
                if(fuses_can.hasOwnProperty(id) && !fuses_can[id]){
                    return ''// exists, but false
                }
                return (fuses_can[id] = (val === true)) ? id : ''
            }

            if(fuses_can.hasOwnProperty(id)){
               return fuses_can[id] ? id : ''
            }
            return null// no such permission in `fuses_can`
        }
    }

    function merge_rbac_from_others(rbac){
    /* to `rbac_api` form e.g: `cfg.modules.userman.rbac`:{
            can:{
                'module.pingback': true
               ,'module.enjsms': true
            }
           ,roles:{
                'user.test':[
                    'module.enjsms'
                ]
            }
           ,users:{
                test:{
                    pass: '9d4e1e23bd5b727046a9e3b4b7db57bd8d6ee684',
                    roles: [ 'user.test' ],
                    name: 'test user'
                }
            }
        }
     **/
        if(!rbac) return

        if(0 == rbac_api.can.API.length){
            log(
'Coding error: empty `rbac_api.can.API`; use `merge_rbac*()` _after_ `initAuth()`'
            )
        }

        var i, j, k, m, ii, src, dst, secure

        secure = rbac_api.fuses_can
        for(i in rbac){
            if(!rbac_api.hasOwnProperty(i)){// check if `rbac_api` has such category
log('!Security `merge_rbac`: overwrite attempt of "' + i + '"')
                continue// don't allow anything from untrusted sources
            }
            src = rbac[i], dst = rbac_api[i]
            for(j in src){// from source to destination
                if(dst.hasOwnProperty(j)){
//log('!Security `merge_rbac`: overwrite attempt of `' + i + '["' + j + '"]`')
                    // new: just skip `can` that exists already
                    continue// don't allow overwrite anything
                }
                if('can' == i){
                    if(Array.isArray(src[j])){
log('`merge_rbac`: skip array can.' + j)
                        continue// disable arrays (nothing can be there)
                    }
                    if(null !== secure(j)){
log('!Security `merge_rbac`: skip secure permission "' + j + '"')
                        continue// there is such permission in `fuses_can`
                    }
                } else if('roles' == i){// check perms thru `fuses_can`
                    if(!Array.isArray((m = src[j]))){
                        continue// skip
                    }// role_name: [ ]

//log('merge role m: ' + m)
                    for(k = 0; k < m.length; ++k){
//log('merge role m[k]: ' + m[k])
                        if(null !== secure(m[k])){
log('!Security `merge_rbac`: reject role secure permission "' + m[k] + '"')
                            m[k] = ''// there is such permission in `fuses_can`
                        }/* else {// check API subsets
//log('merge role API: ', rbac_api.can.API)
                            for(ii = 0; ii < rbac_api.can.API.length; ++ii){
                            // all API must heve permission
//log('merge role API[ii]: ' + rbac_api.can.API[ii])
                                if(0 == rbac_api.can.API[ii].indexOf(m[k])){
                                // j: "/p", API[i]: '/pingback'
                                    log(
'!Security `merge_rbac`: skip secure API subset "' +
                                        m[k] + '" in role "'+ j + '"'
                                    )
                                    m[k] = ''???
                                    break
                    // stop scan; deny subsets of API from app modules
                    // ??? what app modules ???
                                }
                            }
                        }*/
                    }
                }
                dst[j] = src[j]
            }
        }//TODO: merge l10n from config to global l10n
    }

    function mwRBAC(req, res, next){// manage permissions, roles, users sets
    var ret = { success: true, data: { }}//                             \.../
    var m = req.url.slice(1, 5)// UI call: App.backend.req('/um/lib/rbac/can')

        switch (m){// API is protected, thus `req.session` must be valid
            case 'can': req.session.can && (ret.data = req.session.can)
                break
            case 'all': ret.data = rbac_api
                break
            default:break
        }

        return res.json(ret)// big fat todo
    }
}


text:
package org.openkilda.rulemanager.factory.generator.service.arp;

import static org.openkilda.model.cookie.Cookie.ARP_INGRESS_COOKIE;

import org.openkilda.model.Switch;
import org.openkilda.model.cookie.Cookie;
import org.openkilda.rulemanager.Constants.Priority;
import org.openkilda.rulemanager.Field;
import org.openkilda.rulemanager.Instructions;
import org.openkilda.rulemanager.OfTable;
import org.openkilda.rulemanager.RuleManagerConfig;
import org.openkilda.rulemanager.SpeakerData;
import org.openkilda.rulemanager.match.FieldMatch;
import org.openkilda.rulemanager.utils.RoutingMetadata;

import com.google.common.collect.Sets;
import lombok.Builder;

import java.util.List;
import java.util.Set;

public class ArpIngressRuleGenerator extends ArpRuleGenerator {

    @Builder
    public ArpIngressRuleGenerator(RuleManagerConfig config) {
        super(config);
    }

    @Override
    public List<SpeakerData> generateCommands(Switch sw) {
        RoutingMetadata metadata = buildMetadata(RoutingMetadata.builder().arpFlag(true), sw);
        Set<FieldMatch> match = Sets.newHashSet(
                FieldMatch.builder().field(Field.METADATA).value(metadata.getValue()).mask(metadata.getMask()).build()
        );

        Instructions instructions = buildSendToControllerInstructions();

        Cookie cookie = new Cookie(ARP_INGRESS_COOKIE);
        return buildCommands(sw, cookie, OfTable.INGRESS, Priority.ARP_INGRESS_PRIORITY, match, instructions);
    }
}


text:
package org.apache.gobblin.source.extractor;

import com.google.gson.Gson;
import com.google.gson.JsonElement;

/**
 * Implementation of {@link Watermark} used for testing purposes in {@link TestWatermark}.
 */
public class TestWatermark implements Watermark {

  private static final Gson GSON = new Gson();

  private long watermark = -1;

  @Override
  public JsonElement toJson() {
    return WatermarkSerializerHelper.convertWatermarkToJson(this);
  }

  @Override
  public short calculatePercentCompletion(Watermark lowWatermark, Watermark highWatermark) {
    TestWatermark testLowWatermark = GSON.fromJson(lowWatermark.toJson(), TestWatermark.class);
    TestWatermark testHighWatermark = GSON.fromJson(highWatermark.toJson(), TestWatermark.class);
    return (short) (100 * (this.watermark - testLowWatermark.getLongWatermark()) / (testHighWatermark
        .getLongWatermark() - testLowWatermark.getLongWatermark()));
  }

  public void setLongWatermark(long watermark) {
    this.watermark = watermark;
  }

  public long getLongWatermark() {
    return this.watermark;
  }
}


text:
set -eou pipefail

underline() {
    echo "$2"
    printf "%0.s$1" $(seq ${#2})
}

log() { echo "$@" >&2; }
title() { underline "=" "$@"; }
section() { underline "-" "$@"; }

#
# All sorts of content
#
release_notes() {
    log "Fetching release notes"
    cat manual-release-notes || echo "FIXME manual notes needed"
}

summary() {
    log "Building summary"
    echo "This release follows $PREREF and consists of $(git log --oneline $RELSPANREF | wc -l) changes, contributed by"
    echo -n "$(git shortlog -sne $RELSPANREF | wc -l) people, leading to"
    echo "$(git diff --shortstat $RELSPANREF)."
}

downloads() {
    log "Adding download urls"
    local GHRELURL="https://github.com/kubevirt/containerized-data-importer/releases/tag/"
    local RELURL="$GHRELURL$RELREF"
    cat <<EOF
The source code and selected binaries are available for download at:
<$RELURL>.

Pre-built CDI containers are published on Quay.io and can be viewed at:
<https://quay.io/repository/kubevirt/cdi-controller/>
<https://quay.io/repository/kubevirt/cdi-importer/>
<https://quay.io/repository/kubevirt/cdi-cloner/>
<https://quay.io/repository/kubevirt/cdi-uploadproxy/>
<https://quay.io/repository/kubevirt/cdi-apiserver/>
<https://quay.io/repository/kubevirt/cdi-uploadserver/>
<https://quay.io/repository/kubevirt/cdi-operator/>
EOF
}

shortlog() {
    git shortlog -sne --no-merges $RELSPANREF | sed "s/^/    /"
}

usage() {
    echo "Usage: $0 [RELEASE_REF] [PREV_RELEASE_REF]"
}

main() {
    log "Span: $RELSPANREF"
    cat <<EOF | tee release-announcement
$(summary)

$(downloads)

$(section "Notable changes")

$(release_notes)

$(section "Contributors")

$(git shortlog -sne $RELSPANREF | wc -l) people contributed to this release:

$(shortlog)

Additional Resources
--------------------
- Mailing list: <https://groups.google.com/forum/#!forum/kubevirt-dev>
- [How to contribute][contributing]
- [License][license]

[contributing]: https://github.com/kubevirt/containerized-data-importer/blob/main/hack/README.md
[license]: https://github.com/kubevirt/containerized-data-importer/blob/main/LICENSE
EOF
}

#
# Let's get the party started
#
RELREF="$1"
PREREF="$2"
RELREF=${RELREF:-$(git describe --abbrev=0 --tags)}
PREREF=${PREREF:-$(git describe --abbrev=0 --tags $RELREF^)}
RELSPANREF=$PREREF..$RELREF

main

# vim: sw=2 et


text:
import uuid
import random
from django.contrib.postgres.search import SearchVector
from openstates.data.models import (
    Division,
    Jurisdiction,
    Organization,
    Person,
    Bill,
    VoteEvent,
    SearchableBill,
)
from openstates.importers.computed_fields import update_bill_fields

def make_random_bill(name):
    state = Jurisdiction.objects.get(name=name)
    session = random.choice(state.legislative_sessions.all())
    org = state.organizations.get(classification=random.choice(("upper", "lower")))
    b = Bill.objects.create(
        id="ocd-bill/" + str(uuid.uuid4()),
        title="Bill Title",
        identifier=(
            random.choice(("HB", "SB", "HR", "SR")) + str(random.randint(1000, 3000))
        ),
        legislative_session=session,
        from_organization=org,
        classification=[random.choice(["bill", "resolution"])],
        subject=[random.choice("abcdefghijklmnopqrstuvwxyz") for _ in range(10)],
    )
    b.actions.create(
        description="Introduced", order=10, organization=org, date="2018-01-01"
    )

    for n in range(random.randint(1, 2)):
        ve = VoteEvent.objects.create(
            bill=b,
            legislative_session=session,
            motion_text="Motion Text",
            organization=org,
            result=random.choice(("failed", "passed")),
        )
        ve.counts.create(option="yes", value=random.randint(0, 10))
        ve.counts.create(option="no", value=random.randint(0, 10))
        for m in range(random.randint(1, 5)):
            ve.votes.create(option=random.choice(("yes", "no")), voter_name="Voter")
    return b

def make_person(name, state, chamber, district, party):
    org = Organization.objects.get(jurisdiction__name=state, classification=chamber)
    party, _ = Organization.objects.get_or_create(classification="party", name=party)
    jurisdiction = Jurisdiction.objects.get(name=state)
    chamber_letter = chamber[0]
    if state == "Alaska":
        state = "ak"
    elif state == "Wyoming":
        state = "wy"
    elif state == "Nebraska":
        state = "ne"
        chamber_letter = "u"
    div, _ = Division.objects.get_or_create(
        id="ocd-division/country:us/state:{}/sld{}:{}".format(
            state, chamber_letter, district.lower()
        ),
        name="Division " + district,
    )
    post = org.posts.create(
        label=district,
        division=div,
        role="Representative" if chamber == "lower" else "Senator",
    )
    try:
        district = int(district)
    except ValueError:
        pass
    p = Person.objects.create(
        name=name,
        primary_party=party.name,
        current_jurisdiction=jurisdiction,
        current_role={
            "org_classification": chamber,
            "district": district,
            "division_id": div.id,
            "title": post.role,
        },
    )
    p.memberships.create(post=post, organization=org)
    p.memberships.create(organization=party)
    return p

def populate_db():
    for abbr, state in (("ak", "Alaska"), ("wy", "Wyoming")):
        d = Division.objects.create(
            id="ocd-division/country:us/state:" + abbr, name=state
        )
        j = Jurisdiction.objects.create(
            id="ocd-jurisdiction/country:us/state:" + abbr + "/government",
            name=state,
            division=d,
        )
        j.legislative_sessions.create(
            identifier="2017", name="2017", start_date="2017-01-01"
        )
        j.legislative_sessions.create(
            identifier="2018", name="2018", start_date="2018-01-01"
        )

        leg = Organization.objects.create(
            jurisdiction=j, classification="legislature", name=state + " Legislature"
        )
        Organization.objects.create(
            jurisdiction=j, parent=leg, classification="lower", name=state + " House"
        )
        Organization.objects.create(
            jurisdiction=j, parent=leg, classification="upper", name=state + " Senate"
        )

    alaska = Jurisdiction.objects.get(name="Alaska")
    house = alaska.organizations.get(classification="lower")

    # AK House
    amanda = make_person("Amanda Adams", "Alaska", "lower", "1", "Republican")
    birch = make_person("Bob Birch", "Alaska", "lower", "2", "Republican")
    carrie = make_person("Carrie Carr", "Alaska", "lower", "3", "Democratic")
    don = make_person("Don Dingle", "Alaska", "lower", "4", "Republican")
    # AK Senate
    ellen = make_person("Ellen Evil", "Alaska", "upper", "A", "Independent")
    make_person("Frank Fur", "Alaska", "upper", "B", "Democratic")
    # Ellen used to be a house member
    post = house.posts.create(label="5", role="Representative")
    ellen.memberships.create(post=post, organization=house, end_date="2017-01-01")

    # retired house member
    rhonda = make_person("Rhonda Retired", "Alaska", "upper", "B", "Democratic")
    for m in rhonda.memberships.all():
        m.end_date = "2017-01-01"
        m.save()
    rhonda.current_role = None
    rhonda.save()

    # WY House (multi-member districts)
    make_person("Greta Gonzalez", "Wyoming", "lower", "1", "Democratic")
    make_person("Hank Horn", "Wyoming", "lower", "1", "Republican")

    session = alaska.legislative_sessions.get(identifier="2018")
    b1 = Bill.objects.create(
        id="ocd-bill/1",
        title="Moose Freedom Act",
        identifier="HB 1",
        legislative_session=session,
        from_organization=house,
        classification=["bill", "constitutional amendment"],
        subject=["nature"],
    )
    b1.abstracts.create(abstract="Grants all moose equal rights under the law.")
    b1.abstracts.create(abstract="Ensure moose freedom.")
    b1.other_titles.create(title="Moosemendment")
    b1.other_titles.create(title="Moose & Reindeer Freedom Act")
    b1.other_titles.create(title="M.O.O.S.E.")
    b1.other_identifiers.create(identifier="HCA 1")
    b1.other_identifiers.create(identifier="SB 1")
    a = b1.actions.create(
        description="Introduced", order=10, organization=house, date="2018-01-01"
    )
    a.related_entities.create(name="Amanda Adams", entity_type="person", person=amanda)
    b1.actions.create(
        description="Amended", order=20, organization=house, date="2018-02-01"
    )
    a = b1.actions.create(
        description="Passed House",
        order=30,
        organization=house,
        date="2018-03-01",
        classification=["passage"],
    )
    a.related_entities.create(
        name="House", entity_type="organization", organization=house
    )

    b1.sponsorships.create(primary=True, classification="sponsor", name="Adam One")
    b1.sponsorships.create(
        primary=False, classification="cosponsor", name="Beth Two", person=amanda
    )

    d = b1.documents.create(note="Fiscal Note")
    d.links.create(url="https://example.com/fn")
    d = b1.documents.create(note="Legal Justification")
    d.links.create(url="https://example.com/lj")
    d = b1.versions.create(note="First Draft", date="2017-01-01")
    dlink = d.links.create(url="https://example.com/1.txt", media_type="text/plain")
    d.links.create(url="https://example.com/1.pdf", media_type="application/pdf")
    d = b1.versions.create(note="Final Draft", date="2017-06-01")
    d.links.create(url="https://example.com/f.txt", media_type="text/plain")
    d.links.create(url="https://example.com/f.pdf", media_type="application/pdf")
    b1.sources.create(url="https://example.com/s1")
    b1.sources.create(url="https://example.com/s2")
    b1.sources.create(url="https://example.com/s3")

    SearchableBill.objects.create(
        bill=b1,
        version_link=dlink,
        all_titles=b1.title,
        raw_text="shove some text in here and include a weird word like gorgonzola",
        is_error=False,
        search_vector="",
    )
    SearchableBill.objects.update(
        search_vector=(
            SearchVector("all_titles", weight="A", config="english")
            + SearchVector("raw_text", weight="B", config="english")
        )
    )

    ve = VoteEvent.objects.create(
        bill=b1,
        legislative_session=session,
        motion_text="Vote on House Passage",
        organization=house,
        result="failed",
    )
    ve.counts.create(option="yes", value=1)
    ve.counts.create(option="no", value=4)
    ve.votes.create(option="yes", voter_name="Amanda Adams", voter=amanda)
    ve.votes.create(option="no", voter_name="Birch", voter=birch)
    ve.votes.create(option="no", voter_name="Carr", voter=carrie)
    ve.votes.create(option="no", voter_name="Dingle", voter=don)
    ve.votes.create(option="no", voter_name="Speaker")

    rb = Bill.objects.create(
        id="ocd-bill/3",
        title="Alces alces Freedom Act",
        identifier="SB 9",
        legislative_session=session,
        from_organization=alaska.organizations.get(classification="upper"),
        classification=["bill", "constitutional amendment"],
        subject=["nature"],
    )
    b1.related_bills.create(
        related_bill=rb,
        identifier="SB 9",
        legislative_session="2018",
        relation_type="companion",
    )
    rb.sponsorships.create(
        primary=False, classification="cosponsor", name="Beth Two", person=amanda
    )

    for x in range(10):
        make_random_bill("Alaska")
    for x in range(14):
        make_random_bill("Wyoming")

    # populate bill computed data
    for bill in Bill.objects.all().filter(
        legislative_session__jurisdiction__name__in=["Alaska", "Wyoming"]
    ):
        update_bill_fields(bill)

def populate_unicam():
    d = Division.objects.create(id="ocd-division/country:us/state:ne", name="Nebraska")
    j = Jurisdiction.objects.create(
        id="ocd-jurisdiction/country:us/state:ne/government",
        name="Nebraska",
        division=d,
    )
    j.legislative_sessions.create(
        identifier="2017", name="2017", start_date="2017-01-01"
    )
    j.legislative_sessions.create(
        identifier="2018", name="2018", start_date="2018-01-01"
    )

    Organization.objects.create(
        jurisdiction=j, classification="legislature", name="Nebraska Legislature"
    )

    make_person("Quincy Quip", "Nebraska", "legislature", "1", "Nonpartisan")
    make_person("Wendy Wind", "Nebraska", "legislature", "2", "Nonpartisan")


text:
<?php

namespace common\inputs;

use yii\helpers\ArrayHelper;
use yii\widgets\ActiveForm;

/**
 * Class HiddenInput
 * Текстовое поле
 * @package common\inputs
 * @author Churkin Anton <webadmin87@gmail.com>
 */
class HiddenInput extends BaseInput {

    /**
     * Формирование Html кода поля для вывода в форме
     * @param ActiveForm $form объект форма
     * @param array $options массив html атрибутов поля
     * @param bool|int $index инднкс модели при табличном вводе
     * @return string
     */
    public function renderInput(ActiveForm $form, Array $options = [], $index = false)
    {
        $options = ArrayHelper::merge($this->options, $options);

        return $form->field($this->modelField->model, $this->getFormAttrName($index, $this->modelField->attr), $this->widgetOptions)->hiddenInput($options);
    }

}


text:
<!DOCTYPE html>
<title>same-site cross-origin prerendering not opt in</title>
<meta name="timeout" content="long">
<script src="/resources/testharness.js"></script>
<script src="/resources/testharnessreport.js"></script>
<script src="/common/utils.js"></script>
<script src="/common/get-host-info.sub.js"></script>
<script src="/common/dispatcher/dispatcher.js"></script>
<script src="/html/browsers/browsing-the-web/remote-context-helper/resources/remote-context-helper.js"></script>
<script src="resources/utils.js"></script>

<script>
setup(() => assertSpeculationRulesIsSupported());

promise_test(async t => {
  const rcHelper = new RemoteContextHelper();
  const referrerRC = await rcHelper.addWindow({origin: 'HTTPS_ORIGIN'}, { features: 'noopener' });
  const prerenderedRC = await addPrerenderRC(referrerRC, {origin: 'HTTPS_REMOTE_ORIGIN'});

  // Because the prerender doesn't use opt-in header, it is expected to be canceled.
  // And the navigation is expected to create another page instead of activation.
  referrerRC.navigateTo(prerenderedRC.url);
  assert_equals(await getActivationStart(prerenderedRC), 0);
});

</script>


text:
<?xml version="1.0"?>
<entity_profile>
  <profile id="Administrator">
    <name>Administrateur</name>
  </profile>
  <profile id="Logistician">
    <name>Logisticien</name>
  </profile>
  <profile id="Translator">
    <name>Traducteur</name>
  </profile>
  <profile id="Salesman">
    <name>Commercial</name>
  </profile>
</entity_profile>


text:
        {{node.separatorHeader}}

            {{node[displaykey]}}

        <amexio-nav-mobile *ngIf="node.showInnerMenus"
        [display-key]="displaykey"
         (onNavItemClick)="onInnerClick($event)"  class="amexio-nav-mobile amexio-nav-submenus amexio-nav-mobile-submenus"
        [nodes]="node.submenus" >
        </amexio-nav-mobile>


text:
//  SFExtension
//  https://github.com/paintingStyle/SFExtension.git
//  Copyright © paintingStyle. All rights reserved.

#import <UIKit/UIKit.h>

NS_ASSUME_NONNULL_BEGIN

struct Graphical_Radius {
    CGFloat topLeftRadius;
    CGFloat topRightRadius;
    CGFloat bottomLeftRadius;
    CGFloat bottomRightRadius;
};
typedef struct Graphical_Radius Graphical_Radius;

static inline Graphical_Radius Graphical_RadiusMake(CGFloat topLeftRadius, CGFloat topRightRadius, CGFloat bottomLeftRadius, CGFloat bottomRightRadius) {
    Graphical_Radius radius;
    radius.topLeftRadius = topLeftRadius;
    radius.topRightRadius = topRightRadius;
    radius.bottomLeftRadius = bottomLeftRadius;
    radius.bottomRightRadius = bottomRightRadius;
    return radius;
}

static inline NSString * NSStringFromGraphical_Radius(Graphical_Radius radius) {
    return [NSString stringWithFormat:@"{%.2f, %.2f, %.2f, %.2f}", radius.topLeftRadius, radius.topRightRadius, radius.bottomLeftRadius, radius.bottomRightRadius];
}

@interface UIImage (SFExtension)

#pragma mark - Graphical Cut

- (UIImage *)graphicalSetRadius:(CGFloat)radius
                           size:(CGSize)size;

- (UIImage *)graphicalSetRadius:(CGFloat)radius
                           size:(CGSize)size
                    contentMode:(UIViewContentMode)contentMode;

+ (UIImage *)graphicalSetRadius:(CGFloat)radius
                           size:(CGSize)size
                    borderColor:(UIColor *)borderColor
                    borderWidth:(CGFloat)borderWidth
                backgroundColor:(UIColor *)backgroundColor;

+ (UIImage *)graphicalSetGraphical_Radius:(Graphical_Radius)radius
                                    image:(UIImage *)image
                                     size:(CGSize)size
                              borderColor:(UIColor *)borderColor
                              borderWidth:(CGFloat)borderWidth
                          backgroundColor:(UIColor *)backgroundColor
                          withContentMode:(UIViewContentMode)contentMode;

/**
 加载不要被渲染的图片
 */
+ (UIImage *)imageWithOriginalRenderingMode:(NSString *)imageName;

/**
 *  缩放图片
 */
- (UIImage *)scaleToSize:(CGSize)size;
/**
 *  等比例缩放图片
 */
- (UIImage *)scalingFixedToSize:(CGSize)size;
/**
 *  截取部分图像
 */
- (UIImage *)subImageInRect:(CGRect)rect;
/**
 *  缩放从顶部开始平铺图片
 */
- (UIImage *)imageScaleAspectFillFromTop:(CGSize)frameSize;
/**
 *  填充尺寸的缩略图
 */
- (UIImage *)imageFillSize:(CGSize)viewsize;
/**
 *  生成纯色的图片
 */
+ (UIImage *)imageWithColor:(UIColor *)color;
/**
 *  根据传入大小生成纯色的图片
 */
+ (UIImage *)imageWithColor:(UIColor *)color WithSize:(CGSize)size;
/**
 *  按照比例旋转图片,将图片摆正
 */
- (UIImage *)scaleAndRotateImage;
/**
 *  @param icon   头像图片名称
 *  @param border 边框大小
 *  @param color  边框的颜色
 *
 *  @return 圆形的头像图片
 */
+ (UIImage *)imageWithIconName:(NSString *)icon border:(int)border borderColor:(UIColor *)color;
/**
 *  @param icon   头像图片
 *  @param border 边框大小
 *  @param color  边框的颜色
 *
 *  @return 圆形的头像图片
 */
+ (UIImage *)imageWithIcon:(UIImage *)icon border:(int)border borderColor:(UIColor *)color;

#pragma mark - Create image

///=============================================================================
/// @name Create image
///=============================================================================

/**
 Create an animated image with GIF data. After created, you can access
 the images via property '.images'. If the data is not animated gif, this
 function is same as [UIImage imageWithData:data scale:scale];

 @discussion     It has a better display performance, but costs more memory
 (width * height * frames Bytes). It only suited to display small
 gif such as animated emoticon. If you want to display large gif,
 see `YYImage`.

 @param data     GIF data.

 @param scale    The scale factor

 @return A new image created from GIF, or nil when an error occurs.
 */
+ (nullable UIImage *)imageWithSmallGIFData:(NSData *)data scale:(CGFloat)scale;

/**
 Whether the data is animated GIF.

 @param data Image data

 @return Returns YES only if the data is gif and contains more than one frame,
 otherwise returns NO.
 */
+ (BOOL)isAnimatedGIFData:(NSData *)data;

/**
 Whether the file in the specified path is GIF.

 @param path An absolute file path.

 @return Returns YES if the file is gif, otherwise returns NO.
 */
+ (BOOL)isAnimatedGIFFile:(NSString *)path;

/**
 Create an image from a PDF file data or path.

 @discussion If the PDF has multiple page, is just return's the first page's
 content. Image's scale is equal to current screen's scale, size is same as
 PDF's origin size.

 @param dataOrPath PDF data in `NSData`, or PDF file path in `NSString`.

 @return A new image create from PDF, or nil when an error occurs.
 */
+ (nullable UIImage *)imageWithPDF:(id)dataOrPath;

/**
 Create an image from a PDF file data or path.

 @discussion If the PDF has multiple page, is just return's the first page's
 content. Image's scale is equal to current screen's scale.

 @param dataOrPath  PDF data in `NSData`, or PDF file path in `NSString`.

 @param size     The new image's size, PDF's content will be stretched as needed.

 @return A new image create from PDF, or nil when an error occurs.
 */
+ (nullable UIImage *)imageWithPDF:(id)dataOrPath size:(CGSize)size;

/**
 Create a square image from apple emoji.

 @discussion It creates a square image from apple emoji, image's scale is equal
 to current screen's scale. The original emoji image in `AppleColorEmoji` font
 is in size 160*160 px.

 @param emoji single emoji, such as @"😄".

 @param size  image's size.

 @return Image from emoji, or nil when an error occurs.
 */
+ (nullable UIImage *)imageWithEmoji:(NSString *)emoji size:(CGFloat)size;

/**
 Create and return an image with custom draw code.

 @param size      The image size.
 @param drawBlock The draw block.

 @return The new image.
 */
+ (nullable UIImage *)imageWithSize:(CGSize)size drawBlock:(void (^)(CGContextRef context))drawBlock;

@end

NS_ASSUME_NONNULL_END


text:
golang prototype spi driver for semtech sx1301
DO NOT USE!


text:
#include <gmock/gmock.h>
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/raw_ostream.h"
#include "mlir/IR/AsmState.h"  // from @llvm-project
#include "mlir/IR/BuiltinOps.h"  // from @llvm-project
#include "mlir/IR/MLIRContext.h"  // from @llvm-project
#include "mlir/IR/OwningOpRef.h"  // from @llvm-project
#include "mlir/IR/Verifier.h"  // from @llvm-project
#include "mlir/Parser.h"  // from @llvm-project
#include "mlir/Support/LogicalResult.h"  // from @llvm-project
#include "mlir/Translation.h"  // from @llvm-project
#include "tensorflow/compiler/mlir/init_mlir.h"
#include "tensorflow/core/common_runtime/graph_constructor.h"
#include "tensorflow/core/framework/op.h"
#include "tensorflow/core/ir/dialect.h"
#include "tensorflow/core/ir/importexport/export.h"
#include "tensorflow/core/ir/importexport/import.h"
#include "tensorflow/core/ir/importexport/load_proto.h"
#include "tensorflow/core/ir/importexport/tests/roundtrip/roundtrip.h"
#include "tensorflow/core/platform/protobuf.h"

using mlir::MLIRContext;
using mlir::tfg::ImportGraphDefToMlir;
using tensorflow::GraphDef;
using tensorflow::LoadProtoFromFile;
using tensorflow::Status;

int main(int argc, char **argv) {
  mlir::registerAsmPrinterCLOptions();
  llvm::cl::opt<std::string> input(llvm::cl::Positional, llvm::cl::Required,
                                   llvm::cl::desc("<input file>"));
  tensorflow::InitMlir y(&argc, &argv);
  llvm::cl::ParseCommandLineOptions(argc, argv, "GraphDef Roundtrip testing");
  GraphDef graphdef;
  Status status = LoadProtoFromFile({input.data(), input.size()}, &graphdef);
  if (!status.ok()) {
    LOG(ERROR) << "Failed to load input file '" << input << "': " << status;
    return 2;
  }
  tensorflow::GraphDebugInfo debug_info;
  MLIRContext context;
  auto errorOrModule = ImportGraphDefToMlir(&context, debug_info, graphdef);
  if (!errorOrModule.ok()) {
    LOG(ERROR) << errorOrModule.status();
    return 3;
  }
  auto module = std::move(errorOrModule.ValueOrDie());
  if (failed(mlir::verify(*module))) {
    LOG(ERROR) << "Module verification failed\n";
    return 3;
  }
  {
    // Roundtrip the module to text to ensure the custom printers are complete.
    std::string module_txt;
    llvm::raw_string_ostream os(module_txt);
    module->print(os, mlir::OpPrintingFlags().enableDebugInfo());

    auto new_module = mlir::parseSourceString(os.str(), module->getContext());
    if (!new_module) {
      llvm::errs() << "Couldn't reparse module: \n" << *module.get() << "\n";
      return 4;
    }
    module = std::move(new_module);
  }
  GraphDef new_graphdef;
  status = tensorflow::ExportMlirToGraphdef(*module, &new_graphdef);
  if (!status.ok()) {
    llvm::errs()
        << "\n\n=========\n=========\n=========\n=========\n=========\n"
        << *module.get() << "=========\n=========\n=========\n=========\n";
    LOG(ERROR) << "Error exporting MLIR module to GraphDef: " << status;
    return 4;
  }
  // Roundtrip the input graphdef to graph to ensure we add the default
  // attributes.
  {
    tensorflow::GraphConstructorOptions options;
    options.allow_internal_ops = true;
    options.add_default_attributes = true;
    tensorflow::Graph graph(tensorflow::OpRegistry::Global());
    tensorflow::GraphDef preprocessed_graphdef(graphdef);
    auto status = ConvertGraphDefToGraph(
        options, std::move(preprocessed_graphdef), &graph);
    if (!status.ok()) {
      LOG(ERROR) << status;
      return 1;
    }
    graph.ToGraphDef(&graphdef);
  }
  NormalizeTensorData(graphdef);
  NormalizeTensorData(new_graphdef);
#if defined(PLATFORM_GOOGLE)
  // This compares the protos with some extra tolerance (NaN, ordering, ...).
  if (!Matches(::testing::proto::TreatingNaNsAsEqual(
          ::testing::proto::IgnoringRepeatedFieldOrdering(
              ::testing::EquivToProto(new_graphdef))))(graphdef)) {
    module->dump();
    EXPECT_THAT(new_graphdef,
                ::testing::proto::TreatingNaNsAsEqual(
                    ::testing::proto::IgnoringRepeatedFieldOrdering(
                        ::testing::EquivToProto(graphdef))));
    return 1;
  }
#endif
  // Because we can't depend on gmock in non-test targets we also use
  // the more strict comparison.
  if (!tensorflow::protobuf::util::MessageDifferencer::Equivalent(
          graphdef, new_graphdef)) {
    // This will show the diff inline.
#if defined(PLATFORM_GOOGLE)
    EXPECT_THAT(new_graphdef, ::testing::EquivToProto(graphdef));
#endif
    llvm::errs() << "Not equivalent\n";
    return 2;
  }
}


text:
<!DOCTYPE html>

    <link rel="stylesheet" href="http://cdn.leafletjs.com/leaflet/v1.0.0-beta.2/leaflet.css" />

    <link rel="stylesheet" href="//cdn.jsdelivr.net/leaflet.esri.geocoder/2.0.2/esri-leaflet-geocoder.css">


text:
<?php

namespace Blast\Orm\Relations;

use Blast\Orm\ConnectionAwareInterface;
use Blast\Orm\ConnectionAwareTrait;
use Blast\Orm\Entity\Definition;
use Blast\Orm\Entity\EntityAwareTrait;
use Blast\Orm\Entity\ProviderFactoryInterface;
use Blast\Orm\Entity\ProviderFactoryTrait;
use Blast\Orm\Hydrator\HydratorInterface;
use Blast\Orm\Query;
use Doctrine\Common\Util\Inflector;

class ManyToMany implements ConnectionAwareInterface, ProviderFactoryInterface, RelationInterface
{
    use ConnectionAwareTrait;
    use EntityAwareTrait;
    use ProviderFactoryTrait;
    use RelationTrait;

    /**
     * @var object|string
     */
    private $foreignEntity;
    /**
     * @var null|string
     */
    private $foreignKey;
    /**
     * @var null|string
     */
    private $localKey;
    /**
     * @var null|object|string
     */
    private $junction;
    /**
     * @var null|string
     */
    private $junctionLocalKey;
    /**
     * @var null|string
     */
    private $junctionForeignKey;

    /**
     * Many occurrences in local entity relate to many occurrences in foreign entity and vice versa.
     * The relations are linked by a junction table.
     *
     * @param string|object $entity
     * @param string|object $foreignEntity
     * @param null|string $foreignKey Default field name is {foreign primary key name}
     * @param null|string $localKey Default field name is {local primary key name}
     * @param null|string|object $junction Default table name is {local entity table name}_{foreign entity table name}
     * @param null|string $junctionLocalKey Default field name is {local table name}_{$localKey}
     * @param null|string $junctionForeignKey Default field name is {foreign table name}_{$foreignKey}
     */
    public function __construct($entity, $foreignEntity, $foreignKey = null, $localKey = null,
                                $junction = null, $junctionLocalKey = null, $junctionForeignKey = null)
    {

        $this->entity = $entity;
        $this->foreignEntity = $foreignEntity;
        $this->foreignKey = $foreignKey;
        $this->localKey = $localKey;
        $this->junction = $junction;
        $this->junctionLocalKey = $junctionLocalKey;
        $this->junctionForeignKey = $junctionForeignKey;
    }

    /**
     * @return null|string
     */
    public function getLocalKey()
    {
        return $this->localKey;
    }

    /**
     * @return \SplStack
     */
    public function execute()
    {
        return $this->getQuery()->execute(HydratorInterface::HYDRATE_COLLECTION);
    }

    /**
     * Get relation query
     *
     * @return \Blast\Orm\Query
     */
    public function getQuery()
    {
        if (null !== $this->query) {
            return $this->query;
        }
        $provider = $this->createProvider($this->getEntity());
        $foreignProvider = $this->createProvider($this->getForeignEntity());
        $foreignKey = $this->getForeignKey();
        $junction = $this->getJunction();
        $junctionLocalKey = $this->getJunctionLocalKey();
        $junctionForeignKey = $this->getJunctionForeignKey();

        $data = $provider->extract();

        $localKey = $provider->getDefinition()->getPrimaryKeyName();

        //determine foreign key
        if ($foreignKey === null) {
            $foreignKey = $foreignProvider->getDefinition()->getPrimaryKeyName();
        }

        //determine through
        if (!is_string($junction) || $junction === null) {
            $junction = Inflector::singularize($provider->getDefinition()->getTableName()) . '_' . Inflector::singularize($foreignProvider->getDefinition()->getTableName());
        }

        //determine through local key
        if ($junctionLocalKey === null) {
            $junctionLocalKey = Inflector::singularize($provider->getDefinition()->getTableName()) . '_' . $localKey;
        }

        //determine through foreign key
        if ($junctionForeignKey === null) {
            $junctionForeignKey = Inflector::singularize($foreignProvider->getDefinition()->getTableName()) . '_' . $foreignKey;
        }

        $query = new Query($provider->getDefinition()->getMapper()->getConnection());

        //prepare query for foreign table
        $foreignQuery = $foreignProvider->getDefinition()->getMapper()
            ->setConnection($this->getConnection())
            ->select();

        //get relations by through db object
        if (isset($data[$localKey])) {
            $junctionProvider = is_string($junction) ?
                $this->createProvider($junction) :
                $junction;
            $junctionMapper = $junctionProvider->getDefinition()->getMapper();
            $junctionMapper->setConnection($this->getConnection());
            if(true){

            }
            $results = $junctionMapper
                ->select([$junctionForeignKey])
                ->where($query->expr()->eq($junctionLocalKey, $data[$localKey]))
                ->execute(HydratorInterface::HYDRATE_RAW);

            //set conditions on foreign query
            foreach ($results as $result) {
                $foreignQuery->where($query->expr()->eq($foreignKey, $result[$junctionForeignKey]));
            }
        }

        $this->query = $foreignQuery;

        return $this->query;
    }

    /**
     * @return object|string
     */
    public function getForeignEntity()
    {
        return $this->foreignEntity;
    }

    /**
     * @return null|string
     */
    public function getForeignKey()
    {
        return $this->foreignKey;
    }

    /**
     * @return null|object|string
     */
    public function getJunction()
    {
        return $this->junction;
    }

    /**
     * @return null|string
     */
    public function getJunctionLocalKey()
    {
        return $this->junctionLocalKey;
    }

    /**
     * @return null|string
     */
    public function getJunctionForeignKey()
    {
        return $this->junctionForeignKey;
    }
}


text:
using System;
using System.Xml.Serialization;

namespace Aop.Api.Domain
{
    /// <summary>
    /// InsEndorseItem Data Structure.
    /// </summary>
    [Serializable]
    public class InsEndorseItem : AopObject
    {
        /// <summary>
        /// 批单项新值
        /// </summary>
        [XmlElement("new_value")]
        public string NewValue { get; set; }

        /// <summary>
        /// 批单项旧值
        /// </summary>
        [XmlElement("old_value")]
        public string OldValue { get; set; }

        /// <summary>
        /// 批单类型;303:保单改期;311:批改保单标的
        /// </summary>
        [XmlElement("type")]
        public long Type { get; set; }
    }
}


text:
import lombok.NoArgsConstructor;
public @NoArgsConstructor(force = true) class NoArgsConstructorForce {
  private final int[] i;
  private final Object[] o;
  private final java.util.List<?>[] fullQualifiedList;
  public @java.lang.SuppressWarnings("all") @javax.annotation.Generated("lombok") NoArgsConstructorForce() {
    super();
    this.i = null;
    this.o = null;
    this.fullQualifiedList = null;
  }
}


text:
/**
 * @fileoverview 'vf2jsvf2js.display.InteractiveObject'
 *
 * @author erikdebruin@apache.org (Erik de Bruin)
 */

'use strict';

goog.provide('vf2js.display.InteractiveObject');

goog.require('vf2js.display.DisplayObject');

/**
 * @constructor
 * @struct
 * @extends {vf2js.display.DisplayObject}
 */
vf2js.display.InteractiveObject = function() {
  vf2js.display.InteractiveObject.base(this, 'constructor');
};
goog.inherits(vf2js.display.InteractiveObject, vf2js.display.DisplayObject);

/**
 * Metadata
 *
 * @type {Object.<string, Array.<Object>>}
 */
vf2js.display.InteractiveObject.prototype.FLEXJS_CLASS_INFO =
    { names: [{ name: 'InteractiveObject', qName: 'vf2js.display.InteractiveObject'}],
      interfaces: [] }