android-go/android28/main.go

package android28


/*
#cgo CFLAGS: -x objective-c -fno-objc-arc
#cgo LDFLAGS: -landroid -llog -lnativewindow -lm

#import <android/native_window.h>
#import <android/log.h>
#import <android/sensor.h>
#import <jni.h>
#import <stdlib.h>
#import <sys/stat.h>

*/
import "C"

import (
	"unsafe"
)

type Id struct {
	ptr unsafe.Pointer
}
func (o *Id) Ptr() unsafe.Pointer { if o == nil { return nil }; return o.ptr }

type Int C.int

type Stat64_t = C.struct_stat64

type Mode_t C.__mode_t

type AHardwareBuffer = C.struct_AHardwareBuffer

type Int32_t C.__int32_t

type ANativeWindow = C.struct_ANativeWindow

type Double C.double

type AHardwareBuffer_Desc = C.struct_AHardwareBuffer_Desc

type Float C.float

type ASensor = C.struct_ASensor

type Char C.char

type ASensorEventQueue = C.struct_ASensorEventQueue

type Long C.long

type ASensorManager = C.struct_ASensorManager

type LongLong C.longlong

type ALooper = C.struct_ALooper

type Bool C.bool

type Stat_t = C.struct_stat

type Timespec = C.struct_timespec

type Uint64_t C.__uint64_t

type ARect = C.struct_ARect

type Intmax_t C.int64_t

type Dev_t C.uint64_t

type Size_t C.ulong

type ANativeWindow_Buffer = C.struct_ANativeWindow_Buffer

type Uintmax_t C.uint64_t

type Int64_t C.__int64_t

type ASensorList *C.ASensorRef

type Ssize_t C.__kernel_ssize_t

type ASensorEvent = C.struct_ASensorEvent
const ANDROID_LOG_UNKNOWN = C.ANDROID_LOG_UNKNOWN
const ANDROID_LOG_DEFAULT = C.ANDROID_LOG_DEFAULT
const ANDROID_LOG_VERBOSE = C.ANDROID_LOG_VERBOSE
const ANDROID_LOG_DEBUG = C.ANDROID_LOG_DEBUG
const ANDROID_LOG_INFO = C.ANDROID_LOG_INFO
const ANDROID_LOG_WARN = C.ANDROID_LOG_WARN
const ANDROID_LOG_ERROR = C.ANDROID_LOG_ERROR
const ANDROID_LOG_FATAL = C.ANDROID_LOG_FATAL
const ANDROID_LOG_SILENT = C.ANDROID_LOG_SILENT

const LOG_ID_MIN = C.LOG_ID_MIN
const LOG_ID_MAIN = C.LOG_ID_MAIN
const LOG_ID_RADIO = C.LOG_ID_RADIO
const LOG_ID_EVENTS = C.LOG_ID_EVENTS
const LOG_ID_SYSTEM = C.LOG_ID_SYSTEM
const LOG_ID_CRASH = C.LOG_ID_CRASH
const LOG_ID_STATS = C.LOG_ID_STATS
const LOG_ID_SECURITY = C.LOG_ID_SECURITY
const LOG_ID_KERNEL = C.LOG_ID_KERNEL
const LOG_ID_MAX = C.LOG_ID_MAX

const JNIInvalidRefType = C.JNIInvalidRefType
const JNILocalRefType = C.JNILocalRefType
const JNIGlobalRefType = C.JNIGlobalRefType
const JNIWeakGlobalRefType = C.JNIWeakGlobalRefType

const ADATASPACE_UNKNOWN = C.ADATASPACE_UNKNOWN
const ADATASPACE_SCRGB_LINEAR = C.ADATASPACE_SCRGB_LINEAR
const ADATASPACE_SRGB = C.ADATASPACE_SRGB
const ADATASPACE_SCRGB = C.ADATASPACE_SCRGB
const ADATASPACE_DISPLAY_P3 = C.ADATASPACE_DISPLAY_P3
const ADATASPACE_BT2020_PQ = C.ADATASPACE_BT2020_PQ

const AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM = C.AHARDWAREBUFFER_FORMAT_R8G8B8A8_UNORM
const AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM = C.AHARDWAREBUFFER_FORMAT_R8G8B8X8_UNORM
const AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM = C.AHARDWAREBUFFER_FORMAT_R8G8B8_UNORM
const AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM = C.AHARDWAREBUFFER_FORMAT_R5G6B5_UNORM
const AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT = C.AHARDWAREBUFFER_FORMAT_R16G16B16A16_FLOAT
const AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM = C.AHARDWAREBUFFER_FORMAT_R10G10B10A2_UNORM
const AHARDWAREBUFFER_FORMAT_BLOB = C.AHARDWAREBUFFER_FORMAT_BLOB
const AHARDWAREBUFFER_FORMAT_D16_UNORM = C.AHARDWAREBUFFER_FORMAT_D16_UNORM
const AHARDWAREBUFFER_FORMAT_D24_UNORM = C.AHARDWAREBUFFER_FORMAT_D24_UNORM
const AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT = C.AHARDWAREBUFFER_FORMAT_D24_UNORM_S8_UINT
const AHARDWAREBUFFER_FORMAT_D32_FLOAT = C.AHARDWAREBUFFER_FORMAT_D32_FLOAT
const AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT = C.AHARDWAREBUFFER_FORMAT_D32_FLOAT_S8_UINT
const AHARDWAREBUFFER_FORMAT_S8_UINT = C.AHARDWAREBUFFER_FORMAT_S8_UINT
const AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420 = C.AHARDWAREBUFFER_FORMAT_Y8Cb8Cr8_420

