27,
      27,
      28,
      27,
      27,
      27,
      27,
      27,
      26,
    )

  private val root = Node()

  init {
    for (i in CODE_BIT_COUNTS.indices) {
      addCode(i, CODES[i], CODE_BIT_COUNTS[i].toInt())
    }
  }

  @Throws(IOException::class)
  fun encode(
    source: ByteString,
    sink: BufferedSink,
  ) {
    var accumulator = 0L

        }

        override fun encode(
          writer: DerWriter,
          value: T,
        ) {
          val list = decompose(value)
          writer.withTypeHint {
            for (i in list.indices) {
              val adapter = members[i] as DerAdapter<Any?>
              adapter.toDer(writer, list[i])
            }
          }
        }
      }

    return BasicDerAdapter(
      name = name,

pkg go/ast, method (*IndexListExpr) Pos() token.Pos
pkg go/ast, type FuncType struct, TypeParams *FieldList
pkg go/ast, type IndexListExpr struct
pkg go/ast, type IndexListExpr struct, Indices []Expr
pkg go/ast, type IndexListExpr struct, Lbrack token.Pos
pkg go/ast, type IndexListExpr struct, Rbrack token.Pos
pkg go/ast, type IndexListExpr struct, X Expr
pkg go/ast, type TypeSpec struct, TypeParams *FieldList

        }
      }
    }

  private fun nameToFirstIndex(): Map<ByteString, Int> {
    val result = LinkedHashMap<ByteString, Int>(STATIC_HEADER_TABLE.size, 1.0F)
    for (i in STATIC_HEADER_TABLE.indices) {
      if (!result.containsKey(STATIC_HEADER_TABLE[i].name)) {
        result[STATIC_HEADER_TABLE[i].name] = i
      }
    }
    return result.unmodifiable()
  }

  class Writer
    @JvmOverloads

	}

	// xattr bar should always appear before others
	indices := []int{
		bytes.Index(buf.Bytes(), []byte("bar=bar")),
		bytes.Index(buf.Bytes(), []byte("baz=baz")),
		bytes.Index(buf.Bytes(), []byte("foo=foo")),
		bytes.Index(buf.Bytes(), []byte("qux=qux")),
	}
	if !slices.IsSorted(indices) {
		t.Fatal("PAX headers are not sorted")
	}
}

func TestUSTARLongName(t *testing.T) {

            assertNotNull(buildElement, "Build element should exist");

            List<Element> buildChildren = buildElement.children().toList();

            // Find the indices of pluginManagement and plugins
            int pluginManagementIndex = -1;
            int pluginsIndex = -1;

            for (int i = 0; i < buildChildren.size(); i++) {

	// The start index is inclusive and the end index is exclusive.
	type span struct {
		start int
		end   int
	}
	spans := make([]span, 0, 32)

	// Find the field start and end indices.
	// Doing this in a separate pass (rather than slicing the string s
	// and collecting the result substrings right away) is significantly
	// more efficient, possibly due to cache effects.

<a href="#Representability">representable</a> by a value of type
<code>int</code>; for arrays or constant strings, constant indices must also be in range.
If both indices are constant, they must satisfy <code>low &lt;= high</code>.
If the indices are out of range at run time, a <a href="#Run_time_panics">run-time panic</a> occurs.
</p>

<p>

      this.a = a;
      this.b = b;
    }
  }

  /**
   * Returns a stream consisting of the results of applying the given function to the elements of
   * {@code stream} and their indices in the stream. For example,
   *
   * {@snippet :
   * mapWithIndex(
   *     Stream.of("a", "b", "c"),
   *     (e, index) -> index + ":" + e)
   * }
   *

    static boolean hashFloodingDetected(@Nullable Object[] hashTable) {
      int maxRunBeforeFallback = maxRunBeforeFallback(hashTable.length);
      int mask = hashTable.length - 1;

      // Invariant: all elements at indices in [knownRunStart, knownRunEnd) are nonnull.
      // If knownRunStart == knownRunEnd, this is vacuously true.
      // When knownRunEnd exceeds hashTable.length, it "wraps", detecting runs around the end
      // of the table.