recursive part of generate_copy_in
13610
def recursive_generate_copy_in(copy_in, current_path)
      limited_files_of(current_path) { |file| copy_in << file }
      directories_of(current_path) do |dir|
        recursive_generate_copy_in(copy_in, ::File.join(dir))
      end
      true
    end
848104
function dup(x) {
    var i, buff;
    buff=new Array(x.length);
    copy_(buff,x);
    return buff;
  }
188772
def copy_iterator(self):
        
        self.__udiff, iterator_copy = itertools.tee(self.__udiff)
        return iterator_copy
693426
def p_generate_for(self, p):
        ''
        p[0] = ForStatement(p[3], p[4], p[5], p[7], lineno=p.lineno(1))
        p.set_lineno(0, p.lineno(1))
759162
private void recursiveDump(Node n, int level, PrintWriter p)
    {        
        //Opening tag
        if (n.getNodeType() == Node.ELEMENT_NODE)
        {
            String tag = "";
            Element el = (Element) n;
            //do not dump original style definitions
            if (filterStyles)
            {
                if (el.getTagName().equals("style")) 
                    return;
                if (el.getTagName().equals("link") &&
                    ("stylesheet".equalsIgnoreCase(el.getAttribute("rel")) || 
                     "text/css".equalsIgnoreCase(el.getAttribute("type"))))
                    return;
            }
            //Replace meta generator
            if (el.getTagName().equals("meta") && "generator".equalsIgnoreCase(el.getAttribute("name")))
                el.setAttribute("content", "CSS Transformer by Radek Burget, burgetr@fit.vutbr.cz");
            //Change encoding to utf-8
            if (el.getTagName().equals("meta") && "content-type".equalsIgnoreCase(el.getAttribute("http-equiv")))
                el.setAttribute("content", "text/html; charset=utf-8");
            //Dump the tag
            tag = tag + "<" + el.getTagName();
            NamedNodeMap attrs = el.getAttributes();
            for (int i = 0; i < attrs.getLength(); i++)
            {
                Node attr = attrs.item(i);
                tag = tag + " " + attr.getNodeName() + "=\"" + attr.getNodeValue() + "\"";
            }
            tag = tag + ">";
            p.print(tag);
        }
        else if (n.getNodeType() == Node.TEXT_NODE)
        {
            p.print(n.getNodeValue());
        }
        else if (n.getNodeType() == Node.COMMENT_NODE)
        {
            p.print("<!--");
            p.print(n.getNodeValue());
            p.print("-->");
        }
                                
        NodeList child = n.getChildNodes();
        for (int i = 0; i < child.getLength(); i++)
            recursiveDump(child.item(i), level+1, p);   

        //Closing tag
        if (n.getNodeType() == Node.ELEMENT_NODE)
        {
            //if (n.getNodeName().equals("head"))
            //    p.print("<script type=\"text/javascript\" src=\"visual.js\"></script>");
            p.print("</" + n.getNodeName() + ">");
        }        
    }
193091
def print_generated_sequence(gen, num, *, sep=", ", fmt='', seed=None):
    
    if seed:
       gen.reset(seed)

    elems = [format(next(gen), fmt) for _ in range(num)]
    sep_initial = "\n\n" if '\n' in sep else " "
    print("Generated sequence:{}{}".format(sep_initial, sep.join(elems)))
1106361
def gen_sub(src1, src2, dst):
        
        assert src1.size == src2.size

        return ReilBuilder.build(ReilMnemonic.SUB, src1, src2, dst)
886873
def deep_copy(item_original):
    """"""
    item = copy.copy(item_original)
    item._id = uuid.uuid4().hex
    if hasattr(item, '_children') and len(item._children) > 0:
        children_new = collections.OrderedDict()
        for subitem_original in item._children.values():
            subitem = deep_copy(subitem_original)
            subitem._parent = item
            children_new[subitem.get_name()] = subitem
        item._children = children_new
    return item
1296017
def copyto(self, src, where=None):
        
        for n, _ in enumerate(self.l):
            if where[n]:
                self.l[n] = src.l[n]
784569
def copy(self):
        ""
        other = _ChainedHashAlgorithm(self._algorithms)
        other._hobj = deepcopy(self._hobj)
        other._fobj = deepcopy(self._fobj)
        return other
398279
def _dir2(obj, pref='', excl=(), slots=None, itor=''):
    '''
    '''
    if slots:  # __slots__ attrs
        if hasattr(obj, slots):
             # collect all inherited __slots__ attrs
             # from list, tuple, or dict __slots__,
             # while removing any duplicate attrs
            s = {}
            for c in type(obj).mro():
                for a in getattr(c, slots, ()):
                    if hasattr(obj, a):
                        s.setdefault(a, getattr(obj, a))
             # assume __slots__ tuple/list
             # is holding the attr values
            yield slots, _Slots(s)  # _keys(s)
            for t in _items(s):
                yield t  # attr name, value
    elif itor:  # iterator referents
        for o in obj:  # iter(obj)
            yield itor, o
    else:  # regular attrs
        for a in dir(obj):
            if a.startswith(pref) and a not in excl and hasattr(obj, a):
               yield a, getattr(obj, a)
