{.repeated section foo}
430182
def _DoRepeatedSection(args, context, callback, trace):
    """"""
    
    block = args
    
    items = context.PushSection(block.section_name, block.pre_formatters)
    if items:
        if not isinstance(items, list):
            raise EvaluationError('Expected a list; got %s' % type(items))
        
        last_index = len(items) - 1
        statements = block.Statements()
        alt_statements = block.Statements('alternates with')
        try:
            i = 0
            while True:
                context.Next()
                # Execute the statements in the block for every item in the list.
                # Execute the alternate block on every iteration except the last.  Each
                # item could be an atom (string, integer, etc.) or a dictionary.
                _Execute(statements, context, callback, trace)
                if i != last_index:
                    _Execute(alt_statements, context, callback, trace)
                i += 1
        except StopIteration:
            pass
    
    else:
        _Execute(block.Statements('or'), context, callback, trace)
    
    context.Pop()
1359277
def _write_section(self, fp, section_name, section_items, delimiter):
        """"""
        fp.write("[{0}]\n".format(section_name))
        for key, value in section_items:
            value = self._interpolation.before_write(self, section_name, key,
                                                     value)
            if value is not None or not self._allow_no_value:
                value = delimiter + str(value).replace('\n', '\n\t')
            else:
                value = ""
            fp.write("{0}{1}\n".format(key, value))
        fp.write("\n")
334694
function getObject(section) {
  var o = {}
    , i
    , k
    , name
    , method
    , sections = section ? [section] : keys
    , rusage = proc.usage();

  for(i = 0;i < sections.length;i++) {
    k = sections[i];
    name = k.charAt(0).toUpperCase() + k.substr(1);
    method = 'get' + name
    o[k] = {
      header: name,
      data: this[method](rusage)
    }
  }
  return o;
}
469643
function repeat(coll, n) {
  if (arguments.length === 1) {
    n = coll;
    return function(xform) {
      return new Repeat(n, xform);
    };
  }
  return seq(coll, repeat(n));
}
753372
def duplicate_child_info(child_ref)
      @title ||= child_ref.title
      @type ||= child_ref.subset_operators
      @definition ||= child_ref.definition
      @status ||= child_ref.status
      @code_list_id ||= child_ref.code_list_id
      @temporal_references = child_ref.temporal_references if @temporal_references.empty?
      @subset_operators ||= child_ref.subset_operators
      @variable ||= child_ref.variable
      @value ||= child_ref.value
    end
1347761
function(obj, section, options = {}) {
    var children, dotSplit, out, safe;
    if (arguments.length === 2) {
      options = section;
      section = void 0;
    }
    if (options.separator == null) {
      options.separator = ' = ';
    }
    if (options.eol == null) {
      options.eol = !options.ssh && process.platform === "win32" ? "\r\n" : "\n";
    }
    if (options.escape == null) {
      options.escape = true;
    }
    safe = module.exports.safe;
    dotSplit = module.exports.dotSplit;
    children = [];
    out = "";
    Object.keys(obj).forEach(function(k, _, __) {
      var val;
      val = obj[k];
      if (val && Array.isArray(val)) {
        return val.forEach(function(item) {
          return out += safe(`${k}[]`) + options.separator + safe(item) + options.eol;
        });
      } else if (val && typeof val === "object") {
        return children.push(k);
      } else if (typeof val === 'boolean') {
        if (val === true) {
          return out += safe(k) + options.eol;
        } else {

        }
      } else {
        // disregard false value
        return out += safe(k) + options.separator + safe(val) + options.eol;
      }
    });
    if (section && out.length) {
      out = "[" + safe(section) + "]" + options.eol + out;
    }
    children.forEach((k, _, __) => {
      var child, nk;
      // escape the section name dot as some daemon could not parse it
      nk = options.escape ? dotSplit(k).join('\\.') : k;
      child = module.exports.stringify(obj[k], (section ? section + "." : "") + nk, options);
      if (out.length && child.length) {
        out += options.eol;
      }
      return out += child;
    });
    return out;
  }
1039603
@Override
	protected StringBuilder endSection( String sectionName, StringBuilder sb ) {
		sb.append( "<br />\n" );
		return sb;
	}