const AHARDWAREBUFFER_USAGE_CPU_READ_NEVER = C.AHARDWAREBUFFER_USAGE_CPU_READ_NEVER
const AHARDWAREBUFFER_USAGE_CPU_READ_RARELY = C.AHARDWAREBUFFER_USAGE_CPU_READ_RARELY
const AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN = C.AHARDWAREBUFFER_USAGE_CPU_READ_OFTEN
const AHARDWAREBUFFER_USAGE_CPU_READ_MASK = C.AHARDWAREBUFFER_USAGE_CPU_READ_MASK
const AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER = C.AHARDWAREBUFFER_USAGE_CPU_WRITE_NEVER
const AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY = C.AHARDWAREBUFFER_USAGE_CPU_WRITE_RARELY
const AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN = C.AHARDWAREBUFFER_USAGE_CPU_WRITE_OFTEN
const AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK = C.AHARDWAREBUFFER_USAGE_CPU_WRITE_MASK
const AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE = C.AHARDWAREBUFFER_USAGE_GPU_SAMPLED_IMAGE
const AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER = C.AHARDWAREBUFFER_USAGE_GPU_FRAMEBUFFER
const AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT = C.AHARDWAREBUFFER_USAGE_GPU_COLOR_OUTPUT
const AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY = C.AHARDWAREBUFFER_USAGE_COMPOSER_OVERLAY
const AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT = C.AHARDWAREBUFFER_USAGE_PROTECTED_CONTENT
const AHARDWAREBUFFER_USAGE_VIDEO_ENCODE = C.AHARDWAREBUFFER_USAGE_VIDEO_ENCODE
const AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA = C.AHARDWAREBUFFER_USAGE_SENSOR_DIRECT_DATA
const AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER = C.AHARDWAREBUFFER_USAGE_GPU_DATA_BUFFER
const AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP = C.AHARDWAREBUFFER_USAGE_GPU_CUBE_MAP
const AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE = C.AHARDWAREBUFFER_USAGE_GPU_MIPMAP_COMPLETE
const AHARDWAREBUFFER_USAGE_VENDOR_0 = C.AHARDWAREBUFFER_USAGE_VENDOR_0
const AHARDWAREBUFFER_USAGE_VENDOR_1 = C.AHARDWAREBUFFER_USAGE_VENDOR_1
const AHARDWAREBUFFER_USAGE_VENDOR_2 = C.AHARDWAREBUFFER_USAGE_VENDOR_2
const AHARDWAREBUFFER_USAGE_VENDOR_3 = C.AHARDWAREBUFFER_USAGE_VENDOR_3
const AHARDWAREBUFFER_USAGE_VENDOR_4 = C.AHARDWAREBUFFER_USAGE_VENDOR_4
const AHARDWAREBUFFER_USAGE_VENDOR_5 = C.AHARDWAREBUFFER_USAGE_VENDOR_5
const AHARDWAREBUFFER_USAGE_VENDOR_6 = C.AHARDWAREBUFFER_USAGE_VENDOR_6
const AHARDWAREBUFFER_USAGE_VENDOR_7 = C.AHARDWAREBUFFER_USAGE_VENDOR_7
const AHARDWAREBUFFER_USAGE_VENDOR_8 = C.AHARDWAREBUFFER_USAGE_VENDOR_8
const AHARDWAREBUFFER_USAGE_VENDOR_9 = C.AHARDWAREBUFFER_USAGE_VENDOR_9
const AHARDWAREBUFFER_USAGE_VENDOR_10 = C.AHARDWAREBUFFER_USAGE_VENDOR_10
const AHARDWAREBUFFER_USAGE_VENDOR_11 = C.AHARDWAREBUFFER_USAGE_VENDOR_11
const AHARDWAREBUFFER_USAGE_VENDOR_12 = C.AHARDWAREBUFFER_USAGE_VENDOR_12
const AHARDWAREBUFFER_USAGE_VENDOR_13 = C.AHARDWAREBUFFER_USAGE_VENDOR_13
const AHARDWAREBUFFER_USAGE_VENDOR_14 = C.AHARDWAREBUFFER_USAGE_VENDOR_14
const AHARDWAREBUFFER_USAGE_VENDOR_15 = C.AHARDWAREBUFFER_USAGE_VENDOR_15
const AHARDWAREBUFFER_USAGE_VENDOR_16 = C.AHARDWAREBUFFER_USAGE_VENDOR_16
const AHARDWAREBUFFER_USAGE_VENDOR_17 = C.AHARDWAREBUFFER_USAGE_VENDOR_17
const AHARDWAREBUFFER_USAGE_VENDOR_18 = C.AHARDWAREBUFFER_USAGE_VENDOR_18
const AHARDWAREBUFFER_USAGE_VENDOR_19 = C.AHARDWAREBUFFER_USAGE_VENDOR_19

const WINDOW_FORMAT_RGBA_8888 = C.WINDOW_FORMAT_RGBA_8888
const WINDOW_FORMAT_RGBX_8888 = C.WINDOW_FORMAT_RGBX_8888
const WINDOW_FORMAT_RGB_565 = C.WINDOW_FORMAT_RGB_565

const ANATIVEWINDOW_TRANSFORM_IDENTITY = C.ANATIVEWINDOW_TRANSFORM_IDENTITY
const ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL = C.ANATIVEWINDOW_TRANSFORM_MIRROR_HORIZONTAL
const ANATIVEWINDOW_TRANSFORM_MIRROR_VERTICAL = C.ANATIVEWINDOW_TRANSFORM_MIRROR_VERTICAL
const ANATIVEWINDOW_TRANSFORM_ROTATE_90 = C.ANATIVEWINDOW_TRANSFORM_ROTATE_90
const ANATIVEWINDOW_TRANSFORM_ROTATE_180 = C.ANATIVEWINDOW_TRANSFORM_ROTATE_180
const ANATIVEWINDOW_TRANSFORM_ROTATE_270 = C.ANATIVEWINDOW_TRANSFORM_ROTATE_270

const ALOOPER_PREPARE_ALLOW_NON_CALLBACKS = C.ALOOPER_PREPARE_ALLOW_NON_CALLBACKS

const ALOOPER_POLL_WAKE = C.ALOOPER_POLL_WAKE
const ALOOPER_POLL_CALLBACK = C.ALOOPER_POLL_CALLBACK
const ALOOPER_POLL_TIMEOUT = C.ALOOPER_POLL_TIMEOUT
const ALOOPER_POLL_ERROR = C.ALOOPER_POLL_ERROR

const ALOOPER_EVENT_INPUT = C.ALOOPER_EVENT_INPUT
const ALOOPER_EVENT_OUTPUT = C.ALOOPER_EVENT_OUTPUT
const ALOOPER_EVENT_ERROR = C.ALOOPER_EVENT_ERROR
const ALOOPER_EVENT_HANGUP = C.ALOOPER_EVENT_HANGUP
const ALOOPER_EVENT_INVALID = C.ALOOPER_EVENT_INVALID

