Intern all the strings.
429190
public void intern() {
        symbol = symbol.intern();
        if (leftChild != null) {
            leftChild.intern();
        }
        if (rightChild != null) {
            rightChild.intern();
        }
    }
156182
public T intern(T o) {
    WeakReference<T> ref = map.get(o);
    if (ref == null) {
      ref = Generics.newWeakReference(o);
      map.put(o, ref);
    }
//    else {
//      System.err.println("Found dup for " + o);
//    }
    return ref.get();
  }
191971
@SuppressWarnings("unused")
    public static List<String> internListOf(Object... objects) {
        if (objects == null || objects.length == 0) {
            return Collections.emptyList();
        }
        List<String> strings = new ArrayList<>(objects.length);
        for (Object object : objects) {
            strings.add(object.toString().intern());
        }
        return Collections.unmodifiableList(strings);
    }
978955
public void writeIntern (String value)
        throws IOException
    {
        // if the value to be written is null, simply write a zero
        if (value == null) {
            writeShort(0);
            return;
        }

        // create our intern map if necessary
        if (_internmap == null) {
            _internmap = Maps.newHashMap();
        }

        // look up the intern mapping record
        Short code = _internmap.get(value);

        // create a mapping for the value if we've not got one
        if (code == null) {
            if (ObjectInputStream.STREAM_DEBUG) {
                log.info(hashCode() + ": Creating intern mapping", "code", _nextInternCode,
                         "value", value);
            }
            code = createInternMapping(_nextInternCode++);
            _internmap.put(value.intern(), code);

            // make sure we didn't blow past our maximum intern count
            if (_nextInternCode <= 0) {
                throw new RuntimeException("Too many unique interns written to ObjectOutputStream");
            }
            writeNewInternMapping(code, value);

        } else {
            writeExistingInternMapping(code, value);
        }
    }
567068
def sendall(self, data, **kws):
        """"""
        return SendAll(self, data, timeout=self._timeout, **kws)
1032293
def _remove_init_all(r):
    """"""
    new_r = redbaron.NodeList()
    for n in r.node_list:
        if n.type == 'assignment' and n.target.value == '__all__':
            pass
        else:
            new_r.append(n)
    return new_r
1192245
@Requires("name != null")
  @Ensures({
    "result != null",
    "result == methodHandles.get(name)"
  })
  protected List<MethodContractHandle> internMethod(String name) {
    ArrayList<MethodContractHandle> handles = methodHandles.get(name);
    if (handles == null) {
      handles = new ArrayList<MethodContractHandle>();
      methodHandles.put(name, handles);
    }
    return handles;
  }
1025439
def intern_atom(self, name, only_if_exists = 0):
        """"""
        r = request.InternAtom(display = self.display,
                               name = name,
                               only_if_exists = only_if_exists)
        return r.atom
290154
def iter_all_children(self):
        '''
        '''
        
        if self.inline_child:
            yield self.inline_child
        for x in self.children:
            yield x
1114837
def stop_everything(self):
        """"""
        for x in range(118):
            for c in range(16):
                self.stop_Note(x, c)
832582
def select_all(*str_or_rx)
      results = str_or_rx.flatten.map { |v| select_all_by v }
      results.first
    end
1018982
function stringInterner() { // eslint-disable-line no-unused-vars
  const strings = [];
  const ids = {};
  return {
    intern: function internString(s) {
      const find = ids[s];
      if (find === undefined) {
        const id = strings.length;
        ids[s] = id;
        strings.push(s);
        return id;
      } else {
        return find;
      }
    },
    get: function getString(id) {
      return strings[id];
    },
  };
}
1293841
function infect(tape) {
  if (!document) {
   tape.Test.prototype.html = function () {};
   return;
  }
  injectFavicon();
  createTestResults();
  setInitalStyle();
  decorateTape(tape);
  hijackLog();
  style();
}
509007
protected final void initializeAbstractProposition(String id,
            UniqueId uniqueId) {
        this.uniqueId = uniqueId;
        if (id == null) {
            this.id = "";
        } else {
            this.id = id.intern();
        }
    }
1299165
public void processAllChildren(TObjectProcedure<Cluster<T>> procedure) {
        if (children == null)
            return;
        for (Cluster<T> child : children) {
            procedure.execute(child);
            child.processAllChildren(procedure);
        }
    }
804516
def insert_slash(string, every=2):
    """"""
    return os.path.join(string[i:i+every] for i in xrange(0, len(string), every))
1184313
function all(config, parent) {
  var children = parent.children
  var length = children && children.length
  var index = -1
  var result = []
  var child
  var node
  var pos
  var prevEndLine
  var prevOffset
  var endLine

  while (++index < length) {
    node = children[index]
    pos = node.position
    endLine = position.start(node).line

    if (prevEndLine && endLine !== prevEndLine) {
      child = config.parser.tokenizeWhiteSpace(
        repeat(newline, endLine - prevEndLine)
      )
      patch(config, [child], prevOffset)

      if (child.value.length < 2) {
        child.value = repeat(newline, 2)
      }

      result.push(child)
    }

    child = one(config, node)

    if (child) {
      result = result.concat(child)
    }

    pos = position.end(node)
    prevEndLine = pos.line
    prevOffset = pos.offset
  }

  return result
}