These are the three 'f' functions. See RFC 2144, section 2.2.
10617
function f1(d, m, r) {
    const t = m + d;
    const I = (t << r) | (t >>> (32 - r));
    return ((sBox[0][I >>> 24] ^ sBox[1][(I >>> 16) & 255]) - sBox[2][(I >>> 8) & 255]) + sBox[3][I & 255];
  }
50569
def function_offsets(file, functions)
      arch = architecture(file)
      objdump_bin = find_objdump(arch)
      objdump_cmd = ::Shellwords.join([objdump_bin, '-T', file])
      functions.map! { |f| '\\b' + f + '\\b' }
      ret = {}
      `#{objdump_cmd} | grep -iP '(#{functions.join('|')})'`.lines.map(&:chomp).each do |line|
        tokens = line.split
        ret[tokens.last] = tokens.first.to_i(16)
      end
      ret
    end
547512
function parseCFFDict(reader, offset, length) {
            if (null != offset) {
                reader.seek(offset);
            }

            var entries = [];
            var operands = [];
            var lastOffset = reader.offset + (null != length ? length : reader.length);

            while (reader.offset < lastOffset) {
                var op = reader.readUint8();

                // The first byte for each dict item distinguishes between operator (key) and operand (value).
                // Values <= 21 are operators.
                if (op <= 21) {
                    // Two-byte operators have an initial escape byte of 12.
                    if (op === 12) {
                        op = 1200 + reader.readUint8();
                    }

                    entries.push([op, operands]);
                    operands = [];
                }
                else {
                    // Since the operands (values) come before the operators (keys), we store all operands in a list
                    // until we encounter an operator.
                    operands.push(parseOperand(reader, op));
                }
            }

            return entriesToObject(entries);
        }
935491
def create_function_f_i(self):
        """"""
        return ca.Function(
            'f_i',
            [self.t, self.x, self.y, self.m, self.p, self.c, self.pre_c, self.ng, self.nu],
            [self.f_i],
            ['t', 'x', 'y', 'm', 'p', 'c', 'pre_c', 'ng', 'nu'], ['x_n'], self.func_opt)
917215
function pton(af, addr, dest, index) {
  switch (af) {
    case IPV4_OCTETS:
      return pton4(addr, dest, index)
    case IPV6_OCTETS:
      return pton6(addr, dest, index)
    default:
      throw new Error('Unsupported ip address.')
  }
}
1361775
function _curry3 (fn) {
  return function f3 (a, b, c) {
    switch (arguments.length) {
      case 0:
        return f3
      case 1:
        return _curry2(function (_b, _c) {
          return fn(a, _b, _c)
        })
      case 2:
        return function (_c) {
          return fn(a, b, _c)
        }
      default:
        return fn(a, b, c)
    }
  }
}
902515
def fqn(o):
    
    parts = []
    if isinstance(o, (str, bytes)):
        return o
    if not hasattr(o, '__module__'):
        raise ValueError('Invalid argument `%s`' % o)
    parts.append(o.__module__)
    if isclass(o):
        parts.append(o.__name__)
    elif isinstance(o, types.FunctionType):
        parts.append(o.__name__)
    else:
        parts.append(o.__class__.__name__)
    return '.'.join(parts)
499839
def SpiceUDREPI(f):
    
    @functools.wraps(f)
    def wrapping_udrepi(cnfine, srcpre, srcsurf):
        f(cnfine, srcpre, srcsurf)

    return UDREPI(wrapping_udrepi)
1373493
def fmap(self, f: Callable[[T], B]) -> 'List[B]':
        
        return List([f(x) for x in self.unbox()])
628493
def format_frameinfo(fi):
    
    s1 = "{0}:{1}".format(fi.filename, fi.lineno)
    s2 = "function:{0},    code_context:".format(fi.function)
    if fi.code_context:
        s3 = fi.code_context[0]
    else:
        s3 = "<no code context available>"

    return "\n".join([s1, s2, s3])
922335
def logical_xor(f1, f2):  # function factory
    '''
    '''
    def f_xor(arr):
        return np.logical_xor(f1(arr), f2(arr))
    f_xor.__name__ = f1.__name__ + "_xor_" + f2.__name__
    return f_xor
1344695
def standard_parsing_functions(Block, Tx):
    
    def stream_block(f, block):
        assert isinstance(block, Block)
        block.stream(f)

    def stream_blockheader(f, blockheader):
        assert isinstance(blockheader, Block)
        blockheader.stream_header(f)

    def stream_tx(f, tx):
        assert isinstance(tx, Tx)
        tx.stream(f)

    def parse_int_6(f):
        b = f.read(6) + b'\0\0'
        return struct.unpack(b, "<L")[0]

    def stream_int_6(f, v):
        f.write(struct.pack(v, "<L")[:6])

    more_parsing = [
        ("A", (PeerAddress.parse, lambda f, peer_addr: peer_addr.stream(f))),
        ("v", (InvItem.parse, lambda f, inv_item: inv_item.stream(f))),
        ("T", (Tx.parse, stream_tx)),
        ("B", (Block.parse, stream_block)),
        ("z", (Block.parse_as_header, stream_blockheader)),
        ("1", (lambda f: struct.unpack("B", f.read(1))[0], lambda f, v: f.write(struct.pack("B", v)))),
        ("6", (parse_int_6, stream_int_6)),
        ("O", (lambda f: True if f.read(1) else False,
               lambda f, v: f.write(b'' if v is None else struct.pack("B", v)))),
    ]
    all_items = list(STREAMER_FUNCTIONS.items())
    all_items.extend(more_parsing)
    return all_items
546907
def format_ft_def(func, full_name:str=None)->str:
    ""
    sig = inspect.signature(func)
    name = f'<code>{full_name or func.__name__}</code>'
    fmt_params = [format_param(param) for name,param
                  in sig.parameters.items() if name not in ('self','cls')]
    arg_str = f"({', '.join(fmt_params)})"
    if sig.return_annotation and (sig.return_annotation != sig.empty): arg_str += f" → {anno_repr(sig.return_annotation)}"
    if is_fastai_class(type(func)):        arg_str += f" :: {link_type(type(func))}"
    f_name = f"<code>class</code> {name}" if inspect.isclass(func) else name
    return f'{f_name}',f'{name}{arg_str}'
667483
def prepare_fw(bin_string):
    """"""
    pads = len(bin_string) % 128  # 128 bytes per page for atmega328
    for _ in range(128 - pads):  # pad up to even 128 bytes
        bin_string += b'\xff'
    fware = {
        'blocks': int(len(bin_string) / FIRMWARE_BLOCK_SIZE),
        'crc': compute_crc(bin_string),
        'data': bin_string,
    }
    return fware
738464
def decode_rfc2231(s):
    """"""
    parts = s.split(TICK, 2)
    if len(parts) <= 2:
        return None, None, s
    return parts
1003662
def SpiceUDFUNS(f):
    

    @functools.wraps(f)
    def wrapping_udfuns(x, value):
        result = f(x)
        value[0] = c_double(result)

    return UDFUNS(wrapping_udfuns)
787516
function (f) {
			var separator
				, temp = [];
			[ '/', '-', ' '].forEach(function(sep) {
				if (temp.length < 2) {
					separator = sep;
					temp = f.split(separator);
				}
			});
			return separator;				
		}