def get(index)
      return nil if @size == 0
      index += @size if index < 0
      return nil if index >= @size || index < 0
      return leaf_node_for(@root, @levels * BITS_PER_LEVEL, index)[index & INDEX_MASK]
    end
def get(index)
      return nil if @size == 0
      index += @size if index < 0
      return nil if index >= @size || index < 0
      return leaf_node_for(@root, @levels * BITS_PER_LEVEL, index)[index & INDEX_MASK]
    end
@!method update_in(*key_path, &block)
 Return a new `Tuple` with a deeply nested value modified to the result
 of the given code block.  When traversing the nested `Tuple`s and
 `Hash`es, non-existing keys are created with empty `Hash` values.

 The code block receives the existing value of the deeply nested key (or
 `nil` if it doesn't exist). This is useful for "transforming" the value
 associated with a certain key.

 Note that the original `Tuple` and sub-`Tuple`s and sub-`Hash`es are
 left unmodified; new data structure copies are created along the path
 wherever needed.

 @example
   t = Erlang::Tuple[123, 456, 789, Erlang::Map["a" => Erlang::Tuple[5, 6, 7]]]
   t.update_in(3, "a", 1) { |value| value + 9 }
   # => Erlang::Tuple[123, 456, 789, Erlang::Map["a" => Erlang::Tuple[5, 15, 7]]]

 @param key_path [Object(s)] List of keys which form the path to the key to be modified
 @yield [value] The previously stored value
 @yieldreturn [Object] The new value to store
 @return [Tuple]
 @see Associable#update_in
 Retrieve the element at `index`. If there is none (either the provided index
 is too high or too low), return `nil`.

 @example
   t = Erlang::Tuple["A", "B", "C", "D"]
   t.get(2)   # => "C"
   t.get(-1)  # => "D"
   t.get(4)   # => nil

 @param index [Integer] The index to retrieve
 @return [Object]