up

plugins/flutter/src/pocketpy.h

@@ -6732,7 +6732,7 @@ extern "C" {
 }
 
 extern "C" {
-typedef i64 (*__f_int__int_int_int)(VM*, i64, i64, i64);
+typedef i64 (*__f_int__int_int_int)(i64, i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_int__int_int_int(VM* vm, const char* mod, const char* name, __f_int__int_int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6740,12 +6740,12 @@ void pkpy_vm_bind__f_int__int_int_int(VM* vm, const char* mod, const char* name,
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
         i64 _2 = vm->PyInt_AS_C(args[2]);
-        i64 ret = f(vm, _0, _1, _2);
+        i64 ret = f(_0, _1, _2);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__float_float_float)(VM*, f64, f64, f64);
+typedef i64 (*__f_int__float_float_float)(f64, f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_int__float_float_float(VM* vm, const char* mod, const char* name, __f_int__float_float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6753,12 +6753,12 @@ void pkpy_vm_bind__f_int__float_float_float(VM* vm, const char* mod, const char*
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
         f64 _2 = vm->PyFloat_AS_C(args[2]);
-        i64 ret = f(vm, _0, _1, _2);
+        i64 ret = f(_0, _1, _2);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__str_str_str)(VM*, const char*, const char*, const char*);
+typedef i64 (*__f_int__str_str_str)(const char*, const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_int__str_str_str(VM* vm, const char* mod, const char* name, __f_int__str_str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6766,12 +6766,12 @@ void pkpy_vm_bind__f_int__str_str_str(VM* vm, const char* mod, const char* name,
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
         const char* _2 = vm->PyStr_AS_C(args[2]);
-        i64 ret = f(vm, _0, _1, _2);
+        i64 ret = f(_0, _1, _2);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__bool_bool_bool)(VM*, bool, bool, bool);
+typedef i64 (*__f_int__bool_bool_bool)(bool, bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_int__bool_bool_bool(VM* vm, const char* mod, const char* name, __f_int__bool_bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6779,12 +6779,12 @@ void pkpy_vm_bind__f_int__bool_bool_bool(VM* vm, const char* mod, const char* na
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
         bool _2 = vm->PyBool_AS_C(args[2]);
-        i64 ret = f(vm, _0, _1, _2);
+        i64 ret = f(_0, _1, _2);
         return vm->PyInt(ret);
     });
 }
 
-typedef f64 (*__f_float__int_int_int)(VM*, i64, i64, i64);
+typedef f64 (*__f_float__int_int_int)(i64, i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_float__int_int_int(VM* vm, const char* mod, const char* name, __f_float__int_int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6792,12 +6792,12 @@ void pkpy_vm_bind__f_float__int_int_int(VM* vm, const char* mod, const char* nam
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
         i64 _2 = vm->PyInt_AS_C(args[2]);
-        f64 ret = f(vm, _0, _1, _2);
+        f64 ret = f(_0, _1, _2);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__float_float_float)(VM*, f64, f64, f64);
+typedef f64 (*__f_float__float_float_float)(f64, f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_float__float_float_float(VM* vm, const char* mod, const char* name, __f_float__float_float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6805,12 +6805,12 @@ void pkpy_vm_bind__f_float__float_float_float(VM* vm, const char* mod, const cha
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
         f64 _2 = vm->PyFloat_AS_C(args[2]);
-        f64 ret = f(vm, _0, _1, _2);
+        f64 ret = f(_0, _1, _2);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__str_str_str)(VM*, const char*, const char*, const char*);
+typedef f64 (*__f_float__str_str_str)(const char*, const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_float__str_str_str(VM* vm, const char* mod, const char* name, __f_float__str_str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6818,12 +6818,12 @@ void pkpy_vm_bind__f_float__str_str_str(VM* vm, const char* mod, const char* nam
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
         const char* _2 = vm->PyStr_AS_C(args[2]);
-        f64 ret = f(vm, _0, _1, _2);
+        f64 ret = f(_0, _1, _2);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__bool_bool_bool)(VM*, bool, bool, bool);
+typedef f64 (*__f_float__bool_bool_bool)(bool, bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_float__bool_bool_bool(VM* vm, const char* mod, const char* name, __f_float__bool_bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6831,12 +6831,12 @@ void pkpy_vm_bind__f_float__bool_bool_bool(VM* vm, const char* mod, const char*
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
         bool _2 = vm->PyBool_AS_C(args[2]);
-        f64 ret = f(vm, _0, _1, _2);
+        f64 ret = f(_0, _1, _2);
         return vm->PyFloat(ret);
     });
 }
 
-typedef const char* (*__f_str__int_int_int)(VM*, i64, i64, i64);
+typedef const char* (*__f_str__int_int_int)(i64, i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_str__int_int_int(VM* vm, const char* mod, const char* name, __f_str__int_int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6844,12 +6844,12 @@ void pkpy_vm_bind__f_str__int_int_int(VM* vm, const char* mod, const char* name,
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
         i64 _2 = vm->PyInt_AS_C(args[2]);
-        const char* ret = f(vm, _0, _1, _2);
+        const char* ret = f(_0, _1, _2);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__float_float_float)(VM*, f64, f64, f64);
+typedef const char* (*__f_str__float_float_float)(f64, f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_str__float_float_float(VM* vm, const char* mod, const char* name, __f_str__float_float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6857,12 +6857,12 @@ void pkpy_vm_bind__f_str__float_float_float(VM* vm, const char* mod, const char*
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
         f64 _2 = vm->PyFloat_AS_C(args[2]);
-        const char* ret = f(vm, _0, _1, _2);
+        const char* ret = f(_0, _1, _2);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__str_str_str)(VM*, const char*, const char*, const char*);
+typedef const char* (*__f_str__str_str_str)(const char*, const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_str__str_str_str(VM* vm, const char* mod, const char* name, __f_str__str_str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6870,12 +6870,12 @@ void pkpy_vm_bind__f_str__str_str_str(VM* vm, const char* mod, const char* name,
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
         const char* _2 = vm->PyStr_AS_C(args[2]);
-        const char* ret = f(vm, _0, _1, _2);
+        const char* ret = f(_0, _1, _2);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__bool_bool_bool)(VM*, bool, bool, bool);
+typedef const char* (*__f_str__bool_bool_bool)(bool, bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_str__bool_bool_bool(VM* vm, const char* mod, const char* name, __f_str__bool_bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6883,12 +6883,12 @@ void pkpy_vm_bind__f_str__bool_bool_bool(VM* vm, const char* mod, const char* na
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
         bool _2 = vm->PyBool_AS_C(args[2]);
-        const char* ret = f(vm, _0, _1, _2);
+        const char* ret = f(_0, _1, _2);
         return vm->PyStr(ret);
     });
 }
 
-typedef bool (*__f_bool__int_int_int)(VM*, i64, i64, i64);
+typedef bool (*__f_bool__int_int_int)(i64, i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_bool__int_int_int(VM* vm, const char* mod, const char* name, __f_bool__int_int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6896,12 +6896,12 @@ void pkpy_vm_bind__f_bool__int_int_int(VM* vm, const char* mod, const char* name
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
         i64 _2 = vm->PyInt_AS_C(args[2]);
-        bool ret = f(vm, _0, _1, _2);
+        bool ret = f(_0, _1, _2);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__float_float_float)(VM*, f64, f64, f64);
+typedef bool (*__f_bool__float_float_float)(f64, f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_bool__float_float_float(VM* vm, const char* mod, const char* name, __f_bool__float_float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6909,12 +6909,12 @@ void pkpy_vm_bind__f_bool__float_float_float(VM* vm, const char* mod, const char
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
         f64 _2 = vm->PyFloat_AS_C(args[2]);
-        bool ret = f(vm, _0, _1, _2);
+        bool ret = f(_0, _1, _2);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__str_str_str)(VM*, const char*, const char*, const char*);
+typedef bool (*__f_bool__str_str_str)(const char*, const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_bool__str_str_str(VM* vm, const char* mod, const char* name, __f_bool__str_str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6922,12 +6922,12 @@ void pkpy_vm_bind__f_bool__str_str_str(VM* vm, const char* mod, const char* name
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
         const char* _2 = vm->PyStr_AS_C(args[2]);
-        bool ret = f(vm, _0, _1, _2);
+        bool ret = f(_0, _1, _2);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__bool_bool_bool)(VM*, bool, bool, bool);
+typedef bool (*__f_bool__bool_bool_bool)(bool, bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_bool__bool_bool_bool(VM* vm, const char* mod, const char* name, __f_bool__bool_bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6935,12 +6935,12 @@ void pkpy_vm_bind__f_bool__bool_bool_bool(VM* vm, const char* mod, const char* n
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
         bool _2 = vm->PyBool_AS_C(args[2]);
-        bool ret = f(vm, _0, _1, _2);
+        bool ret = f(_0, _1, _2);
         return vm->PyBool(ret);
     });
 }
 
-typedef void (*__f_None__int_int_int)(VM*, i64, i64, i64);
+typedef void (*__f_None__int_int_int)(i64, i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_None__int_int_int(VM* vm, const char* mod, const char* name, __f_None__int_int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6948,12 +6948,12 @@ void pkpy_vm_bind__f_None__int_int_int(VM* vm, const char* mod, const char* name
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
         i64 _2 = vm->PyInt_AS_C(args[2]);
-        f(vm, _0, _1, _2);
+        f(_0, _1, _2);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__float_float_float)(VM*, f64, f64, f64);
+typedef void (*__f_None__float_float_float)(f64, f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_None__float_float_float(VM* vm, const char* mod, const char* name, __f_None__float_float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6961,12 +6961,12 @@ void pkpy_vm_bind__f_None__float_float_float(VM* vm, const char* mod, const char
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
         f64 _2 = vm->PyFloat_AS_C(args[2]);
-        f(vm, _0, _1, _2);
+        f(_0, _1, _2);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__str_str_str)(VM*, const char*, const char*, const char*);
+typedef void (*__f_None__str_str_str)(const char*, const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_None__str_str_str(VM* vm, const char* mod, const char* name, __f_None__str_str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6974,12 +6974,12 @@ void pkpy_vm_bind__f_None__str_str_str(VM* vm, const char* mod, const char* name
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
         const char* _2 = vm->PyStr_AS_C(args[2]);
-        f(vm, _0, _1, _2);
+        f(_0, _1, _2);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__bool_bool_bool)(VM*, bool, bool, bool);
+typedef void (*__f_None__bool_bool_bool)(bool, bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_None__bool_bool_bool(VM* vm, const char* mod, const char* name, __f_None__bool_bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -6987,1237 +6987,1237 @@ void pkpy_vm_bind__f_None__bool_bool_bool(VM* vm, const char* mod, const char* n
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
         bool _2 = vm->PyBool_AS_C(args[2]);
-        f(vm, _0, _1, _2);
+        f(_0, _1, _2);
         return vm->None;
     });
 }
 
-typedef i64 (*__f_int__int_int)(VM*, i64, i64);
+typedef i64 (*__f_int__int_int)(i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_int__int_int(VM* vm, const char* mod, const char* name, __f_int__int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__int_float)(VM*, i64, f64);
+typedef i64 (*__f_int__int_float)(i64, f64);
 __EXPORT
 void pkpy_vm_bind__f_int__int_float(VM* vm, const char* mod, const char* name, __f_int__int_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__int_str)(VM*, i64, const char*);
+typedef i64 (*__f_int__int_str)(i64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_int__int_str(VM* vm, const char* mod, const char* name, __f_int__int_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__int_bool)(VM*, i64, bool);
+typedef i64 (*__f_int__int_bool)(i64, bool);
 __EXPORT
 void pkpy_vm_bind__f_int__int_bool(VM* vm, const char* mod, const char* name, __f_int__int_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__float_int)(VM*, f64, i64);
+typedef i64 (*__f_int__float_int)(f64, i64);
 __EXPORT
 void pkpy_vm_bind__f_int__float_int(VM* vm, const char* mod, const char* name, __f_int__float_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__float_float)(VM*, f64, f64);
+typedef i64 (*__f_int__float_float)(f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_int__float_float(VM* vm, const char* mod, const char* name, __f_int__float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__float_str)(VM*, f64, const char*);
+typedef i64 (*__f_int__float_str)(f64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_int__float_str(VM* vm, const char* mod, const char* name, __f_int__float_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__float_bool)(VM*, f64, bool);
+typedef i64 (*__f_int__float_bool)(f64, bool);
 __EXPORT
 void pkpy_vm_bind__f_int__float_bool(VM* vm, const char* mod, const char* name, __f_int__float_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__str_int)(VM*, const char*, i64);
+typedef i64 (*__f_int__str_int)(const char*, i64);
 __EXPORT
 void pkpy_vm_bind__f_int__str_int(VM* vm, const char* mod, const char* name, __f_int__str_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__str_float)(VM*, const char*, f64);
+typedef i64 (*__f_int__str_float)(const char*, f64);
 __EXPORT
 void pkpy_vm_bind__f_int__str_float(VM* vm, const char* mod, const char* name, __f_int__str_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__str_str)(VM*, const char*, const char*);
+typedef i64 (*__f_int__str_str)(const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_int__str_str(VM* vm, const char* mod, const char* name, __f_int__str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__str_bool)(VM*, const char*, bool);
+typedef i64 (*__f_int__str_bool)(const char*, bool);
 __EXPORT
 void pkpy_vm_bind__f_int__str_bool(VM* vm, const char* mod, const char* name, __f_int__str_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__bool_int)(VM*, bool, i64);
+typedef i64 (*__f_int__bool_int)(bool, i64);
 __EXPORT
 void pkpy_vm_bind__f_int__bool_int(VM* vm, const char* mod, const char* name, __f_int__bool_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__bool_float)(VM*, bool, f64);
+typedef i64 (*__f_int__bool_float)(bool, f64);
 __EXPORT
 void pkpy_vm_bind__f_int__bool_float(VM* vm, const char* mod, const char* name, __f_int__bool_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__bool_str)(VM*, bool, const char*);
+typedef i64 (*__f_int__bool_str)(bool, const char*);
 __EXPORT
 void pkpy_vm_bind__f_int__bool_str(VM* vm, const char* mod, const char* name, __f_int__bool_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__bool_bool)(VM*, bool, bool);
+typedef i64 (*__f_int__bool_bool)(bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_int__bool_bool(VM* vm, const char* mod, const char* name, __f_int__bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef f64 (*__f_float__int_int)(VM*, i64, i64);
+typedef f64 (*__f_float__int_int)(i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_float__int_int(VM* vm, const char* mod, const char* name, __f_float__int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__int_float)(VM*, i64, f64);
+typedef f64 (*__f_float__int_float)(i64, f64);
 __EXPORT
 void pkpy_vm_bind__f_float__int_float(VM* vm, const char* mod, const char* name, __f_float__int_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__int_str)(VM*, i64, const char*);
+typedef f64 (*__f_float__int_str)(i64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_float__int_str(VM* vm, const char* mod, const char* name, __f_float__int_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__int_bool)(VM*, i64, bool);
+typedef f64 (*__f_float__int_bool)(i64, bool);
 __EXPORT
 void pkpy_vm_bind__f_float__int_bool(VM* vm, const char* mod, const char* name, __f_float__int_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__float_int)(VM*, f64, i64);
+typedef f64 (*__f_float__float_int)(f64, i64);
 __EXPORT
 void pkpy_vm_bind__f_float__float_int(VM* vm, const char* mod, const char* name, __f_float__float_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__float_float)(VM*, f64, f64);
+typedef f64 (*__f_float__float_float)(f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_float__float_float(VM* vm, const char* mod, const char* name, __f_float__float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__float_str)(VM*, f64, const char*);
+typedef f64 (*__f_float__float_str)(f64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_float__float_str(VM* vm, const char* mod, const char* name, __f_float__float_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__float_bool)(VM*, f64, bool);
+typedef f64 (*__f_float__float_bool)(f64, bool);
 __EXPORT
 void pkpy_vm_bind__f_float__float_bool(VM* vm, const char* mod, const char* name, __f_float__float_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__str_int)(VM*, const char*, i64);
+typedef f64 (*__f_float__str_int)(const char*, i64);
 __EXPORT
 void pkpy_vm_bind__f_float__str_int(VM* vm, const char* mod, const char* name, __f_float__str_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__str_float)(VM*, const char*, f64);
+typedef f64 (*__f_float__str_float)(const char*, f64);
 __EXPORT
 void pkpy_vm_bind__f_float__str_float(VM* vm, const char* mod, const char* name, __f_float__str_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__str_str)(VM*, const char*, const char*);
+typedef f64 (*__f_float__str_str)(const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_float__str_str(VM* vm, const char* mod, const char* name, __f_float__str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__str_bool)(VM*, const char*, bool);
+typedef f64 (*__f_float__str_bool)(const char*, bool);
 __EXPORT
 void pkpy_vm_bind__f_float__str_bool(VM* vm, const char* mod, const char* name, __f_float__str_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__bool_int)(VM*, bool, i64);
+typedef f64 (*__f_float__bool_int)(bool, i64);
 __EXPORT
 void pkpy_vm_bind__f_float__bool_int(VM* vm, const char* mod, const char* name, __f_float__bool_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__bool_float)(VM*, bool, f64);
+typedef f64 (*__f_float__bool_float)(bool, f64);
 __EXPORT
 void pkpy_vm_bind__f_float__bool_float(VM* vm, const char* mod, const char* name, __f_float__bool_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__bool_str)(VM*, bool, const char*);
+typedef f64 (*__f_float__bool_str)(bool, const char*);
 __EXPORT
 void pkpy_vm_bind__f_float__bool_str(VM* vm, const char* mod, const char* name, __f_float__bool_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__bool_bool)(VM*, bool, bool);
+typedef f64 (*__f_float__bool_bool)(bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_float__bool_bool(VM* vm, const char* mod, const char* name, __f_float__bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef const char* (*__f_str__int_int)(VM*, i64, i64);
+typedef const char* (*__f_str__int_int)(i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_str__int_int(VM* vm, const char* mod, const char* name, __f_str__int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__int_float)(VM*, i64, f64);
+typedef const char* (*__f_str__int_float)(i64, f64);
 __EXPORT
 void pkpy_vm_bind__f_str__int_float(VM* vm, const char* mod, const char* name, __f_str__int_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__int_str)(VM*, i64, const char*);
+typedef const char* (*__f_str__int_str)(i64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_str__int_str(VM* vm, const char* mod, const char* name, __f_str__int_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__int_bool)(VM*, i64, bool);
+typedef const char* (*__f_str__int_bool)(i64, bool);
 __EXPORT
 void pkpy_vm_bind__f_str__int_bool(VM* vm, const char* mod, const char* name, __f_str__int_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__float_int)(VM*, f64, i64);
+typedef const char* (*__f_str__float_int)(f64, i64);
 __EXPORT
 void pkpy_vm_bind__f_str__float_int(VM* vm, const char* mod, const char* name, __f_str__float_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__float_float)(VM*, f64, f64);
+typedef const char* (*__f_str__float_float)(f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_str__float_float(VM* vm, const char* mod, const char* name, __f_str__float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__float_str)(VM*, f64, const char*);
+typedef const char* (*__f_str__float_str)(f64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_str__float_str(VM* vm, const char* mod, const char* name, __f_str__float_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__float_bool)(VM*, f64, bool);
+typedef const char* (*__f_str__float_bool)(f64, bool);
 __EXPORT
 void pkpy_vm_bind__f_str__float_bool(VM* vm, const char* mod, const char* name, __f_str__float_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__str_int)(VM*, const char*, i64);
+typedef const char* (*__f_str__str_int)(const char*, i64);
 __EXPORT
 void pkpy_vm_bind__f_str__str_int(VM* vm, const char* mod, const char* name, __f_str__str_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__str_float)(VM*, const char*, f64);
+typedef const char* (*__f_str__str_float)(const char*, f64);
 __EXPORT
 void pkpy_vm_bind__f_str__str_float(VM* vm, const char* mod, const char* name, __f_str__str_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__str_str)(VM*, const char*, const char*);
+typedef const char* (*__f_str__str_str)(const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_str__str_str(VM* vm, const char* mod, const char* name, __f_str__str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__str_bool)(VM*, const char*, bool);
+typedef const char* (*__f_str__str_bool)(const char*, bool);
 __EXPORT
 void pkpy_vm_bind__f_str__str_bool(VM* vm, const char* mod, const char* name, __f_str__str_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__bool_int)(VM*, bool, i64);
+typedef const char* (*__f_str__bool_int)(bool, i64);
 __EXPORT
 void pkpy_vm_bind__f_str__bool_int(VM* vm, const char* mod, const char* name, __f_str__bool_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__bool_float)(VM*, bool, f64);
+typedef const char* (*__f_str__bool_float)(bool, f64);
 __EXPORT
 void pkpy_vm_bind__f_str__bool_float(VM* vm, const char* mod, const char* name, __f_str__bool_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__bool_str)(VM*, bool, const char*);
+typedef const char* (*__f_str__bool_str)(bool, const char*);
 __EXPORT
 void pkpy_vm_bind__f_str__bool_str(VM* vm, const char* mod, const char* name, __f_str__bool_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__bool_bool)(VM*, bool, bool);
+typedef const char* (*__f_str__bool_bool)(bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_str__bool_bool(VM* vm, const char* mod, const char* name, __f_str__bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef bool (*__f_bool__int_int)(VM*, i64, i64);
+typedef bool (*__f_bool__int_int)(i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_bool__int_int(VM* vm, const char* mod, const char* name, __f_bool__int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__int_float)(VM*, i64, f64);
+typedef bool (*__f_bool__int_float)(i64, f64);
 __EXPORT
 void pkpy_vm_bind__f_bool__int_float(VM* vm, const char* mod, const char* name, __f_bool__int_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__int_str)(VM*, i64, const char*);
+typedef bool (*__f_bool__int_str)(i64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_bool__int_str(VM* vm, const char* mod, const char* name, __f_bool__int_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__int_bool)(VM*, i64, bool);
+typedef bool (*__f_bool__int_bool)(i64, bool);
 __EXPORT
 void pkpy_vm_bind__f_bool__int_bool(VM* vm, const char* mod, const char* name, __f_bool__int_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__float_int)(VM*, f64, i64);
+typedef bool (*__f_bool__float_int)(f64, i64);
 __EXPORT
 void pkpy_vm_bind__f_bool__float_int(VM* vm, const char* mod, const char* name, __f_bool__float_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__float_float)(VM*, f64, f64);
+typedef bool (*__f_bool__float_float)(f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_bool__float_float(VM* vm, const char* mod, const char* name, __f_bool__float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__float_str)(VM*, f64, const char*);
+typedef bool (*__f_bool__float_str)(f64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_bool__float_str(VM* vm, const char* mod, const char* name, __f_bool__float_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__float_bool)(VM*, f64, bool);
+typedef bool (*__f_bool__float_bool)(f64, bool);
 __EXPORT
 void pkpy_vm_bind__f_bool__float_bool(VM* vm, const char* mod, const char* name, __f_bool__float_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__str_int)(VM*, const char*, i64);
+typedef bool (*__f_bool__str_int)(const char*, i64);
 __EXPORT
 void pkpy_vm_bind__f_bool__str_int(VM* vm, const char* mod, const char* name, __f_bool__str_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__str_float)(VM*, const char*, f64);
+typedef bool (*__f_bool__str_float)(const char*, f64);
 __EXPORT
 void pkpy_vm_bind__f_bool__str_float(VM* vm, const char* mod, const char* name, __f_bool__str_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__str_str)(VM*, const char*, const char*);
+typedef bool (*__f_bool__str_str)(const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_bool__str_str(VM* vm, const char* mod, const char* name, __f_bool__str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__str_bool)(VM*, const char*, bool);
+typedef bool (*__f_bool__str_bool)(const char*, bool);
 __EXPORT
 void pkpy_vm_bind__f_bool__str_bool(VM* vm, const char* mod, const char* name, __f_bool__str_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__bool_int)(VM*, bool, i64);
+typedef bool (*__f_bool__bool_int)(bool, i64);
 __EXPORT
 void pkpy_vm_bind__f_bool__bool_int(VM* vm, const char* mod, const char* name, __f_bool__bool_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__bool_float)(VM*, bool, f64);
+typedef bool (*__f_bool__bool_float)(bool, f64);
 __EXPORT
 void pkpy_vm_bind__f_bool__bool_float(VM* vm, const char* mod, const char* name, __f_bool__bool_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__bool_str)(VM*, bool, const char*);
+typedef bool (*__f_bool__bool_str)(bool, const char*);
 __EXPORT
 void pkpy_vm_bind__f_bool__bool_str(VM* vm, const char* mod, const char* name, __f_bool__bool_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__bool_bool)(VM*, bool, bool);
+typedef bool (*__f_bool__bool_bool)(bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_bool__bool_bool(VM* vm, const char* mod, const char* name, __f_bool__bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef void (*__f_None__int_int)(VM*, i64, i64);
+typedef void (*__f_None__int_int)(i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_None__int_int(VM* vm, const char* mod, const char* name, __f_None__int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__int_float)(VM*, i64, f64);
+typedef void (*__f_None__int_float)(i64, f64);
 __EXPORT
 void pkpy_vm_bind__f_None__int_float(VM* vm, const char* mod, const char* name, __f_None__int_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__int_str)(VM*, i64, const char*);
+typedef void (*__f_None__int_str)(i64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_None__int_str(VM* vm, const char* mod, const char* name, __f_None__int_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__int_bool)(VM*, i64, bool);
+typedef void (*__f_None__int_bool)(i64, bool);
 __EXPORT
 void pkpy_vm_bind__f_None__int_bool(VM* vm, const char* mod, const char* name, __f_None__int_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__float_int)(VM*, f64, i64);
+typedef void (*__f_None__float_int)(f64, i64);
 __EXPORT
 void pkpy_vm_bind__f_None__float_int(VM* vm, const char* mod, const char* name, __f_None__float_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__float_float)(VM*, f64, f64);
+typedef void (*__f_None__float_float)(f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_None__float_float(VM* vm, const char* mod, const char* name, __f_None__float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__float_str)(VM*, f64, const char*);
+typedef void (*__f_None__float_str)(f64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_None__float_str(VM* vm, const char* mod, const char* name, __f_None__float_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__float_bool)(VM*, f64, bool);
+typedef void (*__f_None__float_bool)(f64, bool);
 __EXPORT
 void pkpy_vm_bind__f_None__float_bool(VM* vm, const char* mod, const char* name, __f_None__float_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__str_int)(VM*, const char*, i64);
+typedef void (*__f_None__str_int)(const char*, i64);
 __EXPORT
 void pkpy_vm_bind__f_None__str_int(VM* vm, const char* mod, const char* name, __f_None__str_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__str_float)(VM*, const char*, f64);
+typedef void (*__f_None__str_float)(const char*, f64);
 __EXPORT
 void pkpy_vm_bind__f_None__str_float(VM* vm, const char* mod, const char* name, __f_None__str_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__str_str)(VM*, const char*, const char*);
+typedef void (*__f_None__str_str)(const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_None__str_str(VM* vm, const char* mod, const char* name, __f_None__str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__str_bool)(VM*, const char*, bool);
+typedef void (*__f_None__str_bool)(const char*, bool);
 __EXPORT
 void pkpy_vm_bind__f_None__str_bool(VM* vm, const char* mod, const char* name, __f_None__str_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__bool_int)(VM*, bool, i64);
+typedef void (*__f_None__bool_int)(bool, i64);
 __EXPORT
 void pkpy_vm_bind__f_None__bool_int(VM* vm, const char* mod, const char* name, __f_None__bool_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__bool_float)(VM*, bool, f64);
+typedef void (*__f_None__bool_float)(bool, f64);
 __EXPORT
 void pkpy_vm_bind__f_None__bool_float(VM* vm, const char* mod, const char* name, __f_None__bool_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__bool_str)(VM*, bool, const char*);
+typedef void (*__f_None__bool_str)(bool, const char*);
 __EXPORT
 void pkpy_vm_bind__f_None__bool_str(VM* vm, const char* mod, const char* name, __f_None__bool_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__bool_bool)(VM*, bool, bool);
+typedef void (*__f_None__bool_bool)(bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_None__bool_bool(VM* vm, const char* mod, const char* name, __f_None__bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef i64 (*__f_int__int)(VM*, i64);
+typedef i64 (*__f_int__int)(i64);
 __EXPORT
 void pkpy_vm_bind__f_int__int(VM* vm, const char* mod, const char* name, __f_int__int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
-        i64 ret = f(vm, _0);
+        i64 ret = f(_0);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__float)(VM*, f64);
+typedef i64 (*__f_int__float)(f64);
 __EXPORT
 void pkpy_vm_bind__f_int__float(VM* vm, const char* mod, const char* name, __f_int__float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
-        i64 ret = f(vm, _0);
+        i64 ret = f(_0);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__str)(VM*, const char*);
+typedef i64 (*__f_int__str)(const char*);
 __EXPORT
 void pkpy_vm_bind__f_int__str(VM* vm, const char* mod, const char* name, __f_int__str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
-        i64 ret = f(vm, _0);
+        i64 ret = f(_0);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__bool)(VM*, bool);
+typedef i64 (*__f_int__bool)(bool);
 __EXPORT
 void pkpy_vm_bind__f_int__bool(VM* vm, const char* mod, const char* name, __f_int__bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
-        i64 ret = f(vm, _0);
+        i64 ret = f(_0);
         return vm->PyInt(ret);
     });
 }
 
-typedef f64 (*__f_float__int)(VM*, i64);
+typedef f64 (*__f_float__int)(i64);
 __EXPORT
 void pkpy_vm_bind__f_float__int(VM* vm, const char* mod, const char* name, __f_float__int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
-        f64 ret = f(vm, _0);
+        f64 ret = f(_0);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__float)(VM*, f64);
+typedef f64 (*__f_float__float)(f64);
 __EXPORT
 void pkpy_vm_bind__f_float__float(VM* vm, const char* mod, const char* name, __f_float__float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
-        f64 ret = f(vm, _0);
+        f64 ret = f(_0);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__str)(VM*, const char*);
+typedef f64 (*__f_float__str)(const char*);
 __EXPORT
 void pkpy_vm_bind__f_float__str(VM* vm, const char* mod, const char* name, __f_float__str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
-        f64 ret = f(vm, _0);
+        f64 ret = f(_0);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__bool)(VM*, bool);
+typedef f64 (*__f_float__bool)(bool);
 __EXPORT
 void pkpy_vm_bind__f_float__bool(VM* vm, const char* mod, const char* name, __f_float__bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
-        f64 ret = f(vm, _0);
+        f64 ret = f(_0);
         return vm->PyFloat(ret);
     });
 }
 
-typedef const char* (*__f_str__int)(VM*, i64);
+typedef const char* (*__f_str__int)(i64);
 __EXPORT
 void pkpy_vm_bind__f_str__int(VM* vm, const char* mod, const char* name, __f_str__int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
-        const char* ret = f(vm, _0);
+        const char* ret = f(_0);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__float)(VM*, f64);
+typedef const char* (*__f_str__float)(f64);
 __EXPORT
 void pkpy_vm_bind__f_str__float(VM* vm, const char* mod, const char* name, __f_str__float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
-        const char* ret = f(vm, _0);
+        const char* ret = f(_0);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__str)(VM*, const char*);
+typedef const char* (*__f_str__str)(const char*);
 __EXPORT
 void pkpy_vm_bind__f_str__str(VM* vm, const char* mod, const char* name, __f_str__str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
-        const char* ret = f(vm, _0);
+        const char* ret = f(_0);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__bool)(VM*, bool);
+typedef const char* (*__f_str__bool)(bool);
 __EXPORT
 void pkpy_vm_bind__f_str__bool(VM* vm, const char* mod, const char* name, __f_str__bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
-        const char* ret = f(vm, _0);
+        const char* ret = f(_0);
         return vm->PyStr(ret);
     });
 }
 
-typedef bool (*__f_bool__int)(VM*, i64);
+typedef bool (*__f_bool__int)(i64);
 __EXPORT
 void pkpy_vm_bind__f_bool__int(VM* vm, const char* mod, const char* name, __f_bool__int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
-        bool ret = f(vm, _0);
+        bool ret = f(_0);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__float)(VM*, f64);
+typedef bool (*__f_bool__float)(f64);
 __EXPORT
 void pkpy_vm_bind__f_bool__float(VM* vm, const char* mod, const char* name, __f_bool__float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
-        bool ret = f(vm, _0);
+        bool ret = f(_0);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__str)(VM*, const char*);
+typedef bool (*__f_bool__str)(const char*);
 __EXPORT
 void pkpy_vm_bind__f_bool__str(VM* vm, const char* mod, const char* name, __f_bool__str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
-        bool ret = f(vm, _0);
+        bool ret = f(_0);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__bool)(VM*, bool);
+typedef bool (*__f_bool__bool)(bool);
 __EXPORT
 void pkpy_vm_bind__f_bool__bool(VM* vm, const char* mod, const char* name, __f_bool__bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
-        bool ret = f(vm, _0);
+        bool ret = f(_0);
         return vm->PyBool(ret);
     });
 }
 
-typedef void (*__f_None__int)(VM*, i64);
+typedef void (*__f_None__int)(i64);
 __EXPORT
 void pkpy_vm_bind__f_None__int(VM* vm, const char* mod, const char* name, __f_None__int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
-        f(vm, _0);
+        f(_0);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__float)(VM*, f64);
+typedef void (*__f_None__float)(f64);
 __EXPORT
 void pkpy_vm_bind__f_None__float(VM* vm, const char* mod, const char* name, __f_None__float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
-        f(vm, _0);
+        f(_0);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__str)(VM*, const char*);
+typedef void (*__f_None__str)(const char*);
 __EXPORT
 void pkpy_vm_bind__f_None__str(VM* vm, const char* mod, const char* name, __f_None__str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
-        f(vm, _0);
+        f(_0);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__bool)(VM*, bool);
+typedef void (*__f_None__bool)(bool);
 __EXPORT
 void pkpy_vm_bind__f_None__bool(VM* vm, const char* mod, const char* name, __f_None__bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
-        f(vm, _0);
+        f(_0);
         return vm->None;
     });
 }
 
-typedef i64 (*__f_int__)(VM*);
+typedef i64 (*__f_int__)();
 __EXPORT
 void pkpy_vm_bind__f_int__(VM* vm, const char* mod, const char* name, __f_int__ f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<0>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
-        i64 ret = f(vm);
+        i64 ret = f();
         return vm->PyInt(ret);
     });
 }
 
-typedef f64 (*__f_float__)(VM*);
+typedef f64 (*__f_float__)();
 __EXPORT
 void pkpy_vm_bind__f_float__(VM* vm, const char* mod, const char* name, __f_float__ f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<0>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
-        f64 ret = f(vm);
+        f64 ret = f();
         return vm->PyFloat(ret);
     });
 }
 
-typedef const char* (*__f_str__)(VM*);
+typedef const char* (*__f_str__)();
 __EXPORT
 void pkpy_vm_bind__f_str__(VM* vm, const char* mod, const char* name, __f_str__ f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<0>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
-        const char* ret = f(vm);
+        const char* ret = f();
         return vm->PyStr(ret);
     });
 }
 
-typedef bool (*__f_bool__)(VM*);
+typedef bool (*__f_bool__)();
 __EXPORT
 void pkpy_vm_bind__f_bool__(VM* vm, const char* mod, const char* name, __f_bool__ f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<0>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
-        bool ret = f(vm);
+        bool ret = f();
         return vm->PyBool(ret);
     });
 }
 
-typedef void (*__f_None__)(VM*);
+typedef void (*__f_None__)();
 __EXPORT
 void pkpy_vm_bind__f_None__(VM* vm, const char* mod, const char* name, __f_None__ f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<0>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
-        f(vm);
+        f();
         return vm->None;
     });
 }

plugins/godot/godot-cpp

@@ -1 +1 @@
-Subproject commit de94780fd098c376d61f84a6b1655758f9b74c17
+Subproject commit 82f297a00d351a32467eadb8f91865b8d87d2efd

scripts/moc.py

@@ -25,7 +25,7 @@ for n in [4,3,2,1]:
     res = []
     args(n, [], res)
     for p_ret,*p_args in res:
-        c_args = ['VM*'] + [mapping[i] for i in p_args]
+        c_args = [mapping[i] for i in p_args]
         c_ret = mapping[p_ret]
         name = f'__f_{p_ret}__{"_".join(p_args)}'
         # if c_ret == 'const char*':
@@ -36,7 +36,7 @@ for n in [4,3,2,1]:
         impl = []
         for i, p_arg in enumerate(p_args):
             impl.append( f'{mapping[p_arg]} _{i} = vm->Py{p_arg.capitalize()}_AS_C(args[{i}]);' )
-        call_impl = f'f({", ".join(["vm"] + [f"_{j}" for j in range(len(p_args))])})';
+        call_impl = f'f({", ".join([f"_{j}" for j in range(len(p_args))])})';
         if p_ret == 'None':
             impl.append( call_impl + ';' )
             impl.append( 'return vm->None;' )

src/_bindings.h

@@ -1,5 +1,5 @@
 extern "C" {
-typedef i64 (*__f_int__int_int_int)(VM*, i64, i64, i64);
+typedef i64 (*__f_int__int_int_int)(i64, i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_int__int_int_int(VM* vm, const char* mod, const char* name, __f_int__int_int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -7,12 +7,12 @@ void pkpy_vm_bind__f_int__int_int_int(VM* vm, const char* mod, const char* name,
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
         i64 _2 = vm->PyInt_AS_C(args[2]);
-        i64 ret = f(vm, _0, _1, _2);
+        i64 ret = f(_0, _1, _2);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__float_float_float)(VM*, f64, f64, f64);
+typedef i64 (*__f_int__float_float_float)(f64, f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_int__float_float_float(VM* vm, const char* mod, const char* name, __f_int__float_float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -20,12 +20,12 @@ void pkpy_vm_bind__f_int__float_float_float(VM* vm, const char* mod, const char*
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
         f64 _2 = vm->PyFloat_AS_C(args[2]);
-        i64 ret = f(vm, _0, _1, _2);
+        i64 ret = f(_0, _1, _2);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__str_str_str)(VM*, const char*, const char*, const char*);
+typedef i64 (*__f_int__str_str_str)(const char*, const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_int__str_str_str(VM* vm, const char* mod, const char* name, __f_int__str_str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -33,12 +33,12 @@ void pkpy_vm_bind__f_int__str_str_str(VM* vm, const char* mod, const char* name,
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
         const char* _2 = vm->PyStr_AS_C(args[2]);
-        i64 ret = f(vm, _0, _1, _2);
+        i64 ret = f(_0, _1, _2);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__bool_bool_bool)(VM*, bool, bool, bool);
+typedef i64 (*__f_int__bool_bool_bool)(bool, bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_int__bool_bool_bool(VM* vm, const char* mod, const char* name, __f_int__bool_bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -46,12 +46,12 @@ void pkpy_vm_bind__f_int__bool_bool_bool(VM* vm, const char* mod, const char* na
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
         bool _2 = vm->PyBool_AS_C(args[2]);
-        i64 ret = f(vm, _0, _1, _2);
+        i64 ret = f(_0, _1, _2);
         return vm->PyInt(ret);
     });
 }
 
-typedef f64 (*__f_float__int_int_int)(VM*, i64, i64, i64);
+typedef f64 (*__f_float__int_int_int)(i64, i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_float__int_int_int(VM* vm, const char* mod, const char* name, __f_float__int_int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -59,12 +59,12 @@ void pkpy_vm_bind__f_float__int_int_int(VM* vm, const char* mod, const char* nam
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
         i64 _2 = vm->PyInt_AS_C(args[2]);
-        f64 ret = f(vm, _0, _1, _2);
+        f64 ret = f(_0, _1, _2);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__float_float_float)(VM*, f64, f64, f64);
+typedef f64 (*__f_float__float_float_float)(f64, f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_float__float_float_float(VM* vm, const char* mod, const char* name, __f_float__float_float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -72,12 +72,12 @@ void pkpy_vm_bind__f_float__float_float_float(VM* vm, const char* mod, const cha
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
         f64 _2 = vm->PyFloat_AS_C(args[2]);
-        f64 ret = f(vm, _0, _1, _2);
+        f64 ret = f(_0, _1, _2);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__str_str_str)(VM*, const char*, const char*, const char*);
+typedef f64 (*__f_float__str_str_str)(const char*, const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_float__str_str_str(VM* vm, const char* mod, const char* name, __f_float__str_str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -85,12 +85,12 @@ void pkpy_vm_bind__f_float__str_str_str(VM* vm, const char* mod, const char* nam
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
         const char* _2 = vm->PyStr_AS_C(args[2]);
-        f64 ret = f(vm, _0, _1, _2);
+        f64 ret = f(_0, _1, _2);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__bool_bool_bool)(VM*, bool, bool, bool);
+typedef f64 (*__f_float__bool_bool_bool)(bool, bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_float__bool_bool_bool(VM* vm, const char* mod, const char* name, __f_float__bool_bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -98,12 +98,12 @@ void pkpy_vm_bind__f_float__bool_bool_bool(VM* vm, const char* mod, const char*
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
         bool _2 = vm->PyBool_AS_C(args[2]);
-        f64 ret = f(vm, _0, _1, _2);
+        f64 ret = f(_0, _1, _2);
         return vm->PyFloat(ret);
     });
 }
 
-typedef const char* (*__f_str__int_int_int)(VM*, i64, i64, i64);
+typedef const char* (*__f_str__int_int_int)(i64, i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_str__int_int_int(VM* vm, const char* mod, const char* name, __f_str__int_int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -111,12 +111,12 @@ void pkpy_vm_bind__f_str__int_int_int(VM* vm, const char* mod, const char* name,
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
         i64 _2 = vm->PyInt_AS_C(args[2]);
-        const char* ret = f(vm, _0, _1, _2);
+        const char* ret = f(_0, _1, _2);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__float_float_float)(VM*, f64, f64, f64);
+typedef const char* (*__f_str__float_float_float)(f64, f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_str__float_float_float(VM* vm, const char* mod, const char* name, __f_str__float_float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -124,12 +124,12 @@ void pkpy_vm_bind__f_str__float_float_float(VM* vm, const char* mod, const char*
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
         f64 _2 = vm->PyFloat_AS_C(args[2]);
-        const char* ret = f(vm, _0, _1, _2);
+        const char* ret = f(_0, _1, _2);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__str_str_str)(VM*, const char*, const char*, const char*);
+typedef const char* (*__f_str__str_str_str)(const char*, const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_str__str_str_str(VM* vm, const char* mod, const char* name, __f_str__str_str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -137,12 +137,12 @@ void pkpy_vm_bind__f_str__str_str_str(VM* vm, const char* mod, const char* name,
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
         const char* _2 = vm->PyStr_AS_C(args[2]);
-        const char* ret = f(vm, _0, _1, _2);
+        const char* ret = f(_0, _1, _2);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__bool_bool_bool)(VM*, bool, bool, bool);
+typedef const char* (*__f_str__bool_bool_bool)(bool, bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_str__bool_bool_bool(VM* vm, const char* mod, const char* name, __f_str__bool_bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -150,12 +150,12 @@ void pkpy_vm_bind__f_str__bool_bool_bool(VM* vm, const char* mod, const char* na
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
         bool _2 = vm->PyBool_AS_C(args[2]);
-        const char* ret = f(vm, _0, _1, _2);
+        const char* ret = f(_0, _1, _2);
         return vm->PyStr(ret);
     });
 }
 
-typedef bool (*__f_bool__int_int_int)(VM*, i64, i64, i64);
+typedef bool (*__f_bool__int_int_int)(i64, i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_bool__int_int_int(VM* vm, const char* mod, const char* name, __f_bool__int_int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -163,12 +163,12 @@ void pkpy_vm_bind__f_bool__int_int_int(VM* vm, const char* mod, const char* name
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
         i64 _2 = vm->PyInt_AS_C(args[2]);
-        bool ret = f(vm, _0, _1, _2);
+        bool ret = f(_0, _1, _2);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__float_float_float)(VM*, f64, f64, f64);
+typedef bool (*__f_bool__float_float_float)(f64, f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_bool__float_float_float(VM* vm, const char* mod, const char* name, __f_bool__float_float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -176,12 +176,12 @@ void pkpy_vm_bind__f_bool__float_float_float(VM* vm, const char* mod, const char
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
         f64 _2 = vm->PyFloat_AS_C(args[2]);
-        bool ret = f(vm, _0, _1, _2);
+        bool ret = f(_0, _1, _2);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__str_str_str)(VM*, const char*, const char*, const char*);
+typedef bool (*__f_bool__str_str_str)(const char*, const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_bool__str_str_str(VM* vm, const char* mod, const char* name, __f_bool__str_str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -189,12 +189,12 @@ void pkpy_vm_bind__f_bool__str_str_str(VM* vm, const char* mod, const char* name
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
         const char* _2 = vm->PyStr_AS_C(args[2]);
-        bool ret = f(vm, _0, _1, _2);
+        bool ret = f(_0, _1, _2);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__bool_bool_bool)(VM*, bool, bool, bool);
+typedef bool (*__f_bool__bool_bool_bool)(bool, bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_bool__bool_bool_bool(VM* vm, const char* mod, const char* name, __f_bool__bool_bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -202,12 +202,12 @@ void pkpy_vm_bind__f_bool__bool_bool_bool(VM* vm, const char* mod, const char* n
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
         bool _2 = vm->PyBool_AS_C(args[2]);
-        bool ret = f(vm, _0, _1, _2);
+        bool ret = f(_0, _1, _2);
         return vm->PyBool(ret);
     });
 }
 
-typedef void (*__f_None__int_int_int)(VM*, i64, i64, i64);
+typedef void (*__f_None__int_int_int)(i64, i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_None__int_int_int(VM* vm, const char* mod, const char* name, __f_None__int_int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -215,12 +215,12 @@ void pkpy_vm_bind__f_None__int_int_int(VM* vm, const char* mod, const char* name
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
         i64 _2 = vm->PyInt_AS_C(args[2]);
-        f(vm, _0, _1, _2);
+        f(_0, _1, _2);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__float_float_float)(VM*, f64, f64, f64);
+typedef void (*__f_None__float_float_float)(f64, f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_None__float_float_float(VM* vm, const char* mod, const char* name, __f_None__float_float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -228,12 +228,12 @@ void pkpy_vm_bind__f_None__float_float_float(VM* vm, const char* mod, const char
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
         f64 _2 = vm->PyFloat_AS_C(args[2]);
-        f(vm, _0, _1, _2);
+        f(_0, _1, _2);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__str_str_str)(VM*, const char*, const char*, const char*);
+typedef void (*__f_None__str_str_str)(const char*, const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_None__str_str_str(VM* vm, const char* mod, const char* name, __f_None__str_str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -241,12 +241,12 @@ void pkpy_vm_bind__f_None__str_str_str(VM* vm, const char* mod, const char* name
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
         const char* _2 = vm->PyStr_AS_C(args[2]);
-        f(vm, _0, _1, _2);
+        f(_0, _1, _2);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__bool_bool_bool)(VM*, bool, bool, bool);
+typedef void (*__f_None__bool_bool_bool)(bool, bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_None__bool_bool_bool(VM* vm, const char* mod, const char* name, __f_None__bool_bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
@@ -254,1237 +254,1237 @@ void pkpy_vm_bind__f_None__bool_bool_bool(VM* vm, const char* mod, const char* n
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
         bool _2 = vm->PyBool_AS_C(args[2]);
-        f(vm, _0, _1, _2);
+        f(_0, _1, _2);
         return vm->None;
     });
 }
 
-typedef i64 (*__f_int__int_int)(VM*, i64, i64);
+typedef i64 (*__f_int__int_int)(i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_int__int_int(VM* vm, const char* mod, const char* name, __f_int__int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__int_float)(VM*, i64, f64);
+typedef i64 (*__f_int__int_float)(i64, f64);
 __EXPORT
 void pkpy_vm_bind__f_int__int_float(VM* vm, const char* mod, const char* name, __f_int__int_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__int_str)(VM*, i64, const char*);
+typedef i64 (*__f_int__int_str)(i64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_int__int_str(VM* vm, const char* mod, const char* name, __f_int__int_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__int_bool)(VM*, i64, bool);
+typedef i64 (*__f_int__int_bool)(i64, bool);
 __EXPORT
 void pkpy_vm_bind__f_int__int_bool(VM* vm, const char* mod, const char* name, __f_int__int_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__float_int)(VM*, f64, i64);
+typedef i64 (*__f_int__float_int)(f64, i64);
 __EXPORT
 void pkpy_vm_bind__f_int__float_int(VM* vm, const char* mod, const char* name, __f_int__float_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__float_float)(VM*, f64, f64);
+typedef i64 (*__f_int__float_float)(f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_int__float_float(VM* vm, const char* mod, const char* name, __f_int__float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__float_str)(VM*, f64, const char*);
+typedef i64 (*__f_int__float_str)(f64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_int__float_str(VM* vm, const char* mod, const char* name, __f_int__float_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__float_bool)(VM*, f64, bool);
+typedef i64 (*__f_int__float_bool)(f64, bool);
 __EXPORT
 void pkpy_vm_bind__f_int__float_bool(VM* vm, const char* mod, const char* name, __f_int__float_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__str_int)(VM*, const char*, i64);
+typedef i64 (*__f_int__str_int)(const char*, i64);
 __EXPORT
 void pkpy_vm_bind__f_int__str_int(VM* vm, const char* mod, const char* name, __f_int__str_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__str_float)(VM*, const char*, f64);
+typedef i64 (*__f_int__str_float)(const char*, f64);
 __EXPORT
 void pkpy_vm_bind__f_int__str_float(VM* vm, const char* mod, const char* name, __f_int__str_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__str_str)(VM*, const char*, const char*);
+typedef i64 (*__f_int__str_str)(const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_int__str_str(VM* vm, const char* mod, const char* name, __f_int__str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__str_bool)(VM*, const char*, bool);
+typedef i64 (*__f_int__str_bool)(const char*, bool);
 __EXPORT
 void pkpy_vm_bind__f_int__str_bool(VM* vm, const char* mod, const char* name, __f_int__str_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__bool_int)(VM*, bool, i64);
+typedef i64 (*__f_int__bool_int)(bool, i64);
 __EXPORT
 void pkpy_vm_bind__f_int__bool_int(VM* vm, const char* mod, const char* name, __f_int__bool_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__bool_float)(VM*, bool, f64);
+typedef i64 (*__f_int__bool_float)(bool, f64);
 __EXPORT
 void pkpy_vm_bind__f_int__bool_float(VM* vm, const char* mod, const char* name, __f_int__bool_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__bool_str)(VM*, bool, const char*);
+typedef i64 (*__f_int__bool_str)(bool, const char*);
 __EXPORT
 void pkpy_vm_bind__f_int__bool_str(VM* vm, const char* mod, const char* name, __f_int__bool_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__bool_bool)(VM*, bool, bool);
+typedef i64 (*__f_int__bool_bool)(bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_int__bool_bool(VM* vm, const char* mod, const char* name, __f_int__bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        i64 ret = f(vm, _0, _1);
+        i64 ret = f(_0, _1);
         return vm->PyInt(ret);
     });
 }
 
-typedef f64 (*__f_float__int_int)(VM*, i64, i64);
+typedef f64 (*__f_float__int_int)(i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_float__int_int(VM* vm, const char* mod, const char* name, __f_float__int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__int_float)(VM*, i64, f64);
+typedef f64 (*__f_float__int_float)(i64, f64);
 __EXPORT
 void pkpy_vm_bind__f_float__int_float(VM* vm, const char* mod, const char* name, __f_float__int_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__int_str)(VM*, i64, const char*);
+typedef f64 (*__f_float__int_str)(i64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_float__int_str(VM* vm, const char* mod, const char* name, __f_float__int_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__int_bool)(VM*, i64, bool);
+typedef f64 (*__f_float__int_bool)(i64, bool);
 __EXPORT
 void pkpy_vm_bind__f_float__int_bool(VM* vm, const char* mod, const char* name, __f_float__int_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__float_int)(VM*, f64, i64);
+typedef f64 (*__f_float__float_int)(f64, i64);
 __EXPORT
 void pkpy_vm_bind__f_float__float_int(VM* vm, const char* mod, const char* name, __f_float__float_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__float_float)(VM*, f64, f64);
+typedef f64 (*__f_float__float_float)(f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_float__float_float(VM* vm, const char* mod, const char* name, __f_float__float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__float_str)(VM*, f64, const char*);
+typedef f64 (*__f_float__float_str)(f64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_float__float_str(VM* vm, const char* mod, const char* name, __f_float__float_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__float_bool)(VM*, f64, bool);
+typedef f64 (*__f_float__float_bool)(f64, bool);
 __EXPORT
 void pkpy_vm_bind__f_float__float_bool(VM* vm, const char* mod, const char* name, __f_float__float_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__str_int)(VM*, const char*, i64);
+typedef f64 (*__f_float__str_int)(const char*, i64);
 __EXPORT
 void pkpy_vm_bind__f_float__str_int(VM* vm, const char* mod, const char* name, __f_float__str_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__str_float)(VM*, const char*, f64);
+typedef f64 (*__f_float__str_float)(const char*, f64);
 __EXPORT
 void pkpy_vm_bind__f_float__str_float(VM* vm, const char* mod, const char* name, __f_float__str_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__str_str)(VM*, const char*, const char*);
+typedef f64 (*__f_float__str_str)(const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_float__str_str(VM* vm, const char* mod, const char* name, __f_float__str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__str_bool)(VM*, const char*, bool);
+typedef f64 (*__f_float__str_bool)(const char*, bool);
 __EXPORT
 void pkpy_vm_bind__f_float__str_bool(VM* vm, const char* mod, const char* name, __f_float__str_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__bool_int)(VM*, bool, i64);
+typedef f64 (*__f_float__bool_int)(bool, i64);
 __EXPORT
 void pkpy_vm_bind__f_float__bool_int(VM* vm, const char* mod, const char* name, __f_float__bool_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__bool_float)(VM*, bool, f64);
+typedef f64 (*__f_float__bool_float)(bool, f64);
 __EXPORT
 void pkpy_vm_bind__f_float__bool_float(VM* vm, const char* mod, const char* name, __f_float__bool_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__bool_str)(VM*, bool, const char*);
+typedef f64 (*__f_float__bool_str)(bool, const char*);
 __EXPORT
 void pkpy_vm_bind__f_float__bool_str(VM* vm, const char* mod, const char* name, __f_float__bool_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__bool_bool)(VM*, bool, bool);
+typedef f64 (*__f_float__bool_bool)(bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_float__bool_bool(VM* vm, const char* mod, const char* name, __f_float__bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f64 ret = f(vm, _0, _1);
+        f64 ret = f(_0, _1);
         return vm->PyFloat(ret);
     });
 }
 
-typedef const char* (*__f_str__int_int)(VM*, i64, i64);
+typedef const char* (*__f_str__int_int)(i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_str__int_int(VM* vm, const char* mod, const char* name, __f_str__int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__int_float)(VM*, i64, f64);
+typedef const char* (*__f_str__int_float)(i64, f64);
 __EXPORT
 void pkpy_vm_bind__f_str__int_float(VM* vm, const char* mod, const char* name, __f_str__int_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__int_str)(VM*, i64, const char*);
+typedef const char* (*__f_str__int_str)(i64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_str__int_str(VM* vm, const char* mod, const char* name, __f_str__int_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__int_bool)(VM*, i64, bool);
+typedef const char* (*__f_str__int_bool)(i64, bool);
 __EXPORT
 void pkpy_vm_bind__f_str__int_bool(VM* vm, const char* mod, const char* name, __f_str__int_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__float_int)(VM*, f64, i64);
+typedef const char* (*__f_str__float_int)(f64, i64);
 __EXPORT
 void pkpy_vm_bind__f_str__float_int(VM* vm, const char* mod, const char* name, __f_str__float_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__float_float)(VM*, f64, f64);
+typedef const char* (*__f_str__float_float)(f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_str__float_float(VM* vm, const char* mod, const char* name, __f_str__float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__float_str)(VM*, f64, const char*);
+typedef const char* (*__f_str__float_str)(f64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_str__float_str(VM* vm, const char* mod, const char* name, __f_str__float_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__float_bool)(VM*, f64, bool);
+typedef const char* (*__f_str__float_bool)(f64, bool);
 __EXPORT
 void pkpy_vm_bind__f_str__float_bool(VM* vm, const char* mod, const char* name, __f_str__float_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__str_int)(VM*, const char*, i64);
+typedef const char* (*__f_str__str_int)(const char*, i64);
 __EXPORT
 void pkpy_vm_bind__f_str__str_int(VM* vm, const char* mod, const char* name, __f_str__str_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__str_float)(VM*, const char*, f64);
+typedef const char* (*__f_str__str_float)(const char*, f64);
 __EXPORT
 void pkpy_vm_bind__f_str__str_float(VM* vm, const char* mod, const char* name, __f_str__str_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__str_str)(VM*, const char*, const char*);
+typedef const char* (*__f_str__str_str)(const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_str__str_str(VM* vm, const char* mod, const char* name, __f_str__str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__str_bool)(VM*, const char*, bool);
+typedef const char* (*__f_str__str_bool)(const char*, bool);
 __EXPORT
 void pkpy_vm_bind__f_str__str_bool(VM* vm, const char* mod, const char* name, __f_str__str_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__bool_int)(VM*, bool, i64);
+typedef const char* (*__f_str__bool_int)(bool, i64);
 __EXPORT
 void pkpy_vm_bind__f_str__bool_int(VM* vm, const char* mod, const char* name, __f_str__bool_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__bool_float)(VM*, bool, f64);
+typedef const char* (*__f_str__bool_float)(bool, f64);
 __EXPORT
 void pkpy_vm_bind__f_str__bool_float(VM* vm, const char* mod, const char* name, __f_str__bool_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__bool_str)(VM*, bool, const char*);
+typedef const char* (*__f_str__bool_str)(bool, const char*);
 __EXPORT
 void pkpy_vm_bind__f_str__bool_str(VM* vm, const char* mod, const char* name, __f_str__bool_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__bool_bool)(VM*, bool, bool);
+typedef const char* (*__f_str__bool_bool)(bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_str__bool_bool(VM* vm, const char* mod, const char* name, __f_str__bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        const char* ret = f(vm, _0, _1);
+        const char* ret = f(_0, _1);
         return vm->PyStr(ret);
     });
 }
 
-typedef bool (*__f_bool__int_int)(VM*, i64, i64);
+typedef bool (*__f_bool__int_int)(i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_bool__int_int(VM* vm, const char* mod, const char* name, __f_bool__int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__int_float)(VM*, i64, f64);
+typedef bool (*__f_bool__int_float)(i64, f64);
 __EXPORT
 void pkpy_vm_bind__f_bool__int_float(VM* vm, const char* mod, const char* name, __f_bool__int_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__int_str)(VM*, i64, const char*);
+typedef bool (*__f_bool__int_str)(i64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_bool__int_str(VM* vm, const char* mod, const char* name, __f_bool__int_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__int_bool)(VM*, i64, bool);
+typedef bool (*__f_bool__int_bool)(i64, bool);
 __EXPORT
 void pkpy_vm_bind__f_bool__int_bool(VM* vm, const char* mod, const char* name, __f_bool__int_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__float_int)(VM*, f64, i64);
+typedef bool (*__f_bool__float_int)(f64, i64);
 __EXPORT
 void pkpy_vm_bind__f_bool__float_int(VM* vm, const char* mod, const char* name, __f_bool__float_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__float_float)(VM*, f64, f64);
+typedef bool (*__f_bool__float_float)(f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_bool__float_float(VM* vm, const char* mod, const char* name, __f_bool__float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__float_str)(VM*, f64, const char*);
+typedef bool (*__f_bool__float_str)(f64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_bool__float_str(VM* vm, const char* mod, const char* name, __f_bool__float_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__float_bool)(VM*, f64, bool);
+typedef bool (*__f_bool__float_bool)(f64, bool);
 __EXPORT
 void pkpy_vm_bind__f_bool__float_bool(VM* vm, const char* mod, const char* name, __f_bool__float_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__str_int)(VM*, const char*, i64);
+typedef bool (*__f_bool__str_int)(const char*, i64);
 __EXPORT
 void pkpy_vm_bind__f_bool__str_int(VM* vm, const char* mod, const char* name, __f_bool__str_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__str_float)(VM*, const char*, f64);
+typedef bool (*__f_bool__str_float)(const char*, f64);
 __EXPORT
 void pkpy_vm_bind__f_bool__str_float(VM* vm, const char* mod, const char* name, __f_bool__str_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__str_str)(VM*, const char*, const char*);
+typedef bool (*__f_bool__str_str)(const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_bool__str_str(VM* vm, const char* mod, const char* name, __f_bool__str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__str_bool)(VM*, const char*, bool);
+typedef bool (*__f_bool__str_bool)(const char*, bool);
 __EXPORT
 void pkpy_vm_bind__f_bool__str_bool(VM* vm, const char* mod, const char* name, __f_bool__str_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__bool_int)(VM*, bool, i64);
+typedef bool (*__f_bool__bool_int)(bool, i64);
 __EXPORT
 void pkpy_vm_bind__f_bool__bool_int(VM* vm, const char* mod, const char* name, __f_bool__bool_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__bool_float)(VM*, bool, f64);
+typedef bool (*__f_bool__bool_float)(bool, f64);
 __EXPORT
 void pkpy_vm_bind__f_bool__bool_float(VM* vm, const char* mod, const char* name, __f_bool__bool_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__bool_str)(VM*, bool, const char*);
+typedef bool (*__f_bool__bool_str)(bool, const char*);
 __EXPORT
 void pkpy_vm_bind__f_bool__bool_str(VM* vm, const char* mod, const char* name, __f_bool__bool_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__bool_bool)(VM*, bool, bool);
+typedef bool (*__f_bool__bool_bool)(bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_bool__bool_bool(VM* vm, const char* mod, const char* name, __f_bool__bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        bool ret = f(vm, _0, _1);
+        bool ret = f(_0, _1);
         return vm->PyBool(ret);
     });
 }
 
-typedef void (*__f_None__int_int)(VM*, i64, i64);
+typedef void (*__f_None__int_int)(i64, i64);
 __EXPORT
 void pkpy_vm_bind__f_None__int_int(VM* vm, const char* mod, const char* name, __f_None__int_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__int_float)(VM*, i64, f64);
+typedef void (*__f_None__int_float)(i64, f64);
 __EXPORT
 void pkpy_vm_bind__f_None__int_float(VM* vm, const char* mod, const char* name, __f_None__int_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__int_str)(VM*, i64, const char*);
+typedef void (*__f_None__int_str)(i64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_None__int_str(VM* vm, const char* mod, const char* name, __f_None__int_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__int_bool)(VM*, i64, bool);
+typedef void (*__f_None__int_bool)(i64, bool);
 __EXPORT
 void pkpy_vm_bind__f_None__int_bool(VM* vm, const char* mod, const char* name, __f_None__int_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__float_int)(VM*, f64, i64);
+typedef void (*__f_None__float_int)(f64, i64);
 __EXPORT
 void pkpy_vm_bind__f_None__float_int(VM* vm, const char* mod, const char* name, __f_None__float_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__float_float)(VM*, f64, f64);
+typedef void (*__f_None__float_float)(f64, f64);
 __EXPORT
 void pkpy_vm_bind__f_None__float_float(VM* vm, const char* mod, const char* name, __f_None__float_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__float_str)(VM*, f64, const char*);
+typedef void (*__f_None__float_str)(f64, const char*);
 __EXPORT
 void pkpy_vm_bind__f_None__float_str(VM* vm, const char* mod, const char* name, __f_None__float_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__float_bool)(VM*, f64, bool);
+typedef void (*__f_None__float_bool)(f64, bool);
 __EXPORT
 void pkpy_vm_bind__f_None__float_bool(VM* vm, const char* mod, const char* name, __f_None__float_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__str_int)(VM*, const char*, i64);
+typedef void (*__f_None__str_int)(const char*, i64);
 __EXPORT
 void pkpy_vm_bind__f_None__str_int(VM* vm, const char* mod, const char* name, __f_None__str_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__str_float)(VM*, const char*, f64);
+typedef void (*__f_None__str_float)(const char*, f64);
 __EXPORT
 void pkpy_vm_bind__f_None__str_float(VM* vm, const char* mod, const char* name, __f_None__str_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__str_str)(VM*, const char*, const char*);
+typedef void (*__f_None__str_str)(const char*, const char*);
 __EXPORT
 void pkpy_vm_bind__f_None__str_str(VM* vm, const char* mod, const char* name, __f_None__str_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__str_bool)(VM*, const char*, bool);
+typedef void (*__f_None__str_bool)(const char*, bool);
 __EXPORT
 void pkpy_vm_bind__f_None__str_bool(VM* vm, const char* mod, const char* name, __f_None__str_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__bool_int)(VM*, bool, i64);
+typedef void (*__f_None__bool_int)(bool, i64);
 __EXPORT
 void pkpy_vm_bind__f_None__bool_int(VM* vm, const char* mod, const char* name, __f_None__bool_int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         i64 _1 = vm->PyInt_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__bool_float)(VM*, bool, f64);
+typedef void (*__f_None__bool_float)(bool, f64);
 __EXPORT
 void pkpy_vm_bind__f_None__bool_float(VM* vm, const char* mod, const char* name, __f_None__bool_float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         f64 _1 = vm->PyFloat_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__bool_str)(VM*, bool, const char*);
+typedef void (*__f_None__bool_str)(bool, const char*);
 __EXPORT
 void pkpy_vm_bind__f_None__bool_str(VM* vm, const char* mod, const char* name, __f_None__bool_str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         const char* _1 = vm->PyStr_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__bool_bool)(VM*, bool, bool);
+typedef void (*__f_None__bool_bool)(bool, bool);
 __EXPORT
 void pkpy_vm_bind__f_None__bool_bool(VM* vm, const char* mod, const char* name, __f_None__bool_bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<2>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
         bool _1 = vm->PyBool_AS_C(args[1]);
-        f(vm, _0, _1);
+        f(_0, _1);
         return vm->None;
     });
 }
 
-typedef i64 (*__f_int__int)(VM*, i64);
+typedef i64 (*__f_int__int)(i64);
 __EXPORT
 void pkpy_vm_bind__f_int__int(VM* vm, const char* mod, const char* name, __f_int__int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
-        i64 ret = f(vm, _0);
+        i64 ret = f(_0);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__float)(VM*, f64);
+typedef i64 (*__f_int__float)(f64);
 __EXPORT
 void pkpy_vm_bind__f_int__float(VM* vm, const char* mod, const char* name, __f_int__float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
-        i64 ret = f(vm, _0);
+        i64 ret = f(_0);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__str)(VM*, const char*);
+typedef i64 (*__f_int__str)(const char*);
 __EXPORT
 void pkpy_vm_bind__f_int__str(VM* vm, const char* mod, const char* name, __f_int__str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
-        i64 ret = f(vm, _0);
+        i64 ret = f(_0);
         return vm->PyInt(ret);
     });
 }
 
-typedef i64 (*__f_int__bool)(VM*, bool);
+typedef i64 (*__f_int__bool)(bool);
 __EXPORT
 void pkpy_vm_bind__f_int__bool(VM* vm, const char* mod, const char* name, __f_int__bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
-        i64 ret = f(vm, _0);
+        i64 ret = f(_0);
         return vm->PyInt(ret);
     });
 }
 
-typedef f64 (*__f_float__int)(VM*, i64);
+typedef f64 (*__f_float__int)(i64);
 __EXPORT
 void pkpy_vm_bind__f_float__int(VM* vm, const char* mod, const char* name, __f_float__int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
-        f64 ret = f(vm, _0);
+        f64 ret = f(_0);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__float)(VM*, f64);
+typedef f64 (*__f_float__float)(f64);
 __EXPORT
 void pkpy_vm_bind__f_float__float(VM* vm, const char* mod, const char* name, __f_float__float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
-        f64 ret = f(vm, _0);
+        f64 ret = f(_0);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__str)(VM*, const char*);
+typedef f64 (*__f_float__str)(const char*);
 __EXPORT
 void pkpy_vm_bind__f_float__str(VM* vm, const char* mod, const char* name, __f_float__str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
-        f64 ret = f(vm, _0);
+        f64 ret = f(_0);
         return vm->PyFloat(ret);
     });
 }
 
-typedef f64 (*__f_float__bool)(VM*, bool);
+typedef f64 (*__f_float__bool)(bool);
 __EXPORT
 void pkpy_vm_bind__f_float__bool(VM* vm, const char* mod, const char* name, __f_float__bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
-        f64 ret = f(vm, _0);
+        f64 ret = f(_0);
         return vm->PyFloat(ret);
     });
 }
 
-typedef const char* (*__f_str__int)(VM*, i64);
+typedef const char* (*__f_str__int)(i64);
 __EXPORT
 void pkpy_vm_bind__f_str__int(VM* vm, const char* mod, const char* name, __f_str__int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
-        const char* ret = f(vm, _0);
+        const char* ret = f(_0);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__float)(VM*, f64);
+typedef const char* (*__f_str__float)(f64);
 __EXPORT
 void pkpy_vm_bind__f_str__float(VM* vm, const char* mod, const char* name, __f_str__float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
-        const char* ret = f(vm, _0);
+        const char* ret = f(_0);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__str)(VM*, const char*);
+typedef const char* (*__f_str__str)(const char*);
 __EXPORT
 void pkpy_vm_bind__f_str__str(VM* vm, const char* mod, const char* name, __f_str__str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
-        const char* ret = f(vm, _0);
+        const char* ret = f(_0);
         return vm->PyStr(ret);
     });
 }
 
-typedef const char* (*__f_str__bool)(VM*, bool);
+typedef const char* (*__f_str__bool)(bool);
 __EXPORT
 void pkpy_vm_bind__f_str__bool(VM* vm, const char* mod, const char* name, __f_str__bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
-        const char* ret = f(vm, _0);
+        const char* ret = f(_0);
         return vm->PyStr(ret);
     });
 }
 
-typedef bool (*__f_bool__int)(VM*, i64);
+typedef bool (*__f_bool__int)(i64);
 __EXPORT
 void pkpy_vm_bind__f_bool__int(VM* vm, const char* mod, const char* name, __f_bool__int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
-        bool ret = f(vm, _0);
+        bool ret = f(_0);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__float)(VM*, f64);
+typedef bool (*__f_bool__float)(f64);
 __EXPORT
 void pkpy_vm_bind__f_bool__float(VM* vm, const char* mod, const char* name, __f_bool__float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
-        bool ret = f(vm, _0);
+        bool ret = f(_0);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__str)(VM*, const char*);
+typedef bool (*__f_bool__str)(const char*);
 __EXPORT
 void pkpy_vm_bind__f_bool__str(VM* vm, const char* mod, const char* name, __f_bool__str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
-        bool ret = f(vm, _0);
+        bool ret = f(_0);
         return vm->PyBool(ret);
     });
 }
 
-typedef bool (*__f_bool__bool)(VM*, bool);
+typedef bool (*__f_bool__bool)(bool);
 __EXPORT
 void pkpy_vm_bind__f_bool__bool(VM* vm, const char* mod, const char* name, __f_bool__bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
-        bool ret = f(vm, _0);
+        bool ret = f(_0);
         return vm->PyBool(ret);
     });
 }
 
-typedef void (*__f_None__int)(VM*, i64);
+typedef void (*__f_None__int)(i64);
 __EXPORT
 void pkpy_vm_bind__f_None__int(VM* vm, const char* mod, const char* name, __f_None__int f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         i64 _0 = vm->PyInt_AS_C(args[0]);
-        f(vm, _0);
+        f(_0);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__float)(VM*, f64);
+typedef void (*__f_None__float)(f64);
 __EXPORT
 void pkpy_vm_bind__f_None__float(VM* vm, const char* mod, const char* name, __f_None__float f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         f64 _0 = vm->PyFloat_AS_C(args[0]);
-        f(vm, _0);
+        f(_0);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__str)(VM*, const char*);
+typedef void (*__f_None__str)(const char*);
 __EXPORT
 void pkpy_vm_bind__f_None__str(VM* vm, const char* mod, const char* name, __f_None__str f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         const char* _0 = vm->PyStr_AS_C(args[0]);
-        f(vm, _0);
+        f(_0);
         return vm->None;
     });
 }
 
-typedef void (*__f_None__bool)(VM*, bool);
+typedef void (*__f_None__bool)(bool);
 __EXPORT
 void pkpy_vm_bind__f_None__bool(VM* vm, const char* mod, const char* name, __f_None__bool f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<1>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
         bool _0 = vm->PyBool_AS_C(args[0]);
-        f(vm, _0);
+        f(_0);
         return vm->None;
     });
 }
 
-typedef i64 (*__f_int__)(VM*);
+typedef i64 (*__f_int__)();
 __EXPORT
 void pkpy_vm_bind__f_int__(VM* vm, const char* mod, const char* name, __f_int__ f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<0>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
-        i64 ret = f(vm);
+        i64 ret = f();
         return vm->PyInt(ret);
     });
 }
 
-typedef f64 (*__f_float__)(VM*);
+typedef f64 (*__f_float__)();
 __EXPORT
 void pkpy_vm_bind__f_float__(VM* vm, const char* mod, const char* name, __f_float__ f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<0>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
-        f64 ret = f(vm);
+        f64 ret = f();
         return vm->PyFloat(ret);
     });
 }
 
-typedef const char* (*__f_str__)(VM*);
+typedef const char* (*__f_str__)();
 __EXPORT
 void pkpy_vm_bind__f_str__(VM* vm, const char* mod, const char* name, __f_str__ f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<0>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
-        const char* ret = f(vm);
+        const char* ret = f();
         return vm->PyStr(ret);
     });
 }
 
-typedef bool (*__f_bool__)(VM*);
+typedef bool (*__f_bool__)();
 __EXPORT
 void pkpy_vm_bind__f_bool__(VM* vm, const char* mod, const char* name, __f_bool__ f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<0>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
-        bool ret = f(vm);
+        bool ret = f();
         return vm->PyBool(ret);
     });
 }
 
-typedef void (*__f_None__)(VM*);
+typedef void (*__f_None__)();
 __EXPORT
 void pkpy_vm_bind__f_None__(VM* vm, const char* mod, const char* name, __f_None__ f) {
     PyVar obj = vm->new_module_if_not_existed(mod);
     vm->bindFunc<0>(obj, name, [f](VM* vm, const pkpy::ArgList& args) {
-        f(vm);
+        f();
         return vm->None;
     });
 }

src/main.cpp

@@ -19,7 +19,7 @@ struct Timer{
 
 int main(int argc, char** argv){
     VM* vm = pkpy_new_vm(true);
-    pkpy_vm_bind__f_str__(vm, "builtins", "input", [](VM* vm){
+    pkpy_vm_bind__f_str__(vm, "builtins", "input", [](){
         static std::string line;
         std::getline(std::cin, line);
         return line.c_str();