const ASENSOR_TYPE_INVALID = C.ASENSOR_TYPE_INVALID
const ASENSOR_TYPE_ACCELEROMETER = C.ASENSOR_TYPE_ACCELEROMETER
const ASENSOR_TYPE_MAGNETIC_FIELD = C.ASENSOR_TYPE_MAGNETIC_FIELD
const ASENSOR_TYPE_GYROSCOPE = C.ASENSOR_TYPE_GYROSCOPE
const ASENSOR_TYPE_LIGHT = C.ASENSOR_TYPE_LIGHT
const ASENSOR_TYPE_PRESSURE = C.ASENSOR_TYPE_PRESSURE
const ASENSOR_TYPE_PROXIMITY = C.ASENSOR_TYPE_PROXIMITY
const ASENSOR_TYPE_GRAVITY = C.ASENSOR_TYPE_GRAVITY
const ASENSOR_TYPE_LINEAR_ACCELERATION = C.ASENSOR_TYPE_LINEAR_ACCELERATION
const ASENSOR_TYPE_ROTATION_VECTOR = C.ASENSOR_TYPE_ROTATION_VECTOR
const ASENSOR_TYPE_RELATIVE_HUMIDITY = C.ASENSOR_TYPE_RELATIVE_HUMIDITY
const ASENSOR_TYPE_AMBIENT_TEMPERATURE = C.ASENSOR_TYPE_AMBIENT_TEMPERATURE
const ASENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED = C.ASENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED
const ASENSOR_TYPE_GAME_ROTATION_VECTOR = C.ASENSOR_TYPE_GAME_ROTATION_VECTOR
const ASENSOR_TYPE_GYROSCOPE_UNCALIBRATED = C.ASENSOR_TYPE_GYROSCOPE_UNCALIBRATED
const ASENSOR_TYPE_SIGNIFICANT_MOTION = C.ASENSOR_TYPE_SIGNIFICANT_MOTION
const ASENSOR_TYPE_STEP_DETECTOR = C.ASENSOR_TYPE_STEP_DETECTOR
const ASENSOR_TYPE_STEP_COUNTER = C.ASENSOR_TYPE_STEP_COUNTER
const ASENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR = C.ASENSOR_TYPE_GEOMAGNETIC_ROTATION_VECTOR
const ASENSOR_TYPE_HEART_RATE = C.ASENSOR_TYPE_HEART_RATE
const ASENSOR_TYPE_POSE_6DOF = C.ASENSOR_TYPE_POSE_6DOF
const ASENSOR_TYPE_STATIONARY_DETECT = C.ASENSOR_TYPE_STATIONARY_DETECT
const ASENSOR_TYPE_MOTION_DETECT = C.ASENSOR_TYPE_MOTION_DETECT
const ASENSOR_TYPE_HEART_BEAT = C.ASENSOR_TYPE_HEART_BEAT
const ASENSOR_TYPE_ADDITIONAL_INFO = C.ASENSOR_TYPE_ADDITIONAL_INFO
const ASENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT = C.ASENSOR_TYPE_LOW_LATENCY_OFFBODY_DETECT
const ASENSOR_TYPE_ACCELEROMETER_UNCALIBRATED = C.ASENSOR_TYPE_ACCELEROMETER_UNCALIBRATED

const ASENSOR_STATUS_NO_CONTACT = C.ASENSOR_STATUS_NO_CONTACT
const ASENSOR_STATUS_UNRELIABLE = C.ASENSOR_STATUS_UNRELIABLE
const ASENSOR_STATUS_ACCURACY_LOW = C.ASENSOR_STATUS_ACCURACY_LOW
const ASENSOR_STATUS_ACCURACY_MEDIUM = C.ASENSOR_STATUS_ACCURACY_MEDIUM
const ASENSOR_STATUS_ACCURACY_HIGH = C.ASENSOR_STATUS_ACCURACY_HIGH

const AREPORTING_MODE_INVALID = C.AREPORTING_MODE_INVALID
const AREPORTING_MODE_CONTINUOUS = C.AREPORTING_MODE_CONTINUOUS
const AREPORTING_MODE_ON_CHANGE = C.AREPORTING_MODE_ON_CHANGE
const AREPORTING_MODE_ONE_SHOT = C.AREPORTING_MODE_ONE_SHOT
const AREPORTING_MODE_SPECIAL_TRIGGER = C.AREPORTING_MODE_SPECIAL_TRIGGER

const ASENSOR_DIRECT_RATE_STOP = C.ASENSOR_DIRECT_RATE_STOP
const ASENSOR_DIRECT_RATE_NORMAL = C.ASENSOR_DIRECT_RATE_NORMAL
const ASENSOR_DIRECT_RATE_FAST = C.ASENSOR_DIRECT_RATE_FAST
const ASENSOR_DIRECT_RATE_VERY_FAST = C.ASENSOR_DIRECT_RATE_VERY_FAST

const ASENSOR_DIRECT_CHANNEL_TYPE_SHARED_MEMORY = C.ASENSOR_DIRECT_CHANNEL_TYPE_SHARED_MEMORY
const ASENSOR_DIRECT_CHANNEL_TYPE_HARDWARE_BUFFER = C.ASENSOR_DIRECT_CHANNEL_TYPE_HARDWARE_BUFFER

const ASENSOR_ADDITIONAL_INFO_BEGIN = C.ASENSOR_ADDITIONAL_INFO_BEGIN
const ASENSOR_ADDITIONAL_INFO_END = C.ASENSOR_ADDITIONAL_INFO_END
const ASENSOR_ADDITIONAL_INFO_UNTRACKED_DELAY = C.ASENSOR_ADDITIONAL_INFO_UNTRACKED_DELAY
const ASENSOR_ADDITIONAL_INFO_INTERNAL_TEMPERATURE = C.ASENSOR_ADDITIONAL_INFO_INTERNAL_TEMPERATURE
const ASENSOR_ADDITIONAL_INFO_VEC3_CALIBRATION = C.ASENSOR_ADDITIONAL_INFO_VEC3_CALIBRATION
const ASENSOR_ADDITIONAL_INFO_SENSOR_PLACEMENT = C.ASENSOR_ADDITIONAL_INFO_SENSOR_PLACEMENT
const ASENSOR_ADDITIONAL_INFO_SAMPLING = C.ASENSOR_ADDITIONAL_INFO_SAMPLING


func CharWithGoString(s string) *Char {
	return (*Char)(unsafe.Pointer(C.CString(s)))
}

func CharWithBytes(b []byte) *Char {
	return (*Char)(unsafe.Pointer(C.CString(string(b))))
}

func (c *Char) String() string {
	return C.GoString((*C.char)(c))
}

func (c *Char) Free() {
	C.free(unsafe.Pointer(c))
}

func Fstat64(__fd Int, __buf *Stat64_t) Int {
	ret := (Int)(C.fstat64((C.int)(__fd), (*C.struct_stat64)(__buf)))
	return ret
}

func Umask(__mask Mode_t) Mode_t {
	ret := (Mode_t)(C.umask((C.mode_t)(__mask)))
	return ret
}

func AHardwareBufferAcquire(buffer *AHardwareBuffer)  {
	C.AHardwareBuffer_acquire((*C.AHardwareBuffer)(buffer))
}

func ANativeWindowSetBuffersGeometry(window *ANativeWindow, width Int32_t, height Int32_t, format Int32_t) Int32_t {
	ret := (Int32_t)(C.ANativeWindow_setBuffersGeometry((*C.ANativeWindow)(window), (C.int32_t)(width), (C.int32_t)(height), (C.int32_t)(format)))
	return ret
}

func ANativeWindowAcquire(window *ANativeWindow)  {
	C.ANativeWindow_acquire((*C.ANativeWindow)(window))
}

func Ceil(__x Double) Double {
	ret := (Double)(C.ceil((C.double)(__x)))
	return ret
}

