Add back strings.
423044
def str_repl(self, inputstring, **kwargs):
        """"""
        out = []
        comment = None
        string = None

        for i, c in enumerate(append_it(inputstring, None)):
            try:

                if comment is not None:
                    if c is not None and c in nums:
                        comment += c
                    elif c == unwrapper and comment:
                        ref = self.get_ref("comment", comment)
                        if out and not out[-1].endswith("\n"):
                            out[-1] = out[-1].rstrip(" ")
                            if not self.minify:
                                out[-1] += "  "  # put two spaces before comment
                        out.append("#" + ref)
                        comment = None
                    else:
                        raise CoconutInternalException("invalid comment marker in", getline(i, inputstring))
                elif string is not None:
                    if c is not None and c in nums:
                        string += c
                    elif c == unwrapper and string:
                        text, strchar = self.get_ref("str", string)
                        out.append(strchar + text + strchar)
                        string = None
                    else:
                        raise CoconutInternalException("invalid string marker in", getline(i, inputstring))
                elif c is not None:
                    if c == "#":
                        comment = ""
                    elif c == strwrapper:
                        string = ""
                    else:
                        out.append(c)

            except CoconutInternalException as err:
                complain(err)
                if comment is not None:
                    out.append(comment)
                    comment = None
                if string is not None:
                    out.append(string)
                    string = None
                out.append(c)

        return "".join(out)
335675
protected void pushBack(String str)
    {
        char[] chars = str.toCharArray();
        for ( int j = chars.length - 1; j >= 0; j-- ) {
            reader.unread(chars[j]);
        }
        idx -= chars.length;
    }
846134
def backlink(node):
    """"""
    seen = set()
    to_see = [node]
    while to_see:
      node = to_see.pop()
      seen.add(node)
      for succ in node.next:
        succ.prev.add(node)
        if succ not in seen:
          to_see.append(succ)
232548
def add_string_parameters(self, string):
        
        if isinstance(string, list):
            for x in string:
                self.add_string_parameters(x)
            return
        self._parameters.append("{ \"value\": \"" + string + "\" }")
334487
public void add(String str) {
        String[] tmp;

        if (size == data.length) {
            tmp = new String[data.length + GROW];
            System.arraycopy(data, 0, tmp, 0, data.length);
            data = tmp;
        }
        data[size] = str;
        size++;
    }
420147
public void addAll(final Iterable<String> strings) {
    checkNotNull(strings);
    for (String string : strings) {
      add(string);
    }
  }
197297
def add_state(self, string):
        """"""
        parsed_string = string.split()
        if len(parsed_string) > 0:
            state, rules = parsed_string[0], parsed_string[1:]

            if len(rules) != len(self.alphabet):
                raise SyntaxError('Wrong count of rules ({cur}/{exp}): {string}'
                                  .format(cur=len(rules), exp=len(self.alphabet),
                                          string=string))

            if state in self.states or state == self.TERM_STATE:
                raise SyntaxError('Double definition of state: ' + state)
            else:
                self.states[state] = []

            for rule in rules:
                try:
                    self._add_rule(state, rule)
                except SyntaxError as err:
                    self.states.pop(state)
                    raise err
1231549
public void addByeCommand() {
        StringBuilder buf = new StringBuilder();
        buf.append("(bye)");
        fifo.add(fifo.size(), buf.toString());
    }
186999
def send_backspace(self, count):
        
        for i in range(count):
            self.interface.send_key(Key.BACKSPACE)
375053
private void backpropagate() {
        for (int l = net.length; --l > 0;) {
            backpropagate(net[l], net[l - 1]);
        }
    }
151879
def _flds_append(flds, addthese, dont_add):
        """"""
        for fld in addthese:
            if fld not in flds and fld not in dont_add:
                flds.append(fld)
235785
def backtrack(self, source):
        """"""
        key = self.get_tok(source)
        s = self[key]()
        meta = s.metadata['original_source']
        cls = meta['cls']
        args = meta['args']
        kwargs = meta['kwargs']
        cls = import_name(cls)
        sout = cls(*args, **kwargs)
        sout.metadata = s.metadata['original_metadata']
        sout.name = s.metadata['original_name']
        return sout
1363007
public static String add( String... strings ) {
        int length = 0;
        for ( String str : strings ) {
            if ( str == null ) {
                continue;
            }
            length += str.length();
        }
        CharBuf builder = CharBuf.createExact( length );
        for ( String str : strings ) {
            if ( str == null ) {
                continue;
            }
            builder.add( str );
        }
        return builder.toString();
    }
935463
@Override
    public void backward() {
        Tensor xAdj = modIn.getOutputAdj();
        xAdj.add(yAdj.getValue(0));
    }
130490
public void addListeners()
    {
        super.addListeners();
        if (m_properties.size() > 0)
        {
            Record recPropertiesInput = this.getMainRecord();
            recPropertiesInput.setKeyArea(PropertiesInput.KEY_KEY);
            Iterator<Object> iterator = m_properties.keySet().iterator();
            while (iterator.hasNext())
            {
                String strKey = (String)iterator.next();
                try {
                    recPropertiesInput.addNew();
                    recPropertiesInput.getField(PropertiesInput.KEY).setString(strKey);
                    if (!recPropertiesInput.seek(null))
                    {
                        recPropertiesInput.addNew();
                        recPropertiesInput.getField(PropertiesInput.KEY).setString(strKey);
                        recPropertiesInput.add();
                    }
                } catch (DBException ex) {
                    ex.printStackTrace();
                }
            }
            //?this.getMainRecord().getField(PropertiesInput.KEY).setEnabled(false);
        }
    }
1254221
def stringify(self) :
        ""
        l = []
        h = self.head
        while h :
            l.append(str(h._key))
            h = h.nextDoc
        return "<->".join(l)
926271
def insert_text(self, s, from_undo=False):
        """"""
        return super().insert_text(
            ''.join(c for c in s if c in '0123456789'),
            from_undo
        )