454922
def iter_sections(self, recursive=False, path=None, key='path'):
        
        for x in self.iter_all(recursive=recursive, path=path, key=key):
            if key is None:
                if x.is_section:
                    yield x
            elif x[1].is_section:
                yield x
228429
function isSelfReference(ref, nodes) {
            let scope = ref.from;

            while (scope) {
                if (nodes.indexOf(scope.block) >= 0) {
                    return true;
                }

                scope = scope.upper;
            }

            return false;
        }
89883
function dereference (parser, options) {
  // console.log('Dereferencing $ref pointers in %s', parser.$refs._root$Ref.path);
  var dereferenced = crawl(parser.schema, parser.$refs._root$Ref.path, "#", [], parser.$refs, options);
  parser.$refs.circular = dereferenced.circular;
  parser.schema = dereferenced.value;
}
969003
def _find_sections(self, name_type_pairs):
        """"""
        sections = [None] * len(name_type_pairs)
        for section in self.elf.sections:
            section_name = to_str_safe(section.name)
            section_type = section.type
            for i, name_and_type in enumerate(name_type_pairs):
                if name_and_type != (section_name, section_type):
                    continue
                if sections[i] is not None:
                    raise FlashAlgoException("Elf contains duplicate section %s attr %s" %
                                    (section_name, section_type))
                sections[i] = section
        return sections
1292573
private long getFrequentItemsets(PrintStream out, List<ItemSet> list) {
        long n = 0;
        if (root.children != null) {
            for (int i = 0; i < root.children.length; i++) {
                Node child = root.children[i];
                if (child != null && child.support >= minSupport) {
                    int[] itemset = {child.id};
                    n += getFrequentItemsets(out, list, itemset, i, child);
                }
            }
        }
        
        return n;
    }
945066
def add_repetition(pRepetition)
      return nil unless pRepetition.is_a?(Languages::RepetitionData)
      pRepetition.level = @currentLevel
      @basicStructure.push(pRepetition)
    end
601527
void put(
    Conjunction selector,
    MatchTarget object,
    InternTable subExpr)
    throws MatchingException
  {
    SimpleTest test = Factory.findTest(ordinalPosition, selector);
    if (test == null)
      super.put(selector, object, subExpr);
    else
    {
      ContentMatcher next;
      if (test.getKind() == SimpleTest.NULL)
        next = nullChild = nextMatcher(selector, nullChild);
      else
        if (test.getKind() == SimpleTest.NOTNULL)
          next = notNullChild = nextMatcher(selector, notNullChild);
        else
        {
          handlePut(test, selector, object, subExpr);
          return;
        }
      next.put(selector, object, subExpr);
    }
  }
701184
private void reusePreviouslyUsedVariableMap(SortedSet<Assignment> varsToRename) {
    // If prevUsedRenameMap had duplicate values then this pass would be
    // non-deterministic.
    // In such a case, the following will throw an IllegalArgumentException.
    checkNotNull(prevUsedRenameMap.getNewNameToOriginalNameMap());
    for (Assignment a : varsToRename) {
      String prevNewName = prevUsedRenameMap.lookupNewName(a.oldName);
      if (prevNewName == null || reservedNames.contains(prevNewName)) {
        continue;
      }

      if (a.isLocal
          || (!externNames.contains(a.oldName)
              && prevNewName.startsWith(prefix))) {
        reservedNames.add(prevNewName);
        finalizeNameAssignment(a, prevNewName);
      }
    }
  }
906326
function property(fn, arg) {
      var base = [ section, name ];

      return {
        writable: false,
        enumerable: false,
        value: function () {
          if (arg) base.push(arg);

          return fn.apply(self, base.concat(
            Array.prototype.slice.apply(arguments)
          ));
        }
      };
    }
1167204
function(rule) {
			var offset = rule.valueRange(true).start;
			var nestedSections = this.findAllRules(rule.valueRange().substring(rule.source));
			nestedSections.forEach(function(section) {
				section.start += offset;
				section.end += offset;
				section._selectorEnd += offset;
				section._contentStart += offset;
			});
			return nestedSections;
		}