func AHardwareBufferAllocate(desc *AHardwareBuffer_Desc, outBuffer []*AHardwareBuffer) Int {
	ret := (Int)(C.AHardwareBuffer_allocate((*C.AHardwareBuffer_Desc)(desc), (**C.AHardwareBuffer)(unsafe.Pointer(&outBuffer[0]))))
	return ret
}

func AHardwareBufferDescribe(buffer *AHardwareBuffer, outDesc *AHardwareBuffer_Desc)  {
	C.AHardwareBuffer_describe((*C.AHardwareBuffer)(buffer), (*C.AHardwareBuffer_Desc)(outDesc))
}

func Lgamma(__x Double) Double {
	ret := (Double)(C.lgamma((C.double)(__x)))
	return ret
}

func Nextafterf(__x Float, __y Float) Float {
	ret := (Float)(C.nextafterf((C.float)(__x), (C.float)(__y)))
	return ret
}

func AHardwareBufferUnlock(buffer *AHardwareBuffer, fence *Int32_t) Int {
	ret := (Int)(C.AHardwareBuffer_unlock((*C.AHardwareBuffer)(buffer), (*C.int32_t)(fence)))
	return ret
}

func ASensorGetType(sensor *ASensor) Int {
	ret := (Int)(C.ASensor_getType((*C.ASensor)(sensor)))
	return ret
}

func Atan2f(__y Float, __x Float) Float {
	ret := (Float)(C.atan2f((C.float)(__y), (C.float)(__x)))
	return ret
}

func Sinh(__x Double) Double {
	ret := (Double)(C.sinh((C.double)(__x)))
	return ret
}

func Asinhf(__x Float) Float {
	ret := (Float)(C.asinhf((C.float)(__x)))
	return ret
}

func ASensorGetVendor(sensor *ASensor) *Char {
	ret := (*Char)(unsafe.Pointer(C.ASensor_getVendor((*C.ASensor)(sensor))))
	return ret
}

func Fmodf(__x Float, __y Float) Float {
	ret := (Float)(C.fmodf((C.float)(__x), (C.float)(__y)))
	return ret
}

func ASensorEventQueueDisableSensor(queue *ASensorEventQueue, sensor *ASensor) Int {
	ret := (Int)(C.ASensorEventQueue_disableSensor((*C.ASensorEventQueue)(queue), (*C.ASensor)(sensor)))
	return ret
}

func Atoi(__s *Char) Int {
	ret := (Int)(C.atoi((*C.char)(__s)))
	return ret
}

func Lrintf(__x Float) Long {
	ret := (Long)(C.lrintf((C.float)(__x)))
	return ret
}

func Jn(__n Int, __x Double) Double {
	ret := (Double)(C.jn((C.int)(__n), (C.double)(__x)))
	return ret
}

func Ilogbf(__x Float) Int {
	ret := (Int)(C.ilogbf((C.float)(__x)))
	return ret
}

func Logb(__x Double) Double {
	ret := (Double)(C.logb((C.double)(__x)))
	return ret
}

func ANativeWindowGetFormat(window *ANativeWindow) Int32_t {
	ret := (Int32_t)(C.ANativeWindow_getFormat((*C.ANativeWindow)(window)))
	return ret
}

func Logbf(__x Float) Float {
	ret := (Float)(C.logbf((C.float)(__x)))
	return ret
}

func ASensorManagerGetDefaultSensor(manager *ASensorManager, type_ Int) *ASensor {
	ret := (*ASensor)(unsafe.Pointer(C.ASensorManager_getDefaultSensor((*C.ASensorManager)(manager), (C.int)(type_))))
	return ret
}

func AHardwareBufferSendHandleToUnixSocket(buffer *AHardwareBuffer, socketFd Int) Int {
	ret := (Int)(C.AHardwareBuffer_sendHandleToUnixSocket((*C.AHardwareBuffer)(buffer), (C.int)(socketFd)))
	return ret
}

func Atanf(__x Float) Float {
	ret := (Float)(C.atanf((C.float)(__x)))
	return ret
}

func Fmaf(__x Float, __y Float, __z Float) Float {
	ret := (Float)(C.fmaf((C.float)(__x), (C.float)(__y), (C.float)(__z)))
	return ret
}

func Tanf(__x Float) Float {
	ret := (Float)(C.tanf((C.float)(__x)))
	return ret
}

func Expf(__x Float) Float {
	ret := (Float)(C.expf((C.float)(__x)))
	return ret
}

func Fdimf(__x Float, __y Float) Float {
	ret := (Float)(C.fdimf((C.float)(__x), (C.float)(__y)))
	return ret
}

func ASensorGetMinDelay(sensor *ASensor) Int {
	ret := (Int)(C.ASensor_getMinDelay((*C.ASensor)(sensor)))
	return ret
}

func Remquof(__x Float, __y Float, __quotient_bits *Int) Float {
	ret := (Float)(C.remquof((C.float)(__x), (C.float)(__y), (*C.int)(__quotient_bits)))
	return ret
}

func Lstat64(__path *Char, __buf *Stat64_t) Int {
	ret := (Int)(C.lstat64((*C.char)(__path), (*C.struct_stat64)(__buf)))
	return ret
}

func Remainder(__x Double, __y Double) Double {
	ret := (Double)(C.remainder((C.double)(__x), (C.double)(__y)))
	return ret
}

func Lgammaf(__x Float) Float {
	ret := (Float)(C.lgammaf((C.float)(__x)))
	return ret
}

func Mkdir(__path *Char, __mode Mode_t) Int {
	ret := (Int)(C.mkdir((*C.char)(__path), (C.mode_t)(__mode)))
	return ret
}

func Cosh(__x Double) Double {
	ret := (Double)(C.cosh((C.double)(__x)))
	return ret
}

func Expm1f(__x Float) Float {
	ret := (Float)(C.expm1f((C.float)(__x)))
	return ret
}

func ASensorGetFifoReservedEventCount(sensor *ASensor) Int {
	ret := (Int)(C.ASensor_getFifoReservedEventCount((*C.ASensor)(sensor)))
	return ret
}

func ASensorGetHighestDirectReportRateLevel(sensor *ASensor) Int {
	ret := (Int)(C.ASensor_getHighestDirectReportRateLevel((*C.ASensor)(sensor)))
	return ret
}

func Erf(__x Double) Double {
	ret := (Double)(C.erf((C.double)(__x)))
	return ret
}

func Y0(__x Double) Double {
	ret := (Double)(C.y0((C.double)(__x)))
	return ret
}

func Nanf(__kind *Char) Float {
	ret := (Float)(C.nanf((*C.char)(__kind)))
	return ret
}

func ASensorEventQueueEnableSensor(queue *ASensorEventQueue, sensor *ASensor) Int {
	ret := (Int)(C.ASensorEventQueue_enableSensor((*C.ASensorEventQueue)(queue), (*C.ASensor)(sensor)))
	return ret
}

