pkg maps, func Collect[$0 comparable, $1 interface{}](iter.Seq2[$0, $1]) map[$0]$1 #61900
pkg maps, func Insert[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0, iter.Seq2[$1, $2]) #61900
pkg maps, func Keys[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) iter.Seq[$1] #61900
pkg maps, func Values[$0 interface{ ~map[$1]$2 }, $1 comparable, $2 interface{}]($0) iter.Seq[$2] #61900

            Currency.FRANC, Country.SWITZERLAND);
    EnumBiMap<Currency, Country> bimap = EnumBiMap.create(map);

    Iterator<Currency> iter = bimap.keySet().iterator();
    assertEquals(Currency.DOLLAR, iter.next());
    assertEquals(Currency.FRANC, iter.next());
    iter.remove();

    // forward map ordered by currency
    assertThat(bimap.keySet()).containsExactly(Currency.DOLLAR, Currency.PESO).inOrder();

        SmbTransport conn;

        synchronized (CONNECTIONS) {
            if (SSN_LIMIT != 1) {
                final ListIterator iter = CONNECTIONS.listIterator();
                while (iter.hasNext()) {
                    conn = (SmbTransport) iter.next();
                    if (conn.matches(address, port, localAddr, localPort, hostName)

    const ForwardOperation& op,
    std::unique_ptr<GradientFunction>* gradient_function) const {
  auto iter = registry_.find(op.op_name);
  if (iter == registry_.end()) {
    return absl::NotFoundError(
        absl::StrCat("No gradient defined for op: ", op.op_name, "."));
  }
  gradient_function->reset(iter->second(op));
  return absl::OkStatus();
}

TapeTensor::TapeTensor(AbstractTensorHandle* handle) : handle_(handle) {

    List<Integer> result = Lists.newArrayListWithCapacity(initial.size());
    for (Iterator<Integer> iter = q.iterator(); iter.hasNext(); ) {
      Integer value = iter.next();
      result.add(value);
      if (value == 8) {
        iter.remove();
      }
    }
    assertIntact(q);
    assertThat(result).containsExactly(1, 15, 13, 8, 14);
  }

  /**

                                    " into function '", fn_name, "'");

    input_tensors->emplace_back(node, idx);

    const auto& iter = input_nodes->find(node);
    if (iter == input_nodes->end()) {
      input_nodes->insert({node, {idx}});
    } else {
      auto& indices = iter->second;
      if (std::find(indices.begin(), indices.end(), idx) != indices.end()) {
        return InvalidArgument("TF_Output ", node->name(), ":", idx,

    List<Integer> result = Lists.newArrayListWithCapacity(initial.size());
    for (Iterator<Integer> iter = q.iterator(); iter.hasNext(); ) {
      Integer value = iter.next();
      result.add(value);
      if (value == 8) {
        iter.remove();
      }
    }
    assertIntact(q);
    assertThat(result).containsExactly(1, 15, 13, 8, 14);
  }

  /**

            }

            iter = sorted.listIterator();
            for (j = 0; iter.hasNext(); j++) {
                if (sort == 0) {
                    if (compareNames(dirents[i], name, (SmbFile) iter.next()) < 0) {
                        break;
                    }
                } else if (sort == 1) {
                    if (compareSizes(dirents[i], name, (SmbFile) iter.next()) < 0) {
                        break;

  auto iter = builder->attr_names.insert(attr_name).first;
  builder->Set(*iter, static_cast<tensorflow::DataType>(value));
}

void TF_AttrBuilderSetTypeList(TF_AttrBuilder* builder, const char* attr_name,
                               const TF_DataType* values, int num_values) {
  auto iter = builder->attr_names.insert(attr_name).first;

            }

            iter = sorted.listIterator();
            for (j = 0; iter.hasNext(); j++) {
                if (sort == 0) {
                    if (compareNames(dirents[i], name, iter.next()) < 0) {
                        break;
                    }
                } else if (sort == 1) {
                    if (compareSizes(dirents[i], name, iter.next()) < 0) {
                        break;