// ABI is a free data retrieval call binding the contract method 0x2203ab56.
//
// Solidity: function ABI(node bytes32, contentTypes uint256) constant returns(contentType uint256, data bytes)
350393
func (_PublicResolver *PublicResolverSession) ABI(node [32]byte, contentTypes *big.Int) (struct {
	ContentType *big.Int
	Data        []byte
}, error) {
	return _PublicResolver.Contract.ABI(&_PublicResolver.CallOpts, node, contentTypes)
}
148800
func (e *Env) Addr(k string) (reflect.Value, error) {
	e.RLock()
	defer e.RUnlock()

	if v, ok := e.env[k]; ok {
		if v.CanAddr() {
			return v.Addr(), nil
		}
		return nilValue, fmt.Errorf("unaddressable")
	}
	if e.external != nil {
		v, err := e.external.Get(k)
		if err == nil {
			if v.CanAddr() {
				return v.Addr(), nil
			}
			return nilValue, fmt.Errorf("unaddressable")
		}
	}
	if e.parent == nil {
		return nilValue, fmt.Errorf("undefined symbol '%s'", k)
	}
	return e.parent.Addr(k)
}
550363
func (d *Decoder) decodeBasic(name string, data interface{}, val reflect.Value) error {
	if val.IsValid() && val.Elem().IsValid() {
		return d.decode(name, data, val.Elem())
	}

	dataVal := reflect.ValueOf(data)

	// If the input data is a pointer, and the assigned type is the dereference
	// of that exact pointer, then indirect it so that we can assign it.
	// Example: *string to string
	if dataVal.Kind() == reflect.Ptr && dataVal.Type().Elem() == val.Type() {
		dataVal = reflect.Indirect(dataVal)
	}

	if !dataVal.IsValid() {
		dataVal = reflect.Zero(val.Type())
	}

	dataValType := dataVal.Type()
	if !dataValType.AssignableTo(val.Type()) {
		return fmt.Errorf(
			"'%s' expected type '%s', got '%s'",
			name, val.Type(), dataValType)
	}

	val.Set(dataVal)
	return nil
}
333638
func (lb *LBInterface) Interface() (*net.Interface, error) {
	iface, err := net.InterfaceByName(lb.Name)
	if err != nil {
		return nil, err
	}
	return iface, nil
}
126913
func (j *JsonQuery) Int(s ...string) (int, error) {
	val, err := rquery(j.blob, s...)
	if err != nil {
		return 0, err
	}
	return intFromInterface(val)
}
611394
func uint64FromNetwork(u uint64) uint64 {
	b := *(*[8]byte)(unsafe.Pointer(&u))
	return binary.BigEndian.Uint64(b[:])
}
1016372
func (document *XmlDocument) Uri() (val string) {
	val = C.GoString((*C.char)(unsafe.Pointer(document.Ptr.URL)))
	return
}
745599
func dbFetchBlockIDByHash(dbTx database.Tx, hash *chainhash.Hash) (uint32, error) {
	hashIndex := dbTx.Metadata().Bucket(idByHashIndexBucketName)
	serializedID := hashIndex.Get(hash[:])
	if serializedID == nil {
		return 0, errNoBlockIDEntry
	}

	return byteOrder.Uint32(serializedID), nil
}
383998
func sb3Inv(r0, r1, r2, r3 *uint32) {
	t0 := *r0 | *r1
	t1 := *r1 ^ *r2
	t2 := *r1 & t1
	t3 := *r0 ^ t2
	t4 := *r2 ^ t3
	t5 := *r3 | t3
	*r0 = t1 ^ t5
	t6 := t1 | t5
	t7 := *r3 ^ t6
	*r2 = t4 ^ t7
	t8 := t0 ^ t7
	t9 := *r0 & t8
	*r3 = t3 ^ t9
	*r1 = *r3 ^ (*r0 ^ t8)
}
307931
func Int32toInt24BEBytes(n int32) []byte {
	bytes := make([]byte, 3)
	if (n & 0x800000) > 0 {
		n |= ^0xffffff
	}
	bytes[0] = byte(n >> 16)
	bytes[1] = byte(n >> 8)
	bytes[2] = byte(n >> 0)

	return bytes
}
798140
func _go_glib_callback(cbi *C.callback_info) {
	value, found := callback_contexts.Get(int(cbi.func_no))
	if !found {
		return
	}
	context := value.(*CallbackContext)
	t := context.f.Type()
	fargs := make([]reflect.Value, t.NumIn())
	if len(fargs) > 0 {
		fargs[0] = reflect.ValueOf(context)
	}
	ret := context.f.Call(fargs)
	if len(ret) > 0 {
		value := ret[0].Interface()
		switch value.(type) {
		case bool:
			bval := gbool(value.(bool))
			cbi.ret = unsafe.Pointer(&bval)
		case byte:
			bval := C.gchar(value.(byte))
			cbi.ret = unsafe.Pointer(&bval)
		case int:
			ival := C.int(value.(int))
			cbi.ret = unsafe.Pointer(&ival)
		case uint:
			uval := C.guint(value.(uint))
			cbi.ret = unsafe.Pointer(&uval)
		case float32:
			f32val := C.gfloat(value.(float32))
			cbi.ret = unsafe.Pointer(&f32val)
		case float64:
			f64val := C.gfloat(value.(float64))
			cbi.ret = unsafe.Pointer(&f64val)
		case string:
			cbi.ret = unsafe.Pointer(C.CString(value.(string)))
		default:
			if pv, ok := value.(*[0]uint8); ok {
				cbi.ret = unsafe.Pointer(pv)
			} else {
				av := reflect.ValueOf(value)
				if av.Kind() == reflect.Ptr {
					cbi.ret = unsafe.Pointer(av.Pointer())
				} else if av.CanAddr() {
					cbi.ret = unsafe.Pointer(av.UnsafeAddr())
				} else {
					cbi.ret = unsafe.Pointer(&value)
				}
			}
		}
	}
}
744065
func (f *formatter) formatSci(b []byte, adj int, e byte) {
	f.WriteByte(b[0])

	if len(b) > 1 {
		f.WriteByte('.')
		f.Write(b[1:])
	}

	// If negative, the call to strconv.Itoa will add the minus sign for us.
	f.WriteByte(e)
	if adj > 0 {
		f.WriteByte('+')
	}
	f.WriteString(strconv.Itoa(adj))
}
782001
func LockIDFromBytes(data []byte) LockID {
	sum := sha512.Sum512(data)
	sum[0] = LockIDVersion0
	return LockID(binary.BigEndian.Uint64(sum[:8]))
}
603871
func getApi() (uint, error) {
	api := C.seccomp_api_get()
	if api == 0 {
		return 0, fmt.Errorf("API level operations are not supported")
	}

	return uint(api), nil
}
383404
func DecodeFunctionReturnFromFile(abiLocation, binPath, funcName string, resultRaw []byte, logger *logging.Logger) ([]*Variable, error) {
	abiSpecBytes, err := readAbi(binPath, abiLocation, logger)
	if err != nil {
		return nil, err
	}
	logger.TraceMsg("ABI Specification (Decode)", "spec", abiSpecBytes)

	// Unpack the result
	return DecodeFunctionReturn(abiSpecBytes, funcName, resultRaw)
}
118039
func bindTypeJava(kind abi.Type) string {
	stringKind := kind.String()
	innerLen, innerMapping := bindUnnestedTypeJava(stringKind)
	return arrayBindingJava(wrapArray(stringKind, innerLen, innerMapping))
}
314995
func byteID(x uint64) []byte {
	b := make([]byte, 8)
	binary.BigEndian.PutUint64(b, x)
	return b
}