Adds the provided domino to the right end of the board.

        :param Domino d: domino to add
        :return: None
        :raises EndsMismatchException: if the values do not match
9552
def _add_right(self, d):
        '''
        
        '''
        if not self:
            self._left = d.first
            self._right = d.second
        elif d.first == self.right_end():
            self._right = d.second
        elif d.second == self.right_end():
            self._right = d.first
        else:
            raise dominoes.EndsMismatchException(
                '{} cannot be added to the right of'
                ' the board - values do not match!'.format(d)
            )

        self._length += 1
999586
private UnicodeSet add_unchecked(int start, int end) {
        if (start < MIN_VALUE || start > MAX_VALUE) {
            throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(start, 6));
        }
        if (end < MIN_VALUE || end > MAX_VALUE) {
            throw new IllegalArgumentException("Invalid code point U+" + Utility.hex(end, 6));
        }
        if (start < end) {
            add(range(start, end), 2, 0);
        } else if (start == end) {
            add(start);
        }
        return this;
    }
142345
def add(self, uuid):
        
        if uuid:
            # Computing the hash
            try:
                x = hash64(uuid)
            except UnicodeEncodeError:
                x = hash64(uuid.encode('ascii', 'ignore'))
            # Finding the register to update by using the first b bits as an index
            j = x & ((1 << self.b) - 1)
            # Remove those b bits
            w = x >> self.b
            # Find the first 0 in the remaining bit pattern
            self.M[j] = max(self.M[j], self._get_rho(w, self.bitcount_arr))
389587
def draw(self, d, i=None):
        '''
        
        '''
        if i is None:
            self._dominoes.append(d)
        else:
            self._dominoes.insert(i, d)
991931
def _add_edge(self, layer, input_id, output_id):
        """"""

        if layer in self.layer_to_id:
            layer_id = self.layer_to_id[layer]
            if input_id not in self.layer_id_to_input_node_ids[layer_id]:
                self.layer_id_to_input_node_ids[layer_id].append(input_id)
            if output_id not in self.layer_id_to_output_node_ids[layer_id]:
                self.layer_id_to_output_node_ids[layer_id].append(output_id)
        else:
            layer_id = len(self.layer_list)
            self.layer_list.append(layer)
            self.layer_to_id[layer] = layer_id
            self.layer_id_to_input_node_ids[layer_id] = [input_id]
            self.layer_id_to_output_node_ids[layer_id] = [output_id]

        self.adj_list[input_id].append((output_id, layer_id))
        self.reverse_adj_list[output_id].append((input_id, layer_id))
895419
def add_edge(self, from_node, to_node):
        
        # Maybe to_node is unknown
        if to_node not in self.nodes:
            self.add_node(to_node)

        try:
            self.nodes[from_node]["sons"].append(to_node)
        # If from_node does not exist, add it with its son
        except KeyError:
            self.nodes[from_node] = {"dfs_loop_status": "", "sons": [to_node]}
378660
def extend(self, iterable):
        
        self._deque.extend(iterable)
        if len(self._deque) > 0:
            self.notEmpty.set()
899867
def add_edge(edges, edge_points, coords, i, j):
    
    if (i, j) in edges or (j, i) in edges:
        # already added
        return( edges.add((i, j)), edge_points.append(coords[[i, j]]))
328583
def _add_to(self, uuid, dest, other):
        """"""
        _assert_uuid(uuid)
        try:
            other.remove(uuid)
        except KeyError:
            pass
        dest.add(uuid)
660140
async def add(ctx, left: int, right: int):
    """"""
    await ctx.send(left + right)
1083294
def add_edge(self, source, target, interaction='-', directed=True, dataframe=True):
        
        new_edge = {
            'source': source,
            'target': target,
            'interaction': interaction,
            'directed': directed
        }
        return self.add_edges([new_edge], dataframe=dataframe)
264343
void addDelta(TableKelp db, int offset, int length)
  {
    if (_delta == null) {
      _delta = new int[2 * db.getDeltaMax()];
    }
    
    _delta[_deltaTail++] = offset;
    _delta[_deltaTail++] = length;
  }
1361707
def add(self, option):
				
		if option.__class__ == Option:
			for _option in self.options:
				if option.name == _option.name:
					raise OptionDuplicateError(_option.name)
			self.options.append(option)
		else:
			raise TypeError("invalid type supplied")
796055
def increment(d, key, val=1):
    
    if key in d:
        d[key] += val
    else:
        d[key] = val
1151250
public boolean add(Edge e) {
        int toAdd = -1;
        if (e.from() == rootVertex) 
            toAdd = e.to();        
        else if (e.to() == rootVertex)
            toAdd = e.from();
        else
            return false;
        boolean b = edges.add(toAdd);
        return b;
    }
301793
def add(self, iterable):
        
        item1 = item2 = MarkovChain.START
        for item3 in iterable:
            self[(item1, item2)].add_side(item3)
            item1 = item2
            item2 = item3
        self[(item1, item2)].add_side(MarkovChain.END)
968569
def AddPoly(self, poly, smart_duplicate_handling=True):
    
    inserted_name = poly.GetName()
    if poly.GetName() in self._name_to_shape:
      if not smart_duplicate_handling:
        raise ShapeError("Duplicate shape found: " + poly.GetName())

      print ("Warning: duplicate shape id being added to collection: " +
             poly.GetName())
      if poly.GreedyPolyMatchDist(self._name_to_shape[poly.GetName()]) < 10:
        print("  (Skipping as it apears to be an exact duplicate)")
      else:
        print("  (Adding new shape variant with uniquified name)")
        inserted_name = "%s-%d" % (inserted_name, len(self._name_to_shape))
    self._name_to_shape[inserted_name] = poly