func ASensorGetResolution(sensor *ASensor) Float {
	ret := (Float)(C.ASensor_getResolution((*C.ASensor)(sensor)))
	return ret
}

func Sin(__x Double) Double {
	ret := (Double)(C.sin((C.double)(__x)))
	return ret
}

func Scalbnf(__x Float, __exponent Int) Float {
	ret := (Float)(C.scalbnf((C.float)(__x), (C.int)(__exponent)))
	return ret
}

func Sqrtf(__x Float) Float {
	ret := (Float)(C.sqrtf((C.float)(__x)))
	return ret
}

func Nearbyint(__x Double) Double {
	ret := (Double)(C.nearbyint((C.double)(__x)))
	return ret
}

func Coshf(__x Float) Float {
	ret := (Float)(C.coshf((C.float)(__x)))
	return ret
}

func Exp(__x Double) Double {
	ret := (Double)(C.exp((C.double)(__x)))
	return ret
}

func Atan2(__y Double, __x Double) Double {
	ret := (Double)(C.atan2((C.double)(__y), (C.double)(__x)))
	return ret
}

func Expm1(__x Double) Double {
	ret := (Double)(C.expm1((C.double)(__x)))
	return ret
}

func Modff(__x Float, __integral_part *Float) Float {
	ret := (Float)(C.modff((C.float)(__x), (*C.float)(__integral_part)))
	return ret
}

func Fabsf(__x Float) Float {
	ret := (Float)(C.fabsf((C.float)(__x)))
	return ret
}

func ASensorEventQueueSetEventRate(queue *ASensorEventQueue, sensor *ASensor, usec Int32_t) Int {
	ret := (Int)(C.ASensorEventQueue_setEventRate((*C.ASensorEventQueue)(queue), (*C.ASensor)(sensor), (C.int32_t)(usec)))
	return ret
}

func ANativeWindowGetWidth(window *ANativeWindow) Int32_t {
	ret := (Int32_t)(C.ANativeWindow_getWidth((*C.ANativeWindow)(window)))
	return ret
}

func Asinf(__x Float) Float {
	ret := (Float)(C.asinf((C.float)(__x)))
	return ret
}

func ASensorGetName(sensor *ASensor) *Char {
	ret := (*Char)(unsafe.Pointer(C.ASensor_getName((*C.ASensor)(sensor))))
	return ret
}

func Fchmod(__fd Int, __mode Mode_t) Int {
	ret := (Int)(C.fchmod((C.int)(__fd), (C.mode_t)(__mode)))
	return ret
}

func Frexp(__x Double, __exponent *Int) Double {
	ret := (Double)(C.frexp((C.double)(__x), (*C.int)(__exponent)))
	return ret
}

func Scalblnf(__x Float, __exponent Long) Float {
	ret := (Float)(C.scalblnf((C.float)(__x), (C.long)(__exponent)))
	return ret
}

func Rintf(__x Float) Float {
	ret := (Float)(C.rintf((C.float)(__x)))
	return ret
}

func Llround(__x Double) LongLong {
	ret := (LongLong)(C.llround((C.double)(__x)))
	return ret
}

func ASensorGetStringType(sensor *ASensor) *Char {
	ret := (*Char)(unsafe.Pointer(C.ASensor_getStringType((*C.ASensor)(sensor))))
	return ret
}

func ANativeWindowRelease(window *ANativeWindow)  {
	C.ANativeWindow_release((*C.ANativeWindow)(window))
}

func Exp2f(__x Float) Float {
	ret := (Float)(C.exp2f((C.float)(__x)))
	return ret
}

func ALooperAcquire(looper *ALooper)  {
	C.ALooper_acquire((*C.ALooper)(looper))
}

func ASensorIsWakeUpSensor(sensor *ASensor) Bool {
	ret := (Bool)(C.ASensor_isWakeUpSensor((*C.ASensor)(sensor)))
	return ret
}

func AndroidGetApplicationTargetSdkVersion() Int {
	ret := (Int)(C.android_get_application_target_sdk_version())
	return ret
}

func ANativeWindowGetBuffersDataSpace(window *ANativeWindow) Int32_t {
	ret := (Int32_t)(C.ANativeWindow_getBuffersDataSpace((*C.ANativeWindow)(window)))
	return ret
}

func Roundf(__x Float) Float {
	ret := (Float)(C.roundf((C.float)(__x)))
	return ret
}

func Log1pf(__x Float) Float {
	ret := (Float)(C.log1pf((C.float)(__x)))
	return ret
}

func Nan(__kind *Char) Double {
	ret := (Double)(C.nan((*C.char)(__kind)))
	return ret
}

func Sinf(__x Float) Float {
	ret := (Float)(C.sinf((C.float)(__x)))
	return ret
}

func Lrint(__x Double) Long {
	ret := (Long)(C.lrint((C.double)(__x)))
	return ret
}

func Isinf(__x Double) Int {
	ret := (Int)(C.isinf((C.double)(__x)))
	return ret
}

func ALooperPollAll(timeoutMillis Int, outFd *Int, outEvents *Int, outData *unsafe.Pointer) Int {
	ret := (Int)(C.ALooper_pollAll((C.int)(timeoutMillis), (*C.int)(outFd), (*C.int)(outEvents), outData))
	return ret
}

func Cos(__x Double) Double {
	ret := (Double)(C.cos((C.double)(__x)))
	return ret
}

func J0(__x Double) Double {
	ret := (Double)(C.j0((C.double)(__x)))
	return ret
}

func ANativeWindowUnlockAndPost(window *ANativeWindow) Int32_t {
	ret := (Int32_t)(C.ANativeWindow_unlockAndPost((*C.ANativeWindow)(window)))
	return ret
}

func ALooperRemoveFd(looper *ALooper, fd Int) Int {
	ret := (Int)(C.ALooper_removeFd((*C.ALooper)(looper), (C.int)(fd)))
	return ret
}

func Tanhf(__x Float) Float {
	ret := (Float)(C.tanhf((C.float)(__x)))
	return ret
}

func Log2f(__x Float) Float {
	ret := (Float)(C.log2f((C.float)(__x)))
	return ret
}

func Fabs(__x Double) Double {
	ret := (Double)(C.fabs((C.double)(__x)))
	return ret
}

func Llrintf(__x Float) LongLong {
	ret := (LongLong)(C.llrintf((C.float)(__x)))
	return ret
}

func Fmax(__x Double, __y Double) Double {
	ret := (Double)(C.fmax((C.double)(__x), (C.double)(__y)))
	return ret
}

func SystemPropertyGet(__name *Char, __value *Char) Int {
	ret := (Int)(C.__system_property_get((*C.char)(__name), (*C.char)(__value)))
	return ret
}

