This loads into something like Set[int]
19763
def _setload(l: Loader, value, type_) -> Set:
    
    t = type_.__args__[0]
    return {l.load(i, t) for i in value}
68204
public void setInt(int index, int value)
    {
        checkPositionIndexes(index, index + SIZE_OF_INT, this.length);
        index += offset;
        data[index] = (byte) (value);
        data[index + 1] = (byte) (value >>> 8);
        data[index + 2] = (byte) (value >>> 16);
        data[index + 3] = (byte) (value >>> 24);
    }
1355986
def set_int(bytearray_, byte_index, _int):
    
    # make sure were dealing with an int
    _int = int(_int)
    _bytes = struct.unpack('2B', struct.pack('>h', _int))
    bytearray_[byte_index:byte_index + 2] = _bytes
    return bytearray_
377727
private static final int gatherIntLE(final byte[] data, final int index) {
        int i = data[index] & 0xFF;

        i |= (data[index + 1] & 0xFF) << 8;
        i |= (data[index + 2] & 0xFF) << 16;
        i |= (data[index + 3] << 24);

        return i;
    }
1054808
def _make_set(var):
    '''
    
    '''
    if var is None:
        return set()
    if not isinstance(var, list):
        if isinstance(var, six.string_types):
            var = var.split()
        else:
            var = list(var)
    return set(var)
181127
def pop_int(count = 1)
      i = stack.pop(count).map{ |s| cast_to_int(s) }
      count == 1 ? i.first : i
    end
722064
@Override
  public Float set(int index, Float element) {
    return set(index, element.floatValue());
  }
708518
function sliceSet(set, skip = 0, count = set.size - skip) {
  const iterator = set.values()
  const output = new Set()
  while (count >= 0 && count--) {
    while (skip >= 0 && skip--) {
      iterator.next()
    }
    const {done, value} = iterator.next()
    if (done) {
      return output
    }
    output.add(value)
  }
  return output
}
981439
private static int[] toIntArray(List<Integer> list) {
    if (list == null || list.isEmpty()) {
      return NO_BINDS;
    }
    int[] res = new int[list.size()];
    for (int i = 0; i < list.size(); i++) {
      res[i] = list.get(i); // must not be null
    }
    return res;
  }
1045396
def int_to_array(i, length=2):
    """"""
    res = []
    for dummy in range(0, length):
        res.append(i & 0xff)
        i = i >> 8
    return reversed(res)
868525
def parse_int(self, buff, start, end):
        '''
            
        '''
#         num = self.parse_uint(buff, start, end)
#         l = (end - start)
#         return self.twos_comp(num, l * 8)
        return struct.unpack_from(self.structmap[end - start], buff, start)[0]
258009
Item set(final int type, final Number number) {
        this.type = type;
        this.number = number;
        this.hashCode = 0x7FFFFFFF & (type + number.intValue());
        return this;
    }
923189
public static IntSet and (IntSet... sets)
    {
        checkNotNull(sets);
        IntSet result = create();
        int len = sets.length;
        if (len > 0) {
            OUTER:
            for (Interator it = sets[0].interator(); it.hasNext(); ) {
                int val = it.nextInt();
                for (int ii = 1; ii < len; ii++) {
                    if (!sets[ii].contains(val)) {
                        continue OUTER;
                    }
                }
                result.add(val);
            }
        }
        return result;
    }
472216
def []=(k, v)

      load_onto_stack

      stack_push(k)
      stack_push(v)
      Lib.lua_settable(@pointer, -3)

      v
    end
1257903
private int nextSetBit(int fromIndex) {
      if (fromIndex < 0)
         throw new IndexOutOfBoundsException("fromIndex < 0: " + fromIndex);

      int u = intIndex(fromIndex);
      int arrayLength = array.length();
      if (u >= arrayLength)
         return -1;

      int possible = array.get(u) & (INT_MASK << fromIndex);

      while (true) {
         if (possible != 0) {
            return (u << ADDRESS_BITS_PER_INT) + Integer.numberOfTrailingZeros(possible);
         }
         if (++u == arrayLength) {
            return -1;
         }
         possible = array.get(u);
      }
   }
971011
function parseType (type) {
  var size
  var ret
  if (isArray(type)) {
    size = parseTypeArray(type)
    var subArray = type.slice(0, type.lastIndexOf('['))
    subArray = parseType(subArray)
    ret = {
      isArray: true,
      name: type,
      size: size,
      memoryUsage: size === 'dynamic' ? 32 : subArray.memoryUsage * size,
      subArray: subArray
    }
    return ret
  } else {
    var rawType
    switch (type) {
      case 'address':
        rawType = 'uint160'
        break
      case 'bool':
        rawType = 'uint8'
        break
      case 'string':
        rawType = 'bytes'
        break
    }
    ret = {
      rawType: rawType,
      name: type,
      memoryUsage: 32
    }

    if ((type.startsWith('bytes') && type !== 'bytes') || type.startsWith('uint') || type.startsWith('int')) {
      ret.size = parseTypeN(type)
    } else if (type.startsWith('ufixed') || type.startsWith('fixed')) {
      ret.size = parseTypeNxM(type)
    }

    if (type.startsWith('bytes') && type !== 'bytes' && (ret.size < 1 || ret.size > 32)) {
      throw new Error('Invalid bytes<N> width: ' + ret.size)
    }
    if ((type.startsWith('uint') || type.startsWith('int')) && (ret.size % 8 || ret.size < 8 || ret.size > 256)) {
      throw new Error('Invalid int/uint<N> width: ' + ret.size)
    }
    return ret
  }
}
80326
def parse_set(self):
        """"""
        lineno = next(self.stream).lineno
        target = self.parse_assign_target()
        self.stream.expect('assign')
        expr = self.parse_tuple()
        return nodes.Assign(target, expr, lineno=lineno)