commit 7edd18c8dc99eaa94f9e56ddf8c8343e5b2c1a20
Author: Greg <gmp@wow.st>
Date:   Tue Sep 17 10:27:17 2019 -0400

    Initial commit

diff --git a/.gitignore b/.gitignore
new file mode 100644
index 0000000..9b7d4d3
--- /dev/null
+++ b/.gitignore
@@ -0,0 +1 @@
+*.ast
diff --git a/android27/main.go b/android27/main.go
new file mode 100644
index 0000000..f7d9a66
--- /dev/null
+++ b/android27/main.go
@@ -0,0 +1,1332 @@
+package android27
+
+
+/*
+#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>
+
+
+void
+___android_log_assert(char* cond, char* tag, char* fmt, void* format) {
+	void** arr = format;
+	__android_log_assert(cond, tag, fmt, format);
+}
+int
+___android_log_buf_print(int bufID, int prio, char* tag, char* fmt, void* format) {
+	void** arr = format;
+	return __android_log_buf_print(bufID, prio, tag, fmt, format);
+}
+int
+___android_log_print(int prio, char* tag, char* fmt, void* format) {
+	void** arr = format;
+	return __android_log_print(prio, tag, fmt, format);
+}
+
+*/
+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 Float C.float
+
+type Int C.int
+
+type Double C.double
+
+type Imaxdiv_t = C.imaxdiv_t
+
+type Intmax_t C.int64_t
+
+type ASensorEventQueue = C.struct_ASensorEventQueue
+
+type ASensor = C.struct_ASensor
+
+type Char C.char
+
+type Mode_t C.__mode_t
+
+type Dev_t C.uint64_t
+
+type Int32_t C.__int32_t
+
+type ANativeWindow = C.struct_ANativeWindow
+
+type ASensorManager = C.struct_ASensorManager
+
+type Long C.long
+
+type ASensorList *C.ASensorRef
+
+type AHardwareBuffer = C.struct_AHardwareBuffer
+
+type Size_t C.ulong
+
+type ALooper = C.struct_ALooper
+
+type Stat_t = C.struct_stat
+
+type Stat64_t = C.struct_stat64
+
+type Uintmax_t C.uint64_t
+
+type Wchar_t C.uint
+
+type Timespec = C.struct_timespec
+
+type Bool C.bool
+
+type LongLong C.longlong
+
+type Ssize_t C.__kernel_ssize_t
+
+type ASensorEvent = C.struct_ASensorEvent
+
+type ANativeWindow_Buffer = C.struct_ANativeWindow_Buffer
+
+type ARect = C.struct_ARect
+
+type Int64_t C.__int64_t
+
+type AHardwareBuffer_Desc = C.struct_AHardwareBuffer_Desc
+
+type Uint64_t C.__uint64_t
+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 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 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 Ceilf(__x Float) Float {
+	ret := (Float)(C.ceilf((C.float)(__x)))
+	return ret
+}
+
+func Rintf(__x Float) Float {
+	ret := (Float)(C.rintf((C.float)(__x)))
+	return ret
+}
+
+func Fmaxf(__x Float, __y Float) Float {
+	ret := (Float)(C.fmaxf((C.float)(__x), (C.float)(__y)))
+	return ret
+}
+
+func AndroidGetDeviceApiLevel() Int {
+	ret := (Int)(C.android_get_device_api_level())
+	return ret
+}
+
+func Exp2(__x Double) Double {
+	ret := (Double)(C.exp2((C.double)(__x)))
+	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 J1(__x Double) Double {
+	ret := (Double)(C.j1((C.double)(__x)))
+	return ret
+}
+
+func Imaxdiv(__numerator Intmax_t, __denominator Intmax_t) Imaxdiv_t {
+	ret := (Imaxdiv_t)(C.imaxdiv((C.intmax_t)(__numerator), (C.intmax_t)(__denominator)))
+	return ret
+}
+
+func Expm1f(__x Float) Float {
+	ret := (Float)(C.expm1f((C.float)(__x)))
+	return ret
+}
+
+func Tgamma(__x Double) Double {
+	ret := (Double)(C.tgamma((C.double)(__x)))
+	return ret
+}
+
+func Fdimf(__x Float, __y Float) Float {
+	ret := (Float)(C.fdimf((C.float)(__x), (C.float)(__y)))
+	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 Roundf(__x Float) Float {
+	ret := (Float)(C.roundf((C.float)(__x)))
+	return ret
+}
+
+func ASensorGetType(sensor *ASensor) Int {
+	ret := (Int)(C.ASensor_getType((*C.ASensor)(sensor)))
+	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 Atanhf(__x Float) Float {
+	ret := (Float)(C.atanhf((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 Exp2f(__x Float) Float {
+	ret := (Float)(C.exp2f((C.float)(__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 Nextafterf(__x Float, __y Float) Float {
+	ret := (Float)(C.nextafterf((C.float)(__x), (C.float)(__y)))
+	return ret
+}
+
+func Remainder(__x Double, __y Double) Double {
+	ret := (Double)(C.remainder((C.double)(__x), (C.double)(__y)))
+	return ret
+}
+
+func Yn(__n Int, __x Double) Double {
+	ret := (Double)(C.yn((C.int)(__n), (C.double)(__x)))
+	return ret
+}
+
+func Imaxabs(__i Intmax_t) Intmax_t {
+	ret := (Intmax_t)(C.imaxabs((C.intmax_t)(__i)))
+	return ret
+}
+
+func ANativeWindowGetHeight(window *ANativeWindow) Int32_t {
+	ret := (Int32_t)(C.ANativeWindow_getHeight((*C.ANativeWindow)(window)))
+	return ret
+}
+
+func Fchmod(__fd Int, __mode Mode_t) Int {
+	ret := (Int)(C.fchmod((C.int)(__fd), (C.mode_t)(__mode)))
+	return ret
+}
+
+func Powf(__x Float, __y Float) Float {
+	ret := (Float)(C.powf((C.float)(__x), (C.float)(__y)))
+	return ret
+}
+
+func Y1(__x Double) Double {
+	ret := (Double)(C.y1((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 ASensorGetHighestDirectReportRateLevel(sensor *ASensor) Int {
+	ret := (Int)(C.ASensor_getHighestDirectReportRateLevel((*C.ASensor)(sensor)))
+	return ret
+}
+
+func Log10f(__x Float) Float {
+	ret := (Float)(C.log10f((C.float)(__x)))
+	return ret
+}
+
+func Atoi(__s *Char) Int {
+	ret := (Int)(C.atoi((*C.char)(__s)))
+	return ret
+}
+
+func Scalbnf(__x Float, __exponent Int) Float {
+	ret := (Float)(C.scalbnf((C.float)(__x), (C.int)(__exponent)))
+	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 ASensorManagerDestroyDirectChannel(manager *ASensorManager, channelId Int)  {
+	C.ASensorManager_destroyDirectChannel((*C.ASensorManager)(manager), (C.int)(channelId))
+}
+
+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 Sinf(__x Float) Float {
+	ret := (Float)(C.sinf((C.float)(__x)))
+	return ret
+}
+
+func Logb(__x Double) Double {
+	ret := (Double)(C.logb((C.double)(__x)))
+	return ret
+}
+
+func Tgammaf(__x Float) Float {
+	ret := (Float)(C.tgammaf((C.float)(__x)))
+	return ret
+}
+
+func Lroundf(__x Float) Long {
+	ret := (Long)(C.lroundf((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 ASensorGetFifoMaxEventCount(sensor *ASensor) Int {
+	ret := (Int)(C.ASensor_getFifoMaxEventCount((*C.ASensor)(sensor)))
+	return ret
+}
+
+func Sinh(__x Double) Double {
+	ret := (Double)(C.sinh((C.double)(__x)))
+	return ret
+}
+
+func Tan(__x Double) Double {
+	ret := (Double)(C.tan((C.double)(__x)))
+	return ret
+}
+
+func Modf(__x Double, __integral_part *Double) Double {
+	ret := (Double)(C.modf((C.double)(__x), (*C.double)(__integral_part)))
+	return ret
+}
+
+func Remainderf(__x Float, __y Float) Float {
+	ret := (Float)(C.remainderf((C.float)(__x), (C.float)(__y)))
+	return ret
+}
+
+func ASensorManagerGetSensorList(manager *ASensorManager, list *ASensorList) Int {
+	ret := (Int)(C.ASensorManager_getSensorList((*C.ASensorManager)(manager), (*C.ASensorList)(list)))
+	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 ALooperAcquire(looper *ALooper)  {
+	C.ALooper_acquire((*C.ALooper)(looper))
+}
+
+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 ALooperRemoveFd(looper *ALooper, fd Int) Int {
+	ret := (Int)(C.ALooper_removeFd((*C.ALooper)(looper), (C.int)(fd)))
+	return ret
+}
+
+func Fstat(__fd Int, __buf *Stat_t) Int {
+	ret := (Int)(C.fstat((C.int)(__fd), (*C.struct_stat)(__buf)))
+	return ret
+}
+
+func Pow(__x Double, __y Double) Double {
+	ret := (Double)(C.pow((C.double)(__x), (C.double)(__y)))
+	return ret
+}
+
+func ASensorGetStringType(sensor *ASensor) *Char {
+	ret := (*Char)(unsafe.Pointer(C.ASensor_getStringType((*C.ASensor)(sensor))))
+	return ret
+}
+
+func Scalbn(__x Double, __exponent Int) Double {
+	ret := (Double)(C.scalbn((C.double)(__x), (C.int)(__exponent)))
+	return ret
+}
+
+func Hypot(__x Double, __y Double) Double {
+	ret := (Double)(C.hypot((C.double)(__x), (C.double)(__y)))
+	return ret
+}
+
+func Y0(__x Double) Double {
+	ret := (Double)(C.y0((C.double)(__x)))
+	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 Nearbyint(__x Double) Double {
+	ret := (Double)(C.nearbyint((C.double)(__x)))
+	return ret
+}
+
+func Acosh(__x Double) Double {
+	ret := (Double)(C.acosh((C.double)(__x)))
+	return ret
+}
+
+func Acoshf(__x Float) Float {
+	ret := (Float)(C.acoshf((C.float)(__x)))
+	return ret
+}
+
+func Cosh(__x Double) Double {
+	ret := (Double)(C.cosh((C.double)(__x)))
+	return ret
+}
+
+func Log10(__x Double) Double {
+	ret := (Double)(C.log10((C.double)(__x)))
+	return ret
+}
+
+func Fdim(__x Double, __y Double) Double {
+	ret := (Double)(C.fdim((C.double)(__x), (C.double)(__y)))
+	return ret
+}
+
+func Stat64(__path *Char, __buf *Stat64_t) Int {
+	ret := (Int)(C.stat64((*C.char)(__path), (*C.struct_stat64)(__buf)))
+	return ret
+}
+
+func Wcstoumax(__s *Wchar_t, __end_ptr []*Wchar_t, __base Int) Uintmax_t {
+	ret := (Uintmax_t)(C.wcstoumax((*C.wchar_t)(__s), (**C.wchar_t)(unsafe.Pointer(&__end_ptr[0])), (C.int)(__base)))
+	return ret
+}
+
+func AHardwareBufferRelease(buffer *AHardwareBuffer)  {
+	C.AHardwareBuffer_release((*C.AHardwareBuffer)(buffer))
+}
+
+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 Lrintf(__x Float) Long {
+	ret := (Long)(C.lrintf((C.float)(__x)))
+	return ret
+}
+
+func Log2f(__x Float) Float {
+	ret := (Float)(C.log2f((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 Cbrtf(__x Float) Float {
+	ret := (Float)(C.cbrtf((C.float)(__x)))
+	return ret
+}
+
+func Lrint(__x Double) Long {
+	ret := (Long)(C.lrint((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 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 Frexp(__x Double, __exponent *Int) Double {
+	ret := (Double)(C.frexp((C.double)(__x), (*C.int)(__exponent)))
+	return ret
+}
+
+func Wcstoimax(__s *Wchar_t, __end_ptr []*Wchar_t, __base Int) Intmax_t {
+	ret := (Intmax_t)(C.wcstoimax((*C.wchar_t)(__s), (**C.wchar_t)(unsafe.Pointer(&__end_ptr[0])), (C.int)(__base)))
+	return ret
+}
+
+func ANativeWindowUnlockAndPost(window *ANativeWindow) Int32_t {
+	ret := (Int32_t)(C.ANativeWindow_unlockAndPost((*C.ANativeWindow)(window)))
+	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 ANativeWindowRelease(window *ANativeWindow)  {
+	C.ANativeWindow_release((*C.ANativeWindow)(window))
+}
+
+func Stat(__path *Char, __buf *Stat_t) Int {
+	ret := (Int)(C.stat((*C.char)(__path), (*C.struct_stat)(__buf)))
+	return ret
+}
+
+func Mkfifo(__path *Char, __mode Mode_t) Int {
+	ret := (Int)(C.mkfifo((*C.char)(__path), (C.mode_t)(__mode)))
+	return ret
+}
+
+func Hypotf(__x Float, __y Float) Float {
+	ret := (Float)(C.hypotf((C.float)(__x), (C.float)(__y)))
+	return ret
+}
+
+func Acosf(__x Float) Float {
+	ret := (Float)(C.acosf((C.float)(__x)))
+	return ret
+}
+
+func Frexpf(__x Float, __exponent *Int) Float {
+	ret := (Float)(C.frexpf((C.float)(__x), (*C.int)(__exponent)))
+	return ret
+}
+
+func Lstat(__path *Char, __buf *Stat_t) Int {
+	ret := (Int)(C.lstat((*C.char)(__path), (*C.struct_stat)(__buf)))
+	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 ANativeWindowGetFormat(window *ANativeWindow) Int32_t {
+	ret := (Int32_t)(C.ANativeWindow_getFormat((*C.ANativeWindow)(window)))
+	return ret
+}
+
+func Modff(__x Float, __integral_part *Float) Float {
+	ret := (Float)(C.modff((C.float)(__x), (*C.float)(__integral_part)))
+	return ret
+}
+
+func Floor(__x Double) Double {
+	ret := (Double)(C.floor((C.double)(__x)))
+	return ret
+}
+
+func AndroidLogAssert(cond *Char, tag *Char, fmt *Char, formats ...unsafe.Pointer)  {
+	var format [16]unsafe.Pointer
+	for i,o := range formats {
+		format[i] = o
+	}
+	C.___android_log_assert((*C.char)(cond), (*C.char)(tag), (*C.char)(fmt), unsafe.Pointer(&format))
+}
+
+func Logf(__x Float) Float {
+	ret := (Float)(C.logf((C.float)(__x)))
+	return ret
+}
+
+func Expf(__x Float) Float {
+	ret := (Float)(C.expf((C.float)(__x)))
+	return ret
+}
+
+func Lgamma(__x Double) Double {
+	ret := (Double)(C.lgamma((C.double)(__x)))
+	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 AHardwareBufferUnlock(buffer *AHardwareBuffer, fence *Int32_t) Int {
+	ret := (Int)(C.AHardwareBuffer_unlock((*C.AHardwareBuffer)(buffer), (*C.int32_t)(fence)))
+	return ret
+}
+
+func Sqrtf(__x Float) Float {
+	ret := (Float)(C.sqrtf((C.float)(__x)))
+	return ret
+}
+
+func ASensorEventQueueHasEvents(queue *ASensorEventQueue) Int {
+	ret := (Int)(C.ASensorEventQueue_hasEvents((*C.ASensorEventQueue)(queue)))
+	return ret
+}
+
+func Atan2(__y Double, __x Double) Double {
+	ret := (Double)(C.atan2((C.double)(__y), (C.double)(__x)))
+	return ret
+}
+
+func ASensorGetMinDelay(sensor *ASensor) Int {
+	ret := (Int)(C.ASensor_getMinDelay((*C.ASensor)(sensor)))
+	return ret
+}
+
+func Scalbln(__x Double, __exponent Long) Double {
+	ret := (Double)(C.scalbln((C.double)(__x), (C.long)(__exponent)))
+	return ret
+}
+
+func Floorf(__x Float) Float {
+	ret := (Float)(C.floorf((C.float)(__x)))
+	return ret
+}
+
+func Fabs(__x Double) Double {
+	ret := (Double)(C.fabs((C.double)(__x)))
+	return ret
+}
+
+func Rint(__x Double) Double {
+	ret := (Double)(C.rint((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 SystemPropertyGet(__name *Char, __value *Char) Int {
+	ret := (Int)(C.__system_property_get((*C.char)(__name), (*C.char)(__value)))
+	return ret
+}
+
+func Asinf(__x Float) Float {
+	ret := (Float)(C.asinf((C.float)(__x)))
+	return ret
+}
+
+func Llroundf(__x Float) LongLong {
+	ret := (LongLong)(C.llroundf((C.float)(__x)))
+	return ret
+}
+
+func Llrint(__x Double) LongLong {
+	ret := (LongLong)(C.llrint((C.double)(__x)))
+	return ret
+}
+
+func Llrintf(__x Float) LongLong {
+	ret := (LongLong)(C.llrintf((C.float)(__x)))
+	return ret
+}
+
+func Fmin(__x Double, __y Double) Double {
+	ret := (Double)(C.fmin((C.double)(__x), (C.double)(__y)))
+	return ret
+}
+
+func Lstat64(__path *Char, __buf *Stat64_t) Int {
+	ret := (Int)(C.lstat64((*C.char)(__path), (*C.struct_stat64)(__buf)))
+	return ret
+}
+
+func ALooperRelease(looper *ALooper)  {
+	C.ALooper_release((*C.ALooper)(looper))
+}
+
+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 Nearbyintf(__x Float) Float {
+	ret := (Float)(C.nearbyintf((C.float)(__x)))
+	return ret
+}
+
+func Nan(__kind *Char) Double {
+	ret := (Double)(C.nan((*C.char)(__kind)))
+	return ret
+}
+
+func Erfcf(__x Float) Float {
+	ret := (Float)(C.erfcf((C.float)(__x)))
+	return ret
+}
+
+func Truncf(__x Float) Float {
+	ret := (Float)(C.truncf((C.float)(__x)))
+	return ret
+}
+
+func ASensorIsDirectChannelTypeSupported(sensor *ASensor, channelType Int) Bool {
+	ret := (Bool)(C.ASensor_isDirectChannelTypeSupported((*C.ASensor)(sensor), (C.int)(channelType)))
+	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 Tanh(__x Double) Double {
+	ret := (Double)(C.tanh((C.double)(__x)))
+	return ret
+}
+
+func Logbf(__x Float) Float {
+	ret := (Float)(C.logbf((C.float)(__x)))
+	return ret
+}
+
+func Log(__x Double) Double {
+	ret := (Double)(C.log((C.double)(__x)))
+	return ret
+}
+
+func Erff(__x Float) Float {
+	ret := (Float)(C.erff((C.float)(__x)))
+	return ret
+}
+
+func Cos(__x Double) Double {
+	ret := (Double)(C.cos((C.double)(__x)))
+	return ret
+}
+
+func Tanhf(__x Float) Float {
+	ret := (Float)(C.tanhf((C.float)(__x)))
+	return ret
+}
+
+func Sqrt(__x Double) Double {
+	ret := (Double)(C.sqrt((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 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 ANativeWindowSetBuffersTransform(window *ANativeWindow, transform Int32_t) Int32_t {
+	ret := (Int32_t)(C.ANativeWindow_setBuffersTransform((*C.ANativeWindow)(window), (C.int32_t)(transform)))
+	return ret
+}
+
+func AndroidLogBufPrint(bufID Int, prio Int, tag *Char, fmt *Char, formats ...unsafe.Pointer) Int {
+	var format [16]unsafe.Pointer
+	for i,o := range formats {
+		format[i] = o
+	}
+	ret := (Int)(C.___android_log_buf_print((C.int)(bufID), (C.int)(prio), (*C.char)(tag), (*C.char)(fmt), unsafe.Pointer(&format)))
+	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 Chmod(__path *Char, __mode Mode_t) Int {
+	ret := (Int)(C.chmod((*C.char)(__path), (C.mode_t)(__mode)))
+	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 Asin(__x Double) Double {
+	ret := (Double)(C.asin((C.double)(__x)))
+	return ret
+}
+
+func Asinh(__x Double) Double {
+	ret := (Double)(C.asinh((C.double)(__x)))
+	return ret
+}
+
+func Round(__x Double) Double {
+	ret := (Double)(C.round((C.double)(__x)))
+	return ret
+}
+
+func Isnan(__x Double) Int {
+	ret := (Int)(C.isnan((C.double)(__x)))
+	return ret
+}
+
+func ALooperPrepare(opts Int) *ALooper {
+	ret := (*ALooper)(unsafe.Pointer(C.ALooper_prepare((C.int)(opts))))
+	return ret
+}
+
+func Cosf(__x Float) Float {
+	ret := (Float)(C.cosf((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 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 ANativeWindowAcquire(window *ANativeWindow)  {
+	C.ANativeWindow_acquire((*C.ANativeWindow)(window))
+}
+
+func Erfc(__x Double) Double {
+	ret := (Double)(C.erfc((C.double)(__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 Isinf(__x Double) Int {
+	ret := (Int)(C.isinf((C.double)(__x)))
+	return ret
+}
+
+func Atanh(__x Double) Double {
+	ret := (Double)(C.atanh((C.double)(__x)))
+	return ret
+}
+
+func Llround(__x Double) LongLong {
+	ret := (LongLong)(C.llround((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 Ilogb(__x Double) Int {
+	ret := (Int)(C.ilogb((C.double)(__x)))
+	return ret
+}
+
+func Erf(__x Double) Double {
+	ret := (Double)(C.erf((C.double)(__x)))
+	return ret
+}
+
+func Lgammaf(__x Float) Float {
+	ret := (Float)(C.lgammaf((C.float)(__x)))
+	return ret
+}
+
+func ASensorIsWakeUpSensor(sensor *ASensor) Bool {
+	ret := (Bool)(C.ASensor_isWakeUpSensor((*C.ASensor)(sensor)))
+	return ret
+}
+
+func Expm1(__x Double) Double {
+	ret := (Double)(C.expm1((C.double)(__x)))
+	return ret
+}
+
+func J0(__x Double) Double {
+	ret := (Double)(C.j0((C.double)(__x)))
+	return ret
+}
+
+func ASensorGetReportingMode(sensor *ASensor) Int {
+	ret := (Int)(C.ASensor_getReportingMode((*C.ASensor)(sensor)))
+	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 Umask(__mask Mode_t) Mode_t {
+	ret := (Mode_t)(C.umask((C.mode_t)(__mask)))
+	return ret
+}
+
+func Ilogbf(__x Float) Int {
+	ret := (Int)(C.ilogbf((C.float)(__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 Nextafter(__x Double, __y Double) Double {
+	ret := (Double)(C.nextafter((C.double)(__x), (C.double)(__y)))
+	return ret
+}
+
+func ASensorManagerGetInstanceForPackage(packageName *Char) *ASensorManager {
+	ret := (*ASensorManager)(unsafe.Pointer(C.ASensorManager_getInstanceForPackage((*C.char)(packageName))))
+	return ret
+}
+
+func AHardwareBufferAcquire(buffer *AHardwareBuffer)  {
+	C.AHardwareBuffer_acquire((*C.AHardwareBuffer)(buffer))
+}
+
+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 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 Fstat64(__fd Int, __buf *Stat64_t) Int {
+	ret := (Int)(C.fstat64((C.int)(__fd), (*C.struct_stat64)(__buf)))
+	return ret
+}
+
+func Acos(__x Double) Double {
+	ret := (Double)(C.acos((C.double)(__x)))
+	return ret
+}
+
+func Exp(__x Double) Double {
+	ret := (Double)(C.exp((C.double)(__x)))
+	return ret
+}
+
+func Fmax(__x Double, __y Double) Double {
+	ret := (Double)(C.fmax((C.double)(__x), (C.double)(__y)))
+	return ret
+}
+
+func Sinhf(__x Float) Float {
+	ret := (Float)(C.sinhf((C.float)(__x)))
+	return ret
+}
+
+func Log1pf(__x Float) Float {
+	ret := (Float)(C.log1pf((C.float)(__x)))
+	return ret
+}
+
+func Ceil(__x Double) Double {
+	ret := (Double)(C.ceil((C.double)(__x)))
+	return ret
+}
+
+func Fmodf(__x Float, __y Float) Float {
+	ret := (Float)(C.fmodf((C.float)(__x), (C.float)(__y)))
+	return ret
+}
+
+func AndroidLogPrint(prio Int, tag *Char, fmt *Char, formats ...unsafe.Pointer) Int {
+	var format [16]unsafe.Pointer
+	for i,o := range formats {
+		format[i] = o
+	}
+	ret := (Int)(C.___android_log_print((C.int)(prio), (*C.char)(tag), (*C.char)(fmt), unsafe.Pointer(&format)))
+	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 Lround(__x Double) Long {
+	ret := (Long)(C.lround((C.double)(__x)))
+	return ret
+}
+
+func Fmod(__x Double, __y Double) Double {
+	ret := (Double)(C.fmod((C.double)(__x), (C.double)(__y)))
+	return ret
+}
+
+func ASensorEventQueueDisableSensor(queue *ASensorEventQueue, sensor *ASensor) Int {
+	ret := (Int)(C.ASensorEventQueue_disableSensor((*C.ASensorEventQueue)(queue), (*C.ASensor)(sensor)))
+	return ret
+}
+
+func ASensorGetVendor(sensor *ASensor) *Char {
+	ret := (*Char)(unsafe.Pointer(C.ASensor_getVendor((*C.ASensor)(sensor))))
+	return ret
+}
+
+func AndroidGetApplicationTargetSdkVersion() Int {
+	ret := (Int)(C.android_get_application_target_sdk_version())
+	return ret
+}
+
+func AHardwareBufferDescribe(buffer *AHardwareBuffer, outDesc *AHardwareBuffer_Desc)  {
+	C.AHardwareBuffer_describe((*C.AHardwareBuffer)(buffer), (*C.AHardwareBuffer_Desc)(outDesc))
+}
+
+func Coshf(__x Float) Float {
+	ret := (Float)(C.coshf((C.float)(__x)))
+	return ret
+}
+
+func Log2(__x Double) Double {
+	ret := (Double)(C.log2((C.double)(__x)))
+	return ret
+}
+
+func Atan(__x Double) Double {
+	ret := (Double)(C.atan((C.double)(__x)))
+	return ret
+}
+
+func ASensorGetFifoReservedEventCount(sensor *ASensor) Int {
+	ret := (Int)(C.ASensor_getFifoReservedEventCount((*C.ASensor)(sensor)))
+	return ret
+}
+
+func Copysignf(__value Float, __sign Float) Float {
+	ret := (Float)(C.copysignf((C.float)(__value), (C.float)(__sign)))
+	return ret
+}
+
+func Jn(__n Int, __x Double) Double {
+	ret := (Double)(C.jn((C.int)(__n), (C.double)(__x)))
+	return ret
+}
+
+func Atanf(__x Float) Float {
+	ret := (Float)(C.atanf((C.float)(__x)))
+	return ret
+}
+
+func Atan2f(__y Float, __x Float) Float {
+	ret := (Float)(C.atan2f((C.float)(__y), (C.float)(__x)))
+	return ret
+}
+
+func Scalblnf(__x Float, __exponent Long) Float {
+	ret := (Float)(C.scalblnf((C.float)(__x), (C.long)(__exponent)))
+	return ret
+}
+
+func Nanf(__kind *Char) Float {
+	ret := (Float)(C.nanf((*C.char)(__kind)))
+	return ret
+}
+
+func Asinhf(__x Float) Float {
+	ret := (Float)(C.asinhf((C.float)(__x)))
+	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 ALooperWake(looper *ALooper)  {
+	C.ALooper_wake((*C.ALooper)(looper))
+}
+
+func Tanf(__x Float) Float {
+	ret := (Float)(C.tanf((C.float)(__x)))
+	return ret
+}
+
+func Log1p(__x Double) Double {
+	ret := (Double)(C.log1p((C.double)(__x)))
+	return ret
+}
+
+func Fabsf(__x Float) Float {
+	ret := (Float)(C.fabsf((C.float)(__x)))
+	return ret
+}
+
+func ASensorGetName(sensor *ASensor) *Char {
+	ret := (*Char)(unsafe.Pointer(C.ASensor_getName((*C.ASensor)(sensor))))
+	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 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 ANativeWindowGetWidth(window *ANativeWindow) Int32_t {
+	ret := (Int32_t)(C.ANativeWindow_getWidth((*C.ANativeWindow)(window)))
+	return ret
+}
+
+func Cbrt(__x Double) Double {
+	ret := (Double)(C.cbrt((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 AHardwareBufferSendHandleToUnixSocket(buffer *AHardwareBuffer, socketFd Int) Int {
+	ret := (Int)(C.AHardwareBuffer_sendHandleToUnixSocket((*C.AHardwareBuffer)(buffer), (C.int)(socketFd)))
+	return ret
+}
diff --git a/nswrap.yaml b/nswrap.yaml
new file mode 100644
index 0000000..2032aed
--- /dev/null
+++ b/nswrap.yaml
@@ -0,0 +1,30 @@
+package: android27
+libraries: [android, log, nativewindow, m]
+inputfiles:
+  - $ANDROID_HOME/ndk-bundle/sysroot/usr/include/android/native_window.h
+  - $ANDROID_HOME//ndk-bundle/sysroot/usr/include/android/log.h
+  - $ANDROID_HOME//ndk-bundle/sysroot/usr/include/android/sensor.h
+  - $ANDROID_HOME//ndk-bundle/sysroot/usr/include/jni.h
+  - $ANDROID_HOME//ndk-bundle/sysroot/usr/include/sys/stat.h
+sysimports:
+  - android/native_window.h
+  - android/log.h
+  - android/sensor.h
+  - jni.h
+  - stdlib.h
+  - sys/stat.h
+functions:
+  - .*
+functionignore:
+  - JNI_CreateJavaVM
+  - JNI_GetCreatedJavaVMs
+  - JNI_GetDefaultJavaVMInitArgs
+  - JNI_OnLoad
+  - JNI_OnUnload
+  - AHardwareBuffer_lockPlanes
+enums:
+  - .*
+typesubs:
+  Stat: Stat_t
+  Stat64: Stat64_t
+clang: $ANDROID_HOME/ndk-bundle/toolchains/llvm/prebuilt/darwin-x86_64/bin/aarch64-linux-android27-clang