func ANativeWindowSetBuffersTransform(window *ANativeWindow, transform Int32_t) Int32_t {
	ret := (Int32_t)(C.ANativeWindow_setBuffersTransform((*C.ANativeWindow)(window), (C.int32_t)(transform)))
	return ret
}

func Log10f(__x Float) Float {
	ret := (Float)(C.log10f((C.float)(__x)))
	return ret
}

func Yn(__n Int, __x Double) Double {
	ret := (Double)(C.yn((C.int)(__n), (C.double)(__x)))
	return ret
}

func ASensorManagerGetDefaultSensorEx(manager *ASensorManager, type_ Int, wakeUp Bool) *ASensor {
	ret := (*ASensor)(unsafe.Pointer(C.ASensorManager_getDefaultSensorEx((*C.ASensorManager)(manager), (C.int)(type_), (C.bool)(wakeUp))))
	return ret
}

func ASensorManagerConfigureDirectReport(manager *ASensorManager, sensor *ASensor, channelId Int, rate Int) Int {
	ret := (Int)(C.ASensorManager_configureDirectReport((*C.ASensorManager)(manager), (*C.ASensor)(sensor), (C.int)(channelId), (C.int)(rate)))
	return ret
}

func Fstat(__fd Int, __buf *Stat_t) Int {
	ret := (Int)(C.fstat((C.int)(__fd), (*C.struct_stat)(__buf)))
	return ret
}

func Utimensat(__dir_fd Int, __path *Char, __times *Timespec, __flags Int) Int {
	ret := (Int)(C.utimensat((C.int)(__dir_fd), (*C.char)(__path), (*C.struct_timespec)(__times), (C.int)(__flags)))
	return ret
}

func AHardwareBufferLock(buffer *AHardwareBuffer, usage Uint64_t, fence Int32_t, rect *ARect, outVirtualAddress *unsafe.Pointer) Int {
	ret := (Int)(C.AHardwareBuffer_lock((*C.AHardwareBuffer)(buffer), (C.uint64_t)(usage), (C.int32_t)(fence), (*C.ARect)(rect), outVirtualAddress))
	return ret
}

func Acosh(__x Double) Double {
	ret := (Double)(C.acosh((C.double)(__x)))
	return ret
}

func Mkfifo(__path *Char, __mode Mode_t) Int {
	ret := (Int)(C.mkfifo((*C.char)(__path), (C.mode_t)(__mode)))
	return ret
}

func ALooperPrepare(opts Int) *ALooper {
	ret := (*ALooper)(unsafe.Pointer(C.ALooper_prepare((C.int)(opts))))
	return ret
}

func Tan(__x Double) Double {
	ret := (Double)(C.tan((C.double)(__x)))
	return ret
}

func AHardwareBufferRelease(buffer *AHardwareBuffer)  {
	C.AHardwareBuffer_release((*C.AHardwareBuffer)(buffer))
}

func Modf(__x Double, __integral_part *Double) Double {
	ret := (Double)(C.modf((C.double)(__x), (*C.double)(__integral_part)))
	return ret
}

func Strtoimax(__s *Char, __end_ptr []*Char, __base Int) Intmax_t {
	ret := (Intmax_t)(C.strtoimax((*C.char)(__s), (**C.char)(unsafe.Pointer(&__end_ptr[0])), (C.int)(__base)))
	return ret
}

func Erfc(__x Double) Double {
	ret := (Double)(C.erfc((C.double)(__x)))
	return ret
}

func ALooperPollOnce(timeoutMillis Int, outFd *Int, outEvents *Int, outData *unsafe.Pointer) Int {
	ret := (Int)(C.ALooper_pollOnce((C.int)(timeoutMillis), (*C.int)(outFd), (*C.int)(outEvents), outData))
	return ret
}

func Sinhf(__x Float) Float {
	ret := (Float)(C.sinhf((C.float)(__x)))
	return ret
}

func Mknodat(__dir_fd Int, __path *Char, __mode Mode_t, __dev Dev_t) Int {
	ret := (Int)(C.mknodat((C.int)(__dir_fd), (*C.char)(__path), (C.mode_t)(__mode), (C.dev_t)(__dev)))
	return ret
}

func Trunc(__x Double) Double {
	ret := (Double)(C.trunc((C.double)(__x)))
	return ret
}

func Fminf(__x Float, __y Float) Float {
	ret := (Float)(C.fminf((C.float)(__x), (C.float)(__y)))
	return ret
}

func ASensorManagerCreateHardwareBufferDirectChannel(manager *ASensorManager, buffer *AHardwareBuffer, size Size_t) Int {
	ret := (Int)(C.ASensorManager_createHardwareBufferDirectChannel((*C.ASensorManager)(manager), (*C.AHardwareBuffer)(buffer), (C.size_t)(size)))
	return ret
}

func ASensorGetFifoMaxEventCount(sensor *ASensor) Int {
	ret := (Int)(C.ASensor_getFifoMaxEventCount((*C.ASensor)(sensor)))
	return ret
}

func ANativeWindowSetBuffersDataSpace(window *ANativeWindow, dataSpace Int32_t) Int32_t {
	ret := (Int32_t)(C.ANativeWindow_setBuffersDataSpace((*C.ANativeWindow)(window), (C.int32_t)(dataSpace)))
	return ret
}

func Fmaxf(__x Float, __y Float) Float {
	ret := (Float)(C.fmaxf((C.float)(__x), (C.float)(__y)))
	return ret
}

func Powf(__x Float, __y Float) Float {
	ret := (Float)(C.powf((C.float)(__x), (C.float)(__y)))
	return ret
}

func Lstat(__path *Char, __buf *Stat_t) Int {
	ret := (Int)(C.lstat((*C.char)(__path), (*C.struct_stat)(__buf)))
	return ret
}

func Mkfifoat(__dir_fd Int, __path *Char, __mode Mode_t) Int {
	ret := (Int)(C.mkfifoat((C.int)(__dir_fd), (*C.char)(__path), (C.mode_t)(__mode)))
	return ret
}

func Nearbyintf(__x Float) Float {
	ret := (Float)(C.nearbyintf((C.float)(__x)))
	return ret
}

func Floorf(__x Float) Float {
	ret := (Float)(C.floorf((C.float)(__x)))
	return ret
}

func Nextafter(__x Double, __y Double) Double {
	ret := (Double)(C.nextafter((C.double)(__x), (C.double)(__y)))
	return ret
}

func ASensorIsDirectChannelTypeSupported(sensor *ASensor, channelType Int) Bool {
	ret := (Bool)(C.ASensor_isDirectChannelTypeSupported((*C.ASensor)(sensor), (C.int)(channelType)))
	return ret
}