1305529
private INode genDirStructure(String rootName, int maxDepth) {
    INode root = new INode(rootName);

    if (maxDepth>0) {
      maxDepth--;
      int minDepth = maxDepth*2/3;
      // Figure out the number of subdirectories to generate
      int numOfSubDirs = minWidth + r.nextInt(maxWidth-minWidth+1);
      // Expand the tree
      for (int i=0; i<numOfSubDirs; i++) {
        int childDepth = (maxDepth == 0)?0:
          (r.nextInt(maxDepth-minDepth+1)+minDepth);
        INode child = genDirStructure("dir"+i, childDepth);
        root.addChild(child);
      }
    }
    return root;
  }
127115
function fp_inv(r, n, p, l) {
	if (mpn_zero_p(n, l)) {
		throw new RangeError("not invertible");
	}
	var u = _fp_u, v = _fp_v, s = _fp_s;
	mpn_copyi(u, n, l), mpn_copyi(v, p, l);
	mpn_zero(r, l), mpn_zero(s, l);
	r[0] = 1;
	for (;;) {
		if (mpn_one_p(u, l)) {
			return r;
		}
		if (mpn_one_p(v, l)) {
			mpn_copyi(r, s, l);
			return r;
		}
		while (mpn_even_p(u, l)) {
			mpn_shr1(u, u, l);
			if (mpn_even_p(r, l)) {
				mpn_shr1(r, r, l);
			}
			else {
				var c = mpn_add(r, r, p, l) << 30;
				mpn_shr1(r, r, l);
				r[l - 1] |= c;
			}
		}
		while (mpn_even_p(v, l)) {
			mpn_shr1(v, v, l);
			if (mpn_even_p(s, l)) {
				mpn_shr1(s, s, l);
			}
			else {
				var c = mpn_add(s, s, p, l) << 30;
				mpn_shr1(s, s, l);
				s[l - 1] |= c;
			}
		}
		if (mpn_cmp(u, v, l) >= 0) {
			mpn_sub(u, u, v, l);
			fp_sub(r, r, s, p, l);
		}
		else {
			mpn_sub(v, v, u, l);
			fp_sub(s, s, r, p, l);
		}
	}
}
116395
def clone(module: torch.nn.Module, num_copies: int) -> torch.nn.ModuleList:
    """"""
    return torch.nn.ModuleList([copy.deepcopy(module) for _ in range(num_copies)])
604686
def copy(self):
        '''

        '''
        # Significant performance improvements by skipping alphabet check
        return type(self)(self.seq, self.material, run_checks=False)
738873
def copy(n = 1)
      raise ArgumentError, 'n must be a non-negative Integer' if not n.is_a?(::Integer) or n < 0
      return self if n == 1
      return Erlang::Binary[(@data * n)]
    end
403859
def __embed_branch_recursive(u, dfs_data):
    """"""
    #print "\nu: {}\nadj: {}".format(u, dfs_data['adj'][u])

    #print 'Pre-inserts'
    #print "FG: {}".format(dfs_data['FG'])
    #print "LF: {}".format(dfs_data['LF'])
    #print "RF: {}".format(dfs_data['RF'])

    for v in dfs_data['adj'][u]:
        #print "\nu, v: {}, {}".format(u, v)
        #print "dfs_u, dfs_v: {}, {}".format(D(u, dfs_data), D(v, dfs_data))
        nonplanar = True
        if a(v, dfs_data) == u:
            #print 'Ancestor block entered:', u, v
            if b(v, dfs_data) == u:
                successful = __insert_branch(u, v, dfs_data)
                if not successful:
                    #print 'InsertBranch({}, {}) Failed'.format(u, v)
                    nonplanar = True
                    return nonplanar
            nonplanar = __embed_branch_recursive(v, dfs_data)
            if nonplanar:
                return nonplanar
        elif is_frond(u, v, dfs_data):
            #print 'Frond block entered:', u, v
            successful = __embed_frond(u, v, dfs_data)
            if not successful:
                #print 'EmbedFrond({}, {}) Failed'.format(u, v)
                nonplanar = True
                return nonplanar

            #print 'Post EmbedFrond'
            #print "FG: {}".format(dfs_data['FG'])
            #print "LF: {}".format(dfs_data['LF'])
            #print "RF: {}".format(dfs_data['RF'])
        else:
            # This block is totally valid, and there will be multiple cases when it gets hit.
            # We only want to do things if an edge is a tree edge (parent to child along the spine of the DFS tree),
            # or if it's a frond edge (an edge moving up the tree from lower along the spine).
            # Every non-tree edge will eventually get handled by the frond edge code as we recurse up the spine.
            pass
    #print "{}: Should be planar".format(u)

    #print 'Post-inserts'
    #print "FG: {}".format(dfs_data['FG'])
    #print "LF: {}".format(dfs_data['LF'])
    #print "RF: {}".format(dfs_data['RF'])

    nonplanar = False
    return nonplanar