Append a Box to the end of the linked list and return this instance.
174825
public function append(Box $b) : Box
    {
        if ($this->next === null && $b->prev === null) {
            $this->next = $b;
            $b->prev = $this;
        } else {
            $this->tail()->append($b->head());
        }
        return $this;
    }
1293750
public StrBuilder appendAll(final Iterator<?> it) {
        if (it != null) {
            while (it.hasNext()) {
                append(it.next());
            }
        }
        return this;
    }
778251
def _handle_end_node(self):
        
        self._result.append(Node(result=self._result, **self._curr))
        self._curr = {}
885805
function endNode() {
            if (parent.children) {
                mergeChildren(parent.children);
                sortChildren(parent.children);
            }
            parent = parentsStack.pop();
        }
392968
public <A extends Appendable> A appendTo(A appendable, Iterable<?> parts) throws IOException {
    return appendTo(appendable, parts.iterator());
  }
301297
def __append_list(append_to, value):
    """"""
    if value is not None:
        if isinstance(value, list):
            append_to.extend(value)
        else:
            append_to.append(value)
385310
function linkedList(data, start, end, dim, clockwise) {
       var i, last;

       if (clockwise === (signedArea(data, start, end, dim) > 0)) {
           for (i = start; i < end; i += dim) last = insertNode(i, data[i], data[i + 1], last);
       } else {
           for (i = end - dim; i >= start; i -= dim) last = insertNode(i, data[i], data[i + 1], last);
       }

       if (last && equals(last, last.next)) {
           removeNode(last);
           last = last.next;
       }

       return last;
   }
458451
private int insertNodeBetween(int index, int nextIndex, long node) {
        assert(previousIndexFromNode(node) == 0);
        assert(nextIndexFromNode(node) == 0);
        assert(nextIndexFromNode(nodes.elementAti(index)) == nextIndex);
        // Append the new node and link it to the existing nodes.
        int newIndex = nodes.size();
        node |= nodeFromPreviousIndex(index) | nodeFromNextIndex(nextIndex);
        nodes.addElement(node);
        // nodes[index].nextIndex = newIndex
        node = nodes.elementAti(index);
        nodes.setElementAt(changeNodeNextIndex(node, newIndex), index);
        // nodes[nextIndex].previousIndex = newIndex
        if(nextIndex != 0) {
            node = nodes.elementAti(nextIndex);
            nodes.setElementAt(changeNodePreviousIndex(node, newIndex), nextIndex);
        }
        return newIndex;
    }
1353903
function append(root, isVirtual) {
      if (isVirtual)
        { makeVirtual.call(this, root); }
      else
        { root.appendChild(this.root); }
    }
954821
public boolean endLink(final Object endVertex, final MouseEvent mouseEvent) {
        logger.debug("endLink({})", endVertex);
        boolean result = false;
        if (_startVertex != null && endVertex != null) {
            if (mouseEvent.getButton() == MouseEvent.BUTTON1) {
                final boolean created = createLink(_startVertex, endVertex, mouseEvent);
                if (created && _graphContext.getVisualizationViewer().isVisible()) {
                    _graphContext.getJobGraph().refresh();
                }
                result = true;
            }
        }
        stopDrawing();
        return result;
    }
772382
void appendEndElement()
  {
    // pop up the stacks

    if (previousSiblingWasParent)
      nodes.writeEntry(previousSibling, 2, NULL);

    // Pop parentage
    previousSibling = currentParent;
    nodes.readSlot(currentParent, gotslot);
    currentParent = gotslot[1] & 0xFFFF;

    // The element just being finished will be
    // the previous sibling for the next operation
    previousSiblingWasParent = true;

    // Pop a level of namespace table
    // namespaceTable.removeLastElem();
  }
1264142
private Tree<Row> findEndIf( Tree<Row> pointer ){
        while( !Type.END_IF.equals( pointer.getContent().getType() ) ){
            pointer = pointer.getNext();
        }
        return pointer;
    }
1330679
def append_value_continuation(self, linenum, indent, continuation):
        
        frame = self.current_frame()
        assert isinstance(frame,FieldFrame) or isinstance(frame,ValueContinuationFrame)
        if isinstance(frame, FieldFrame):
            assert frame.indent < indent and frame.container.contains(ROOT_PATH, frame.field_name)
        if isinstance(frame, ValueContinuationFrame):
            assert frame.indent == indent and frame.container.contains(ROOT_PATH, frame.field_name)
            self.pop_frame()
        field_value = frame.field_value + '\n' + continuation
        frame.container.put_field(ROOT_PATH, frame.field_name, field_value)
        frame = ValueContinuationFrame(linenum, indent, frame.path, frame.container, frame.field_name, field_value)
        self.push_frame(frame)
568010
def p_end_function(p):
    
    p[0] = p[1]
    p[0].append(node.return_stmt(ret=ret_expr))
    p[0].append(node.comment_stmt("\nif __name__ == '__main__':\n    pass"))
1223191
private Node tryAppend(Node s, boolean haveData) {
        for (Node t = tail, p = t;;) {        // move p to last node and append
            Node n, u;                        // temps for reads of next & tail
            if (p == null && (p = head) == null) {
                if (casHead(null, s))
                    return s;                 // initialize
            }
            else if (p.cannotPrecede(haveData))
                return null;                  // lost race vs opposite mode
            else if ((n = p.next) != null)    // not last; keep traversing
                p = p != t && t != (u = tail) ? (t = u) : // stale tail
                    (UNLINKED != n) ? n : null; // restart if off list
            else if (!p.casNext(null, s))
                p = p.next;                   // re-read on CAS failure
            else {
                if (p != t) {                 // update if slack now >= 2
                    while ((tail != t || !casTail(t, s)) &&
                           (t = tail)   != null &&
                           (s = t.next) != null && // advance and retry
                           (s = s.next) != null && s != UNLINKED);
                }
                return p;
            }
        }
    }
315485
@Override
	public Appendable append(CharSequence csq, int start, int end) {
		final int otherLen = end - start;
		grow(this.len + otherLen);
		for (int pos = start; pos < end; pos++) {
			this.value[this.len + pos] = csq.charAt(pos);
		}
		this.len += otherLen;
		return this;
	}
1236889
function(box) {
      var b = new c()

      // merge boxes
      b.x      = Math.min(this.x, box.x)
      b.y      = Math.min(this.y, box.y)
      b.width  = Math.max(this.x + this.width,  box.x + box.width)  - b.x
      b.height = Math.max(this.y + this.height, box.y + box.height) - b.y

      return fullBox(b)
    }