func AHardwareBufferRecvHandleFromUnixSocket(socketFd Int, outBuffer []*AHardwareBuffer) Int {
	ret := (Int)(C.AHardwareBuffer_recvHandleFromUnixSocket((C.int)(socketFd), (**C.AHardwareBuffer)(unsafe.Pointer(&outBuffer[0]))))
	return ret
}

func Acosf(__x Float) Float {
	ret := (Float)(C.acosf((C.float)(__x)))
	return ret
}

func ASensorEventQueueHasEvents(queue *ASensorEventQueue) Int {
	ret := (Int)(C.ASensorEventQueue_hasEvents((*C.ASensorEventQueue)(queue)))
	return ret
}

func Tgammaf(__x Float) Float {
	ret := (Float)(C.tgammaf((C.float)(__x)))
	return ret
}

func Round(__x Double) Double {
	ret := (Double)(C.round((C.double)(__x)))
	return ret
}

func Llroundf(__x Float) LongLong {
	ret := (LongLong)(C.llroundf((C.float)(__x)))
	return ret
}

func Isnan(__x Double) Int {
	ret := (Int)(C.isnan((C.double)(__x)))
	return ret
}

func ANativeWindowGetHeight(window *ANativeWindow) Int32_t {
	ret := (Int32_t)(C.ANativeWindow_getHeight((*C.ANativeWindow)(window)))
	return ret
}

func Ilogb(__x Double) Int {
	ret := (Int)(C.ilogb((C.double)(__x)))
	return ret
}

func ASensorManagerCreateSharedMemoryDirectChannel(manager *ASensorManager, fd Int, size Size_t) Int {
	ret := (Int)(C.ASensorManager_createSharedMemoryDirectChannel((*C.ASensorManager)(manager), (C.int)(fd), (C.size_t)(size)))
	return ret
}

func Rint(__x Double) Double {
	ret := (Double)(C.rint((C.double)(__x)))
	return ret
}

func Cbrt(__x Double) Double {
	ret := (Double)(C.cbrt((C.double)(__x)))
	return ret
}

func Remainderf(__x Float, __y Float) Float {
	ret := (Float)(C.remainderf((C.float)(__x), (C.float)(__y)))
	return ret
}

func Chmod(__path *Char, __mode Mode_t) Int {
	ret := (Int)(C.chmod((*C.char)(__path), (C.mode_t)(__mode)))
	return ret
}

func Futimens(__dir_fd Int, __times *Timespec) Int {
	ret := (Int)(C.futimens((C.int)(__dir_fd), (*C.struct_timespec)(__times)))
	return ret
}

func ALooperForThread() *ALooper {
	ret := (*ALooper)(unsafe.Pointer(C.ALooper_forThread()))
	return ret
}

func Ldexp(__x Double, __exponent Int) Double {
	ret := (Double)(C.ldexp((C.double)(__x), (C.int)(__exponent)))
	return ret
}

func Logf(__x Float) Float {
	ret := (Float)(C.logf((C.float)(__x)))
	return ret
}

func Y1(__x Double) Double {
	ret := (Double)(C.y1((C.double)(__x)))
	return ret
}

func ANativeWindowLock(window *ANativeWindow, outBuffer *ANativeWindow_Buffer, inOutDirtyBounds *ARect) Int32_t {
	ret := (Int32_t)(C.ANativeWindow_lock((*C.ANativeWindow)(window), (*C.ANativeWindow_Buffer)(outBuffer), (*C.ARect)(inOutDirtyBounds)))
	return ret
}

func Floor(__x Double) Double {
	ret := (Double)(C.floor((C.double)(__x)))
	return ret
}

func ASensorManagerGetInstanceForPackage(packageName *Char) *ASensorManager {
	ret := (*ASensorManager)(unsafe.Pointer(C.ASensorManager_getInstanceForPackage((*C.char)(packageName))))
	return ret
}

func Fstatat(__dir_fd Int, __path *Char, __buf *Stat_t, __flags Int) Int {
	ret := (Int)(C.fstatat((C.int)(__dir_fd), (*C.char)(__path), (*C.struct_stat)(__buf), (C.int)(__flags)))
	return ret
}

func Hypot(__x Double, __y Double) Double {
	ret := (Double)(C.hypot((C.double)(__x), (C.double)(__y)))
	return ret
}

func Sqrt(__x Double) Double {
	ret := (Double)(C.sqrt((C.double)(__x)))
	return ret
}

func Remquo(__x Double, __y Double, __quotient_bits *Int) Double {
	ret := (Double)(C.remquo((C.double)(__x), (C.double)(__y), (*C.int)(__quotient_bits)))
	return ret
}

func Tanh(__x Double) Double {
	ret := (Double)(C.tanh((C.double)(__x)))
	return ret
}

func Scalbn(__x Double, __exponent Int) Double {
	ret := (Double)(C.scalbn((C.double)(__x), (C.int)(__exponent)))
	return ret
}

func Llrint(__x Double) LongLong {
	ret := (LongLong)(C.llrint((C.double)(__x)))
	return ret
}

func ASensorManagerDestroyEventQueue(manager *ASensorManager, queue *ASensorEventQueue) Int {
	ret := (Int)(C.ASensorManager_destroyEventQueue((*C.ASensorManager)(manager), (*C.ASensorEventQueue)(queue)))
	return ret
}

func Stat64(__path *Char, __buf *Stat64_t) Int {
	ret := (Int)(C.stat64((*C.char)(__path), (*C.struct_stat64)(__buf)))
	return ret
}

func Asin(__x Double) Double {
	ret := (Double)(C.asin((C.double)(__x)))
	return ret
}

func Pow(__x Double, __y Double) Double {
	ret := (Double)(C.pow((C.double)(__x), (C.double)(__y)))
	return ret
}

func Strtoumax(__s *Char, __end_ptr []*Char, __base Int) Uintmax_t {
	ret := (Uintmax_t)(C.strtoumax((*C.char)(__s), (**C.char)(unsafe.Pointer(&__end_ptr[0])), (C.int)(__base)))
	return ret
}

func Asinh(__x Double) Double {
	ret := (Double)(C.asinh((C.double)(__x)))
	return ret
}

func Acoshf(__x Float) Float {
	ret := (Float)(C.acoshf((C.float)(__x)))
	return ret
}

func Scalbln(__x Double, __exponent Long) Double {
	ret := (Double)(C.scalbln((C.double)(__x), (C.long)(__exponent)))
	return ret
}

func AndroidLogBufWrite(bufID Int, prio Int, tag *Char, text *Char) Int {
	ret := (Int)(C.__android_log_buf_write((C.int)(bufID), (C.int)(prio), (*C.char)(tag), (*C.char)(text)))
	return ret
}

func Acos(__x Double) Double {
	ret := (Double)(C.acos((C.double)(__x)))
	return ret
}

func Log2(__x Double) Double {
	ret := (Double)(C.log2((C.double)(__x)))
	return ret
}

func Erff(__x Float) Float {
	ret := (Float)(C.erff((C.float)(__x)))
	return ret
}

func Fdim(__x Double, __y Double) Double {
	ret := (Double)(C.fdim((C.double)(__x), (C.double)(__y)))
	return ret
}

func J1(__x Double) Double {
	ret := (Double)(C.j1((C.double)(__x)))
	return ret
}

func Exp2(__x Double) Double {
	ret := (Double)(C.exp2((C.double)(__x)))
	return ret
}

func Log10(__x Double) Double {
	ret := (Double)(C.log10((C.double)(__x)))
	return ret
}

func ASensorManagerDestroyDirectChannel(manager *ASensorManager, channelId Int)  {
	C.ASensorManager_destroyDirectChannel((*C.ASensorManager)(manager), (C.int)(channelId))
}

func ASensorGetReportingMode(sensor *ASensor) Int {
	ret := (Int)(C.ASensor_getReportingMode((*C.ASensor)(sensor)))
	return ret
}

func Frexpf(__x Float, __exponent *Int) Float {
	ret := (Float)(C.frexpf((C.float)(__x), (*C.int)(__exponent)))
	return ret
}

func Ceilf(__x Float) Float {
	ret := (Float)(C.ceilf((C.float)(__x)))
	return ret
}

func ASensorEventQueueRegisterSensor(queue *ASensorEventQueue, sensor *ASensor, samplingPeriodUs Int32_t, maxBatchReportLatencyUs Int64_t) Int {
	ret := (Int)(C.ASensorEventQueue_registerSensor((*C.ASensorEventQueue)(queue), (*C.ASensor)(sensor), (C.int32_t)(samplingPeriodUs), (C.int64_t)(maxBatchReportLatencyUs)))
	return ret
}

func ALooperRelease(looper *ALooper)  {
	C.ALooper_release((*C.ALooper)(looper))
}

func Atanh(__x Double) Double {
	ret := (Double)(C.atanh((C.double)(__x)))
	return ret
}

func Copysign(__value Double, __sign Double) Double {
	ret := (Double)(C.copysign((C.double)(__value), (C.double)(__sign)))
	return ret
}

func Fstatat64(__dir_fd Int, __path *Char, __buf *Stat64_t, __flags Int) Int {
	ret := (Int)(C.fstatat64((C.int)(__dir_fd), (*C.char)(__path), (*C.struct_stat64)(__buf), (C.int)(__flags)))
	return ret
}

func Imaxabs(__i Intmax_t) Intmax_t {
	ret := (Intmax_t)(C.imaxabs((C.intmax_t)(__i)))
	return ret
}

func Log1p(__x Double) Double {
	ret := (Double)(C.log1p((C.double)(__x)))
	return ret
}

func Cosf(__x Float) Float {
	ret := (Float)(C.cosf((C.float)(__x)))
	return ret
}

func Mknod(__path *Char, __mode Mode_t, __dev Dev_t) Int {
	ret := (Int)(C.mknod((*C.char)(__path), (C.mode_t)(__mode), (C.dev_t)(__dev)))
	return ret
}

func Fmod(__x Double, __y Double) Double {
	ret := (Double)(C.fmod((C.double)(__x), (C.double)(__y)))
	return ret
}

func Fmin(__x Double, __y Double) Double {
	ret := (Double)(C.fmin((C.double)(__x), (C.double)(__y)))
	return ret
}

func Stat(__path *Char, __buf *Stat_t) Int {
	ret := (Int)(C.stat((*C.char)(__path), (*C.struct_stat)(__buf)))
	return ret
}

func AndroidGetDeviceApiLevel() Int {
	ret := (Int)(C.android_get_device_api_level())
	return ret
}

func Atanhf(__x Float) Float {
	ret := (Float)(C.atanhf((C.float)(__x)))
	return ret
}

func ASensorManagerGetSensorList(manager *ASensorManager, list *ASensorList) Int {
	ret := (Int)(C.ASensorManager_getSensorList((*C.ASensorManager)(manager), (*C.ASensorList)(list)))
	return ret
}

func AndroidLogWrite(prio Int, tag *Char, text *Char) Int {
	ret := (Int)(C.__android_log_write((C.int)(prio), (*C.char)(tag), (*C.char)(text)))
	return ret
}

func Copysignf(__value Float, __sign Float) Float {
	ret := (Float)(C.copysignf((C.float)(__value), (C.float)(__sign)))
	return ret
}

func Fma(__x Double, __y Double, __z Double) Double {
	ret := (Double)(C.fma((C.double)(__x), (C.double)(__y), (C.double)(__z)))
	return ret
}

func Hypotf(__x Float, __y Float) Float {
	ret := (Float)(C.hypotf((C.float)(__x), (C.float)(__y)))
	return ret
}

func Lround(__x Double) Long {
	ret := (Long)(C.lround((C.double)(__x)))
	return ret
}

func Log(__x Double) Double {
	ret := (Double)(C.log((C.double)(__x)))
	return ret
}

func Cbrtf(__x Float) Float {
	ret := (Float)(C.cbrtf((C.float)(__x)))
	return ret
}

func Truncf(__x Float) Float {
	ret := (Float)(C.truncf((C.float)(__x)))
	return ret
}

func Ldexpf(__x Float, __exponent Int) Float {
	ret := (Float)(C.ldexpf((C.float)(__x), (C.int)(__exponent)))
	return ret
}

func ASensorEventQueueGetEvents(queue *ASensorEventQueue, events *ASensorEvent, count Size_t) Ssize_t {
	ret := (Ssize_t)(C.ASensorEventQueue_getEvents((*C.ASensorEventQueue)(queue), (*C.ASensorEvent)(events), (C.size_t)(count)))
	return ret
}

func ALooperWake(looper *ALooper)  {
	C.ALooper_wake((*C.ALooper)(looper))
}

func Atan(__x Double) Double {
	ret := (Double)(C.atan((C.double)(__x)))
	return ret
}

func Lroundf(__x Float) Long {
	ret := (Long)(C.lroundf((C.float)(__x)))
	return ret
}

func Fchmodat(__dir_fd Int, __path *Char, __mode Mode_t, __flags Int) Int {
	ret := (Int)(C.fchmodat((C.int)(__dir_fd), (*C.char)(__path), (C.mode_t)(__mode), (C.int)(__flags)))
	return ret
}

func Mkdirat(__dir_fd Int, __path *Char, __mode Mode_t) Int {
	ret := (Int)(C.mkdirat((C.int)(__dir_fd), (*C.char)(__path), (C.mode_t)(__mode)))
	return ret
}

func Erfcf(__x Float) Float {
	ret := (Float)(C.erfcf((C.float)(__x)))
	return ret
}

func Tgamma(__x Double) Double {
	ret := (Double)(C.tgamma((C.double)(__x)))
	return ret
}