Initial commit.

App/LearnWithTouch_ios/Libraries/libil2cpp/include/char-conversions.h

@@ -0,0 +1,9 @@
+#pragma once
+
+extern const uint8_t CategoryData_v4[71680];
+extern const uint8_t NumericData[12938];
+extern const double NumericDataValues[58];
+extern const Il2CppChar ToLowerDataLow[9424];
+extern const Il2CppChar ToLowerDataHigh[223];
+extern const Il2CppChar ToUpperDataLow[9450];
+extern const Il2CppChar ToUpperDataHigh[223];

App/LearnWithTouch_ios/Libraries/libil2cpp/include/codegen/il2cpp-codegen-common.h

@@ -0,0 +1,359 @@
+#pragma once
+
+#include "il2cpp-config.h"
+
+#include <cassert>
+#include <cstdlib>
+#include <limits>
+#include <string>
+#include <math.h>
+#include <vector>
+
+#include "il2cpp-object-internals.h"
+#include "il2cpp-class-internals.h"
+#include "il2cpp-tabledefs.h"
+
+#include "gc/GarbageCollector.h"
+#include "vm/PlatformInvoke.h"
+#include "vm/StackTrace.h"
+#include "vm/PlatformInvoke.h"
+#include "vm/StackTrace.h"
+#include "vm-utils/Debugger.h"
+#include "utils/StringUtils.h"
+#include "utils/StringView.h"
+#include "utils/Exception.h"
+#include "utils/Output.h"
+#include "utils/Runtime.h"
+
+REAL_NORETURN IL2CPP_NO_INLINE void il2cpp_codegen_no_return();
+
+#if IL2CPP_COMPILER_MSVC
+#define DEFAULT_CALL STDCALL
+#else
+#define DEFAULT_CALL
+#endif
+
+#if defined(__ARMCC_VERSION)
+inline double bankers_round(double x)
+{
+    return __builtin_round(x);
+}
+
+inline float bankers_roundf(float x)
+{
+    return __builtin_roundf(x);
+}
+
+#else
+inline double bankers_round(double x)
+{
+    double integerPart;
+    if (x >= 0.0)
+    {
+        if (modf(x, &integerPart) == 0.5)
+            return (int64_t)integerPart % 2 == 0 ? integerPart : integerPart + 1.0;
+        return floor(x + 0.5);
+    }
+    else
+    {
+        if (modf(x, &integerPart) == -0.5)
+            return (int64_t)integerPart % 2 == 0 ? integerPart : integerPart - 1.0;
+        return ceil(x - 0.5);
+    }
+}
+
+inline float bankers_roundf(float x)
+{
+    double integerPart;
+    if (x >= 0.0f)
+    {
+        if (modf(x, &integerPart) == 0.5)
+            return (int64_t)integerPart % 2 == 0 ? (float)integerPart : (float)integerPart + 1.0f;
+        return floorf(x + 0.5f);
+    }
+    else
+    {
+        if (modf(x, &integerPart) == -0.5)
+            return (int64_t)integerPart % 2 == 0 ? (float)integerPart : (float)integerPart - 1.0f;
+        return ceilf(x - 0.5f);
+    }
+}
+
+#endif
+
+// returns true if overflow occurs
+inline bool il2cpp_codegen_check_mul_overflow_i64(int64_t a, int64_t b, int64_t imin, int64_t imax)
+{
+    // TODO: use a better algorithm without division
+    uint64_t ua = (uint64_t)llabs(a);
+    uint64_t ub = (uint64_t)llabs(b);
+
+    uint64_t c;
+    if ((a > 0 && b > 0) || (a <= 0 && b <= 0))
+        c = (uint64_t)llabs(imax);
+    else
+        c = (uint64_t)llabs(imin);
+
+    return ua != 0 && ub > c / ua;
+}
+
+inline bool il2cpp_codegen_check_mul_oveflow_u64(uint64_t a, uint64_t b)
+{
+    return b != 0 && (a * b) / b != a;
+}
+
+inline int32_t il2cpp_codegen_abs(uint32_t value)
+{
+    return abs(static_cast<int32_t>(value));
+}
+
+inline int32_t il2cpp_codegen_abs(int32_t value)
+{
+    return abs(value);
+}
+
+inline int64_t il2cpp_codegen_abs(uint64_t value)
+{
+    return llabs(static_cast<int64_t>(value));
+}
+
+inline int64_t il2cpp_codegen_abs(int64_t value)
+{
+    return llabs(value);
+}
+
+// Exception support macros
+#define IL2CPP_LEAVE(Offset, Target) \
+    __leave_target = Offset; \
+    goto Target;
+
+#define IL2CPP_END_FINALLY(Id) \
+    goto __CLEANUP_ ## Id;
+
+#define IL2CPP_CLEANUP(Id) \
+    __CLEANUP_ ## Id:
+
+#define IL2CPP_RETHROW_IF_UNHANDLED(ExcType) \
+    if(__last_unhandled_exception) { \
+        ExcType _tmp_exception_local = __last_unhandled_exception; \
+        __last_unhandled_exception = 0; \
+        il2cpp_codegen_raise_exception(_tmp_exception_local); \
+        }
+
+#define IL2CPP_JUMP_TBL(Offset, Target) \
+    if(__leave_target == Offset) { \
+        __leave_target = 0; \
+        goto Target; \
+        }
+
+#define IL2CPP_END_CLEANUP(Offset, Target) \
+    if(__leave_target == Offset) \
+        goto Target;
+
+
+#if IL2CPP_MONO_DEBUGGER
+#define IL2CPP_RAISE_MANAGED_EXCEPTION(message, seqPoint, lastManagedFrame) \
+    do {\
+        il2cpp_codegen_raise_exception((Exception_t*)message, seqPoint, (MethodInfo*)lastManagedFrame);\
+        il2cpp_codegen_no_return();\
+    } while (0)
+#else
+#define IL2CPP_RAISE_MANAGED_EXCEPTION(message, seqPoint, lastManagedFrame) \
+    do {\
+        il2cpp_codegen_raise_exception((Exception_t*)message, NULL, (MethodInfo*)lastManagedFrame);\
+        il2cpp_codegen_no_return();\
+    } while (0)
+#endif
+
+
+template<typename T>
+inline void Il2CppCodeGenWriteBarrier(T** targetAddress, T* object)
+{
+    il2cpp::gc::GarbageCollector::SetWriteBarrier((void**)targetAddress);
+}
+
+void il2cpp_codegen_memory_barrier();
+
+template<typename T>
+inline T VolatileRead(T* location)
+{
+    T result = *location;
+    il2cpp_codegen_memory_barrier();
+    return result;
+}
+
+template<typename T>
+inline void VolatileWrite(T** location, T* value)
+{
+    il2cpp_codegen_memory_barrier();
+    *location = value;
+    Il2CppCodeGenWriteBarrier(location, value);
+}
+
+template<typename T>
+inline void VolatileWrite(T* location, T value)
+{
+    il2cpp_codegen_memory_barrier();
+    *location = value;
+}
+
+inline void il2cpp_codegen_write_to_stdout(const char* str)
+{
+    il2cpp::utils::Output::WriteToStdout(str);
+}
+
+inline void il2cpp_codegen_write_to_stderr(const char* str)
+{
+    il2cpp::utils::Output::WriteToStderr(str);
+}
+
+inline REAL_NORETURN void il2cpp_codegen_abort()
+{
+    il2cpp::utils::Runtime::Abort();
+    il2cpp_codegen_no_return();
+}
+
+inline bool il2cpp_codegen_check_add_overflow(int64_t left, int64_t right)
+{
+    return (right >= 0 && left > kIl2CppInt64Max - right) ||
+        (left < 0 && right < kIl2CppInt64Min - left);
+}
+
+inline bool il2cpp_codegen_check_sub_overflow(int64_t left, int64_t right)
+{
+    return (right >= 0 && left < kIl2CppInt64Min + right) ||
+        (right < 0 && left > kIl2CppInt64Max + right);
+}
+
+template<bool, class T, class U>
+struct pick_first;
+
+template<class T, class U>
+struct pick_first<true, T, U>
+{
+    typedef T type;
+};
+
+template<class T, class U>
+struct pick_first<false, T, U>
+{
+    typedef U type;
+};
+
+template<class T, class U>
+struct pick_bigger
+{
+    typedef typename pick_first<(sizeof(T) >= sizeof(U)), T, U>::type type;
+};
+
+template<typename T, typename U>
+inline typename pick_bigger<T, U>::type il2cpp_codegen_multiply(T left, U right)
+{
+    return left * right;
+}
+
+template<typename T, typename U>
+inline typename pick_bigger<T, U>::type il2cpp_codegen_add(T left, U right)
+{
+    return left + right;
+}
+
+template<typename T, typename U>
+inline typename pick_bigger<T, U>::type il2cpp_codegen_subtract(T left, U right)
+{
+    return left - right;
+}
+
+inline void il2cpp_codegen_memcpy(void* dest, const void* src, size_t count)
+{
+    memcpy(dest, src, count);
+}
+
+inline void il2cpp_codegen_memset(void* ptr, int value, size_t num)
+{
+    memset(ptr, value, num);
+}
+
+#if IL2CPP_MONO_DEBUGGER
+extern volatile uint32_t g_Il2CppDebuggerCheckPointEnabled;
+#endif
+
+inline void il2cpp_codegen_register_debugger_data(const Il2CppDebuggerMetadataRegistration *data)
+{
+#if IL2CPP_MONO_DEBUGGER
+    il2cpp::utils::Debugger::RegisterSequencePointCheck(&g_Il2CppDebuggerCheckPointEnabled);
+    il2cpp::utils::Debugger::RegisterMetadata(data);
+#endif
+}
+
+inline void il2cpp_codegen_check_sequence_point(Il2CppSequencePointExecutionContext* executionContext, size_t seqPointId)
+{
+#if IL2CPP_MONO_DEBUGGER
+    if (g_Il2CppDebuggerCheckPointEnabled)
+        il2cpp::utils::Debugger::CheckSequencePoint(executionContext, seqPointId);
+#endif
+}
+
+inline void il2cpp_codegen_check_pause_point()
+{
+#if IL2CPP_MONO_DEBUGGER
+    if (g_Il2CppDebuggerCheckPointEnabled)
+        il2cpp::utils::Debugger::CheckPausePoint();
+#endif
+}
+
+inline Il2CppSequencePoint* il2cpp_codegen_get_sequence_point(size_t id)
+{
+#if IL2CPP_MONO_DEBUGGER
+    return il2cpp::utils::Debugger::GetSequencePoint(id);
+#else
+    return NULL;
+#endif
+}
+
+class MethodExitSequencePointChecker
+{
+private:
+    size_t m_pSeqPoint;
+    Il2CppSequencePointExecutionContext* m_seqPointStorage;
+
+public:
+    MethodExitSequencePointChecker(Il2CppSequencePointExecutionContext* seqPointStorage, size_t seqPointId) :
+        m_seqPointStorage(seqPointStorage), m_pSeqPoint(seqPointId)
+    {
+    }
+
+    ~MethodExitSequencePointChecker()
+    {
+#if IL2CPP_MONO_DEBUGGER
+        il2cpp_codegen_check_sequence_point(m_seqPointStorage, m_pSeqPoint);
+#endif
+    }
+};
+
+#ifdef _MSC_VER
+#define IL2CPP_DISABLE_OPTIMIZATIONS __pragma(optimize("", off))
+#define IL2CPP_ENABLE_OPTIMIZATIONS __pragma(optimize("", on))
+#else
+#define IL2CPP_DISABLE_OPTIMIZATIONS __attribute__ ((optnone))
+#define IL2CPP_ENABLE_OPTIMIZATIONS
+#endif
+
+// NativeArray macros
+#define IL2CPP_NATIVEARRAY_GET_ITEM(TElementType, TTField, TIndex) \
+    *(reinterpret_cast<TElementType*>(TTField) + TIndex)
+
+#define IL2CPP_NATIVEARRAY_SET_ITEM(TElementType, TTField, TIndex, TValue) \
+   *(reinterpret_cast<TElementType*>(TTField) + TIndex) = TValue;
+
+#define IL2CPP_NATIVEARRAY_GET_LENGTH(TLengthField) \
+   (TLengthField)
+
+// Array Unsafe
+#define IL2CPP_ARRAY_UNSAFE_LOAD(TArray, TIndex) \
+    (TArray)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(TIndex))
+
+inline bool il2cpp_codegen_object_reference_equals(const RuntimeObject *obj1, const RuntimeObject *obj2)
+{
+    return obj1 == obj2;
+}

App/LearnWithTouch_ios/Libraries/libil2cpp/include/codegen/il2cpp-codegen-mono.h

@@ -0,0 +1,995 @@
+#pragma once
+
+#include "il2cpp-codegen-common.h"
+#include "il2cpp-mono-support.h"
+#include "mono-api.h"
+
+struct ProfilerMethodSentry
+{
+    ProfilerMethodSentry(const RuntimeMethod* method)
+#if IL2CPP_ENABLE_PROFILER
+        : m_method(method)
+#endif
+    {
+        IL2CPP_NOT_IMPLEMENTED("Unity profiler hooks are not implemented yet for the libmonoruntime backend.");
+    }
+
+    ~ProfilerMethodSentry()
+    {
+        IL2CPP_NOT_IMPLEMENTED("Unity profiler hooks are not implemented yet for the libmonoruntime backend.");
+    }
+
+private:
+    const RuntimeMethod* m_method;
+};
+
+struct StackTraceSentry
+{
+    StackTraceSentry(RuntimeMethod* method) : m_method(method)
+    {
+        MonoStackFrameInfo frame_info;
+
+        frame_info.method = method;
+        frame_info.actual_method = method;
+        frame_info.type = FRAME_TYPE_MANAGED;
+        frame_info.managed = 1;
+        frame_info.il_offset = 0;
+        frame_info.native_offset = 0;
+        frame_info.ji = (MonoJitInfo*)(void*)-1;
+
+        mono::vm::StackTrace::PushFrame(frame_info);
+    }
+
+    ~StackTraceSentry()
+    {
+        mono::vm::StackTrace::PopFrame();
+    }
+
+private:
+    const RuntimeMethod* m_method;
+};
+
+#define IL2CPP_FAKE_BOX_SENTRY (MonoThreadsSync*)UINTPTR_MAX
+
+template<typename T>
+struct Il2CppFakeBox : RuntimeObject
+{
+    T m_Value;
+
+    Il2CppFakeBox(RuntimeClass* boxedType, T* value)
+    {
+        vtable = il2cpp_mono_class_vtable(g_MonoDomain, boxedType);
+        synchronisation = IL2CPP_FAKE_BOX_SENTRY;
+        m_Value = *value;
+    }
+};
+
+inline bool il2cpp_codegen_is_fake_boxed_object(RuntimeObject* object)
+{
+    return object->synchronisation == IL2CPP_FAKE_BOX_SENTRY;
+}
+
+// TODO: This file should contain all the functions and type declarations needed for the generated code.
+// Hopefully, we stop including everything in the generated code and know exactly what dependencies we have.
+// Note that all parameter and return types should match the generated types not the runtime types.
+
+// type registration
+
+inline String_t* il2cpp_codegen_string_new_utf16(const il2cpp::utils::StringView<Il2CppChar>& str)
+{
+    return (String_t*)mono_string_new_utf16(g_MonoDomain, (const mono_unichar2*)str.Str(), (int32_t)str.Length());
+}
+
+inline NORETURN void il2cpp_codegen_raise_exception(Exception_t *ex, Il2CppSequencePoint *seqPoint = NULL, MethodInfo* lastManagedFrame = NULL)
+{
+    mono_raise_exception((RuntimeException*)ex);
+    il2cpp_codegen_no_return();
+}
+
+inline void il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(const RuntimeMethod* method)
+{
+    il2cpp_mono_raise_execution_engine_exception_if_method_is_not_found(const_cast<RuntimeMethod*>(method));
+}
+
+inline void il2cpp_codegen_raise_execution_engine_exception(const RuntimeMethod* method)
+{
+    mono_raise_exception(mono_get_exception_execution_engine(mono_unity_method_get_name(method)));
+}
+
+inline Exception_t* il2cpp_codegen_get_argument_exception(const char* param, const char* msg)
+{
+    return (Exception_t*)mono_get_exception_argument(param, msg);
+}
+
+inline Exception_t* il2cpp_codegen_get_argument_null_exception(const char* param)
+{
+    return (Exception_t*)mono_get_exception_argument_null(param);
+}
+
+inline Exception_t* il2cpp_codegen_get_overflow_exception()
+{
+    return (Exception_t*)mono_get_exception_overflow();
+}
+
+inline Exception_t* il2cpp_codegen_get_not_supported_exception(const char* msg)
+{
+    return (Exception_t*)mono_get_exception_not_supported(msg);
+}
+
+inline Exception_t* il2cpp_codegen_get_array_type_mismatch_exception()
+{
+    return (Exception_t*)mono_get_exception_array_type_mismatch();
+}
+
+inline Exception_t* il2cpp_codegen_get_invalid_operation_exception(const char* msg)
+{
+    return (Exception_t*)mono_get_exception_invalid_operation(msg);
+}
+
+inline Exception_t* il2cpp_codegen_get_marshal_directive_exception(const char* msg)
+{
+    return (Exception_t*)mono_unity_exception_get_marshal_directive(msg);
+}
+
+inline Exception_t* il2cpp_codegen_get_missing_method_exception(const char* msg)
+{
+    return (Exception_t*)mono_get_exception_missing_method(msg, "ctor");
+}
+
+inline Exception_t* il2cpp_codegen_get_maximum_nested_generics_exception()
+{
+    return (Exception_t*)mono_get_exception_not_supported(MAXIMUM_NESTED_GENERICS_EXCEPTION_MESSAGE);
+}
+
+inline RuntimeClass* il2cpp_codegen_object_class(RuntimeObject* obj)
+{
+    return mono_object_get_class(obj);
+}
+
+// OpCode.IsInst
+
+inline RuntimeObject* IsInst(RuntimeObject *obj, RuntimeClass* targetType)
+{
+    return mono_object_isinst(obj, targetType);
+}
+
+inline RuntimeObject* IsInstSealed(RuntimeObject *obj, RuntimeClass* targetType)
+{
+    if (!obj)
+        return NULL;
+
+    // optimized version to compare sealed classes
+    return mono_unity_object_isinst_sealed(obj, targetType);
+}
+
+inline RuntimeObject* IsInstClass(RuntimeObject *obj, RuntimeClass* targetType)
+{
+    if (!obj)
+        return NULL;
+
+    return mono_unity_class_has_parent_unsafe(mono_object_get_class(obj), targetType) ? obj : NULL;
+}
+
+// OpCode.Castclass
+
+inline RuntimeObject* Castclass(RuntimeObject *obj, RuntimeClass* targetType)
+{
+    if (!obj)
+        return NULL;
+
+    RuntimeObject* result = mono_object_isinst(obj, targetType);
+    if (result)
+        return result;
+
+    mono_raise_exception(mono_get_exception_invalid_cast());
+    return NULL;
+}
+
+inline RuntimeObject* CastclassSealed(RuntimeObject *obj, RuntimeClass* targetType)
+{
+    if (!obj)
+        return NULL;
+
+    RuntimeObject* result = IsInstSealed(obj, targetType);
+    if (result)
+        return result;
+
+    mono_raise_exception(mono_get_exception_invalid_cast());
+    return NULL;
+}
+
+inline RuntimeObject* CastclassClass(RuntimeObject *obj, RuntimeClass* targetType)
+{
+    if (!obj)
+        return NULL;
+
+    RuntimeObject* result = IsInstClass(obj, targetType);
+    if (result)
+        return result;
+
+    mono_raise_exception(mono_get_exception_invalid_cast());
+    return NULL;
+}
+
+// OpCode.Box
+
+inline RuntimeObject* Box(RuntimeClass* type, void* data)
+{
+    return mono_value_box(g_MonoDomain, type, data);
+}
+
+// OpCode.UnBox
+
+inline void* UnBox(RuntimeObject* obj)
+{
+    if (!obj)
+    {
+        mono_raise_exception(mono_get_exception_null_reference());
+        il2cpp_codegen_no_return();
+    }
+
+    return mono_object_unbox(obj);
+}
+
+inline void* UnBox(RuntimeObject* obj, RuntimeClass* klass)
+{
+    if (!obj)
+    {
+        mono_raise_exception(mono_get_exception_null_reference());
+        il2cpp_codegen_no_return();
+    }
+
+    if (!mono_unity_object_check_box_cast(obj, klass))
+    {
+        mono_raise_exception(mono_get_exception_invalid_cast());
+        il2cpp_codegen_no_return();
+    }
+
+    return mono_object_unbox(obj);
+}
+
+inline void UnBoxNullable(RuntimeObject* obj, RuntimeClass* klass, void* storage)
+{
+    mono_unity_object_unbox_nullable(obj, klass, storage);
+}
+
+inline uint32_t il2cpp_codegen_sizeof(RuntimeClass* klass)
+{
+    if (!mono_class_is_valuetype(klass))
+        return sizeof(void*);
+
+    return mono_class_instance_size(klass) - sizeof(RuntimeObject);
+}
+
+inline bool il2cpp_codegen_method_is_virtual(RuntimeMethod* method)
+{
+    return method->slot != -1;
+}
+
+inline bool il2cpp_codegen_object_is_of_sealed_type(RuntimeObject* obj)
+{
+    return obj != NULL && mono_class_is_sealed(mono_object_get_class(obj));
+}
+
+inline bool il2cpp_codegen_method_is_generic_instance(RuntimeMethod* method)
+{
+    return unity_mono_method_is_generic(method);
+}
+
+inline bool il2cpp_codegen_method_is_interface_method(RuntimeMethod* method)
+{
+    return MONO_CLASS_IS_INTERFACE(mono_method_get_class(method));
+}
+
+inline uint16_t il2cpp_codegen_method_get_slot(RuntimeMethod* method)
+{
+    return method->slot;
+}
+
+inline RuntimeClass* il2cpp_codegen_method_get_declaring_type(RuntimeMethod* method)
+{
+    return mono_method_get_class(method);
+}
+
+FORCE_INLINE const VirtualInvokeData il2cpp_codegen_get_virtual_invoke_data(RuntimeMethod* method, void* obj)
+{
+    VirtualInvokeData invokeData;
+    il2cpp_mono_get_virtual_invoke_data(method, obj, &invokeData);
+    return invokeData;
+}
+
+FORCE_INLINE const VirtualInvokeData il2cpp_codegen_get_interface_invoke_data(RuntimeMethod* method, void* obj, RuntimeClass* declaringInterface)
+{
+    VirtualInvokeData invokeData;
+    il2cpp_mono_get_interface_invoke_data(method, obj, &invokeData);
+    return invokeData;
+}
+
+FORCE_INLINE const RuntimeMethod* il2cpp_codegen_get_generic_virtual_method(const RuntimeMethod* method, const RuntimeObject* obj)
+{
+    return il2cpp_mono_get_virtual_target_method(const_cast<RuntimeMethod*>(method), const_cast<RuntimeObject*>(obj));
+}
+
+FORCE_INLINE void il2cpp_codegen_get_generic_virtual_invoke_data(const RuntimeMethod* method, void* obj, VirtualInvokeData* invokeData)
+{
+    il2cpp_mono_get_invoke_data(const_cast<RuntimeMethod*>(method), obj, invokeData);
+}
+
+FORCE_INLINE const RuntimeMethod* il2cpp_codegen_get_generic_interface_method(const RuntimeMethod* method, const RuntimeObject* obj)
+{
+    return il2cpp_mono_get_virtual_target_method(const_cast<RuntimeMethod*>(method), const_cast<RuntimeObject*>(obj));
+}
+
+FORCE_INLINE void il2cpp_codegen_get_generic_interface_invoke_data(RuntimeMethod* method, void* obj, VirtualInvokeData* invokeData)
+{
+    il2cpp_mono_get_invoke_data(method, obj, invokeData);
+}
+
+FORCE_INLINE void il2cpp_codegen_get_generic_interface_invoke_data(const RuntimeMethod* method, void* obj, VirtualInvokeData* invokeData)
+{
+    il2cpp_codegen_get_generic_interface_invoke_data(const_cast<RuntimeMethod*>(method), obj, invokeData);
+}
+
+// OpCode.Ldtoken
+
+inline RuntimeClass* il2cpp_codegen_class_from_type(RuntimeType* type)
+{
+    return mono_class_from_mono_type(type);
+}
+
+inline RuntimeClass* il2cpp_codegen_class_from_type(const RuntimeType *type)
+{
+    return il2cpp_codegen_class_from_type(const_cast<RuntimeType*>(type));
+}
+
+template<typename T>
+inline T InterlockedCompareExchangeImpl(T* location, T value, T comparand)
+{
+    return (T)mono_unity_object_compare_exchange((RuntimeObject**)location, (RuntimeObject*)value, (RuntimeObject*)comparand);
+}
+
+template<typename T>
+inline T InterlockedExchangeImpl(T* location, T value)
+{
+    return (T)mono_unity_object_exchange((RuntimeObject**)location, (RuntimeObject*)value);
+}
+
+inline void ArrayGetGenericValueImpl(RuntimeArray* __this, int32_t pos, void* value)
+{
+    int elementSize = mono_unity_array_get_element_size(__this);
+    memcpy(value, mono_array_addr_with_size(__this, elementSize, pos), elementSize);
+}
+
+inline void ArraySetGenericValueImpl(RuntimeArray * __this, int32_t pos, void* value)
+{
+    int elementSize = mono_unity_array_get_element_size(__this);
+    memcpy(mono_array_addr_with_size(__this, elementSize, pos), value, elementSize);
+}
+
+inline RuntimeArray* SZArrayNew(RuntimeClass* arrayType, uint32_t length)
+{
+    mono_class_init(arrayType);
+
+    MonoError error;
+    RuntimeArray *retVal = mono_array_new_specific_checked(il2cpp_mono_class_vtable(g_MonoDomain, arrayType), length, &error);
+    RuntimeException *exc = mono_error_convert_to_exception(&error);
+    if (exc)
+        mono_raise_exception(exc);
+
+    return retVal;
+}
+
+inline RuntimeArray* GenArrayNew(RuntimeClass* arrayType, il2cpp_array_size_t* dimensions)
+{
+    MonoError error;
+    RuntimeArray *retVal = mono_array_new_full_checked(g_MonoDomain, arrayType, dimensions, NULL, &error);
+    RuntimeException *exc = mono_error_convert_to_exception(&error);
+    if (exc)
+        mono_raise_exception(exc);
+
+    return retVal;
+}
+
+// Performance optimization as detailed here: http://blogs.msdn.com/b/clrcodegeneration/archive/2009/08/13/array-bounds-check-elimination-in-the-clr.aspx
+// Since array size is a signed int32_t, a single unsigned check can be performed to determine if index is less than array size.
+// Negative indices will map to a unsigned number greater than or equal to 2^31 which is larger than allowed for a valid array.
+#define IL2CPP_ARRAY_BOUNDS_CHECK(index, length) \
+    do { \
+        if (((uint32_t)(index)) >= ((uint32_t)length)) mono_raise_exception(mono_get_exception_index_out_of_range()); \
+    } while (0)
+
+inline bool il2cpp_codegen_class_is_assignable_from(RuntimeClass *klass, RuntimeClass *oklass)
+{
+    return mono_class_is_assignable_from(klass, oklass);
+}
+
+inline RuntimeObject* il2cpp_codegen_object_new(RuntimeClass *klass)
+{
+    return mono_object_new(g_MonoDomain, klass);
+}
+
+inline Il2CppMethodPointer il2cpp_codegen_resolve_icall(const RuntimeMethod* icallMethod)
+{
+    return (Il2CppMethodPointer)mono_lookup_internal_call(const_cast<RuntimeMethod*>(icallMethod));
+}
+
+template<typename FunctionPointerType>
+inline FunctionPointerType il2cpp_codegen_resolve_pinvoke(const RuntimeMethod* pinvokeMethod)
+{
+    const char *exc_class, *exc_arg;
+    FunctionPointerType result = reinterpret_cast<FunctionPointerType>(mono_lookup_pinvoke_call(const_cast<RuntimeMethod*>(pinvokeMethod), &exc_class, &exc_arg));
+    if (exc_class)
+    {
+        mono_raise_exception(mono_exception_from_name_msg(mono_unity_image_get_mscorlib(), "System", exc_class, exc_arg));
+        il2cpp_codegen_no_return();
+    }
+
+    return result;
+}
+
+template<typename T>
+inline T* il2cpp_codegen_marshal_allocate_array(size_t length)
+{
+    MonoError unused;
+    return (T*)mono_marshal_alloc((il2cpp_array_size_t)(sizeof(T) * length), &unused);
+}
+
+template<typename T>
+inline T* il2cpp_codegen_marshal_allocate()
+{
+    MonoError unused;
+    return (T*)mono_marshal_alloc(sizeof(T), &unused);
+}
+
+inline char* il2cpp_codegen_marshal_string(String_t* string)
+{
+    return mono::vm::PlatformInvoke::MarshalCSharpStringToCppString((RuntimeString*)string);
+}
+
+inline void il2cpp_codegen_marshal_string_fixed(String_t* string, char* buffer, int numberOfCharacters)
+{
+    return mono::vm::PlatformInvoke::MarshalCSharpStringToCppStringFixed((RuntimeString*)string, buffer, numberOfCharacters);
+}
+
+inline Il2CppChar* il2cpp_codegen_marshal_wstring(String_t* string)
+{
+    return (Il2CppChar*)mono::vm::PlatformInvoke::MarshalCSharpStringToCppWString((RuntimeString*)string);
+}
+
+inline void il2cpp_codegen_marshal_wstring_fixed(String_t* string, Il2CppChar* buffer, int numberOfCharacters)
+{
+    return mono::vm::PlatformInvoke::MarshalCSharpStringToCppWStringFixed((RuntimeString*)string, (mono_unichar2*)buffer, numberOfCharacters);
+}
+
+inline Il2CppChar* il2cpp_codegen_marshal_bstring(String_t* string)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+inline String_t* il2cpp_codegen_marshal_string_result(const char* value)
+{
+    return (String_t*)mono::vm::PlatformInvoke::MarshalCppStringToCSharpStringResult(value);
+}
+
+inline String_t* il2cpp_codegen_marshal_wstring_result(const Il2CppChar* value)
+{
+    return (String_t*)mono::vm::PlatformInvoke::MarshalCppWStringToCSharpStringResult((const mono_unichar2*)value);
+}
+
+inline String_t* il2cpp_codegen_marshal_bstring_result(const Il2CppChar* value)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+inline void il2cpp_codegen_marshal_free_bstring(Il2CppChar* value)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+}
+
+inline char* il2cpp_codegen_marshal_string_builder(StringBuilder_t* stringBuilder)
+{
+    return mono::vm::PlatformInvoke::MarshalStringBuilder((RuntimeStringBuilder*)stringBuilder);
+}
+
+inline Il2CppChar* il2cpp_codegen_marshal_wstring_builder(StringBuilder_t* stringBuilder)
+{
+    return (Il2CppChar*)mono::vm::PlatformInvoke::MarshalWStringBuilder((RuntimeStringBuilder*)stringBuilder);
+}
+
+inline void il2cpp_codegen_marshal_string_builder_result(StringBuilder_t* stringBuilder, char* buffer)
+{
+    mono::vm::PlatformInvoke::MarshalStringBuilderResult((RuntimeStringBuilder*)stringBuilder, buffer);
+}
+
+inline void il2cpp_codegen_marshal_wstring_builder_result(StringBuilder_t* stringBuilder, Il2CppChar* buffer)
+{
+    mono::vm::PlatformInvoke::MarshalWStringBuilderResult((RuntimeStringBuilder*)stringBuilder, (mono_unichar2*)buffer);
+}
+
+inline Il2CppHString il2cpp_codegen_create_hstring(String_t* str)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+inline String_t* il2cpp_codegen_marshal_hstring_result(Il2CppHString hstring)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+inline void il2cpp_codegen_marshal_free_hstring(Il2CppHString hstring)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+}
+
+inline void il2cpp_codegen_marshal_free(void* ptr)
+{
+    mono_marshal_free(ptr);
+}
+
+inline Il2CppMethodPointer il2cpp_codegen_marshal_delegate(MulticastDelegate_t* d)
+{
+    return (Il2CppMethodPointer)mono::vm::PlatformInvoke::MarshalDelegate((RuntimeDelegate*)d);
+}
+
+template<typename T>
+inline T* il2cpp_codegen_marshal_function_ptr_to_delegate(Il2CppMethodPointer functionPtr, RuntimeClass* delegateType)
+{
+    return (T*)mono::vm::PlatformInvoke::MarshalFunctionPointerToDelegate(reinterpret_cast<void*>(functionPtr), delegateType);
+}
+
+inline void il2cpp_codegen_marshal_store_last_error()
+{
+    mono_marshal_set_last_error();
+}
+
+namespace il2cpp
+{
+namespace vm
+{
+    class ScopedThreadAttacher
+    {
+    public:
+        ScopedThreadAttacher() :
+            _threadWasAttached(false)
+        {
+            if (!mono_thread_is_attached())
+            {
+                mono_thread_attach(mono_get_root_domain());
+                _threadWasAttached = true;
+            }
+        }
+
+        ~ScopedThreadAttacher()
+        {
+            if (_threadWasAttached)
+                mono_thread_detach(mono_thread_current());
+        }
+
+    private:
+        bool _threadWasAttached;
+
+        bool mono_thread_is_attached()
+        {
+            return mono_domain_get() != NULL;
+        }
+    };
+}
+}
+
+#if _DEBUG
+struct ScopedMarshallingAllocationCheck
+{
+};
+
+struct ScopedMarshalingAllocationClearer
+{
+};
+#endif
+
+inline void NullCheck(void* this_ptr)
+{
+    if (this_ptr != NULL)
+        return;
+
+    mono_raise_exception(mono_get_exception_null_reference());
+}
+
+inline void DivideByZeroCheck(int64_t denominator)
+{
+    if (denominator != 0)
+        return;
+
+    mono_raise_exception(mono_get_exception_divide_by_zero());
+}
+
+inline void il2cpp_codegen_initobj(void* value, size_t size)
+{
+    memset(value, 0, size);
+}
+
+inline bool MethodIsStatic(const RuntimeMethod* method)
+{
+    return mono_unity_method_is_static(const_cast<RuntimeMethod*>(method));
+}
+
+inline bool MethodHasParameters(const RuntimeMethod* method)
+{
+    return mono_signature_get_param_count(mono_method_signature(const_cast<RuntimeMethod*>(method))) != 0;
+}
+
+//#define IL2CPP_RUNTIME_CLASS_INIT(klass) do { if((klass)->has_cctor && !(klass)->cctor_finished) il2cpp::vm::Runtime::ClassInit ((klass)); } while (0)
+#define IL2CPP_RUNTIME_CLASS_INIT(klass) RuntimeInit(klass)
+
+inline void* il2cpp_codegen_mono_class_rgctx(RuntimeClass* klass, Il2CppRGCTXDataType rgctxType, int rgctxIndex, bool useSharedVersion)
+{
+    return il2cpp_mono_class_rgctx(klass, rgctxType, rgctxIndex, useSharedVersion);
+}
+
+inline void* il2cpp_codegen_mono_method_rgctx(RuntimeMethod* method, Il2CppRGCTXDataType rgctxType, int rgctxIndex, bool useSharedVersion)
+{
+    return il2cpp_mono_method_rgctx(method, rgctxType, rgctxIndex, useSharedVersion);
+}
+
+inline void ArrayElementTypeCheck(RuntimeArray* array, void* value)
+{
+    if (!value)
+        return;
+
+    RuntimeClass *aclass = mono_unity_array_get_class(array);
+    RuntimeClass *eclass = mono_unity_class_get_element_class(aclass);
+    RuntimeClass *oclass = mono_unity_object_get_class((RuntimeObject*)value);
+
+    if (!mono_class_is_assignable_from(eclass, oclass))
+        mono_raise_exception(mono_get_exception_array_type_mismatch());
+}
+
+inline const RuntimeMethod* GetVirtualMethodInfo(RuntimeObject* pThis, const RuntimeMethod* method)
+{
+    if (!pThis)
+        mono_raise_exception(mono_get_exception_null_reference());
+
+    return mono_object_get_virtual_method(pThis, const_cast<RuntimeMethod*>(method));
+}
+
+inline const RuntimeMethod* GetInterfaceMethodInfo(RuntimeObject* pThis, RuntimeMethod *slot, RuntimeClass* declaringInterface)
+{
+    if (!pThis)
+        mono_raise_exception(mono_get_exception_null_reference());
+
+    return mono_object_get_virtual_method(pThis, slot);
+}
+
+inline void il2cpp_codegen_memory_barrier()
+{
+    mono_unity_memory_barrier();
+}
+
+inline void il2cpp_codegen_initialize_method(uint32_t index)
+{
+    il2cpp_mono_initialize_method_metadata(index);
+}
+
+inline bool il2cpp_codegen_type_implements_virtual_method(RuntimeClass* type, RuntimeMethod *slot)
+{
+    return mono_unity_method_get_class(slot) == type;
+}
+
+inline MethodBase_t* il2cpp_codegen_get_method_object(const RuntimeMethod* method)
+{
+    if (unity_mono_method_is_inflated(const_cast<RuntimeMethod*>(method)))
+        method = mono_unity_method_get_generic_definition(const_cast<RuntimeMethod*>(method));
+
+    return (MethodBase_t*)mono_unity_method_get_object(const_cast<RuntimeMethod*>(method));
+}
+
+inline Type_t* il2cpp_codegen_get_type(Il2CppMethodPointer getTypeFunction, String_t* typeName, const char* assemblyName)
+{
+    typedef Type_t* (*getTypeFuncType)(String_t*, const RuntimeMethod*);
+    MonoString* assemblyQualifiedTypeName = mono_unity_string_append_assembly_name_if_necessary((MonoString*)typeName, assemblyName);
+
+    // Try to find the type using a hint about about calling assembly. If it is not found, fall back to calling GetType without the hint.
+    Type_t* type = ((getTypeFuncType)getTypeFunction)((String_t*)assemblyQualifiedTypeName, NULL);
+    if (type == NULL)
+        return ((getTypeFuncType)getTypeFunction)(typeName, NULL);
+    return type;
+}
+
+inline Type_t* il2cpp_codegen_get_type(Il2CppMethodPointer getTypeFunction, String_t* typeName, bool throwOnError, const char* assemblyName)
+{
+    typedef Type_t* (*getTypeFuncType)(String_t*, bool, const RuntimeMethod*);
+    MonoString* assemblyQualifiedTypeName = mono_unity_string_append_assembly_name_if_necessary((MonoString*)typeName, assemblyName);
+
+    // Try to find the type using a hint about about calling assembly. If it is not found, fall back to calling GetType without the hint.
+    Type_t* type = ((getTypeFuncType)getTypeFunction)((String_t*)assemblyQualifiedTypeName, throwOnError, NULL);
+    if (type == NULL)
+        return ((getTypeFuncType)getTypeFunction)(typeName, throwOnError, NULL);
+    return type;
+}
+
+inline Type_t* il2cpp_codegen_get_type(Il2CppMethodPointer getTypeFunction, String_t* typeName, bool throwOnError, bool ignoreCase, const char* assemblyName)
+{
+    typedef Type_t* (*getTypeFuncType)(String_t*, bool, bool, const RuntimeMethod*);
+    MonoString* assemblyQualifiedTypeName = mono_unity_string_append_assembly_name_if_necessary((MonoString*)typeName, assemblyName);
+
+    // Try to find the type using a hint about about calling assembly. If it is not found, fall back to calling GetType without the hint.
+    Type_t* type = ((getTypeFuncType)getTypeFunction)((String_t*)assemblyQualifiedTypeName, throwOnError, ignoreCase, NULL);
+    if (type == NULL)
+        return ((getTypeFuncType)getTypeFunction)(typeName, throwOnError, ignoreCase, NULL);
+    return type;
+}
+
+inline Assembly_t* il2cpp_codegen_get_executing_assembly(const RuntimeMethod* method)
+{
+    return (Assembly_t*)mono_assembly_get_object(g_MonoDomain, mono_unity_class_get_assembly(mono_unity_method_get_class(method)));
+}
+
+// Atomic
+
+inline void* il2cpp_codegen_atomic_compare_exchange_pointer(void* volatile* dest, void* exchange, void* comparand)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+template<typename T>
+inline T* il2cpp_codegen_atomic_compare_exchange_pointer(T* volatile* dest, T* newValue, T* oldValue)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+// COM
+
+inline void il2cpp_codegen_com_marshal_variant(RuntimeObject* obj, Il2CppVariant* variant)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+}
+
+inline RuntimeObject* il2cpp_codegen_com_marshal_variant_result(Il2CppVariant* variant)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+inline void il2cpp_codegen_com_destroy_variant(Il2CppVariant* variant)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+}
+
+inline Il2CppSafeArray* il2cpp_codegen_com_marshal_safe_array(Il2CppChar type, RuntimeArray* managedArray)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+inline RuntimeArray* il2cpp_codegen_com_marshal_safe_array_result(Il2CppChar variantType, RuntimeClass* type, Il2CppSafeArray* safeArray)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+inline Il2CppSafeArray* il2cpp_codegen_com_marshal_safe_array_bstring(RuntimeArray* managedArray)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+inline RuntimeArray* il2cpp_codegen_com_marshal_safe_array_bstring_result(RuntimeClass* type, Il2CppSafeArray* safeArray)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+inline void il2cpp_codegen_com_destroy_safe_array(Il2CppSafeArray* safeArray)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+}
+
+inline void il2cpp_codegen_com_create_instance(const Il2CppGuid& clsid, Il2CppIUnknown** identity)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+}
+
+inline void il2cpp_codegen_com_register_rcw(Il2CppComObject* rcw)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+}
+
+template<typename T>
+inline T* il2cpp_codegen_com_get_or_create_rcw_from_iunknown(Il2CppIUnknown* unknown, RuntimeClass* fallbackClass)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+template<typename T>
+inline T* il2cpp_codegen_com_get_or_create_rcw_from_iinspectable(Il2CppIInspectable* unknown, RuntimeClass* fallbackClass)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+template<typename T>
+inline T* il2cpp_codegen_com_get_or_create_rcw_for_sealed_class(Il2CppIUnknown* unknown, RuntimeClass* objectClass)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+inline void il2cpp_codegen_il2cpp_com_object_cleanup(Il2CppComObject* rcw)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+}
+
+template<typename InterfaceType>
+inline InterfaceType* il2cpp_codegen_com_get_or_create_ccw(RuntimeObject* obj)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+inline intptr_t il2cpp_codegen_com_get_iunknown_for_object(RuntimeObject* obj)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return 0;
+}
+
+inline void il2cpp_codegen_com_raise_exception(il2cpp_hresult_t hr)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+}
+
+inline void il2cpp_codegen_com_raise_exception_if_failed(il2cpp_hresult_t hr, bool defaultToCOMException)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+}
+
+inline RuntimeException* il2cpp_codegen_com_get_exception(il2cpp_hresult_t hr, bool defaultToCOMException)
+{
+    IL2CPP_NOT_IMPLEMENTED("Not implemented yet.");
+    return NULL;
+}
+
+inline RuntimeException* il2cpp_codegen_com_get_exception_for_invalid_iproperty_cast(RuntimeObject* value, const char* a, const char* b)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+inline Il2CppIActivationFactory* il2cpp_codegen_windows_runtime_get_activation_factory(const il2cpp::utils::StringView<Il2CppNativeChar>& runtimeClassName)
+{
+    IL2CPP_NOT_IMPLEMENTED("COM is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+// delegate
+
+inline Il2CppAsyncResult* il2cpp_codegen_delegate_begin_invoke(RuntimeDelegate* delegate, void** params, RuntimeDelegate* asyncCallback, RuntimeObject* state)
+{
+    return il2cpp_mono_delegate_begin_invoke(delegate, params, asyncCallback, state);
+}
+
+inline RuntimeObject* il2cpp_codegen_delegate_end_invoke(Il2CppAsyncResult* asyncResult, void **out_args)
+{
+    return il2cpp_mono_delegate_end_invoke(asyncResult, out_args);
+}
+
+inline const Il2CppGenericInst* il2cpp_codegen_get_generic_class_inst(RuntimeClass* genericClass)
+{
+    IL2CPP_NOT_IMPLEMENTED("Windows runtime is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+inline RuntimeClass* il2cpp_codegen_inflate_generic_class(RuntimeClass* genericClassDefinition, const Il2CppGenericInst* genericInst)
+{
+    //return il2cpp::vm::Class::GetInflatedGenericInstanceClass(genericClassDefinition, genericInst);
+    IL2CPP_NOT_IMPLEMENTED("Windows runtime is not yet supported with the libmonoruntime backend.");
+    return NULL;
+}
+
+inline RuntimeAssembly* il2cpp_codegen_mono_corlib()
+{
+    return mono_unity_assembly_get_mscorlib();
+}
+
+inline RuntimeClass* il2cpp_codegen_mono_class(AssemblyIndex assemblyIndex, uint32_t classToken)
+{
+    return mono_class_get(mono_assembly_get_image(il2cpp_mono_assembly_from_index(assemblyIndex)), classToken);
+}
+
+inline RuntimeClass* il2cpp_codegen_mono_class(RuntimeAssembly* assembly, uint32_t classToken)
+{
+    return mono_class_get(mono_assembly_get_image(assembly), classToken);
+}
+
+inline RuntimeMethod* il2cpp_codegen_mono_method(AssemblyIndex index, uint32_t methodToken)
+{
+    return mono_get_method(mono_assembly_get_image(il2cpp_mono_assembly_from_index(index)), methodToken, NULL);
+}
+
+inline RuntimeMethod* il2cpp_codegen_mono_method(RuntimeAssembly* assembly, uint32_t methodToken)
+{
+    return mono_get_method(mono_assembly_get_image(assembly), methodToken, NULL);
+}
+
+inline void* il2cpp_codegen_mono_get_static_field_address(RuntimeClass* klass, RuntimeField* field)
+{
+    return il2cpp_mono_get_static_field_address(klass, field);
+}
+
+inline void* il2cpp_codegen_mono_get_thread_static_field_address(RuntimeClass* klass, RuntimeField* field)
+{
+    return il2cpp_mono_get_thread_static_field_address(klass, field);
+}
+
+inline RuntimeField* il2cpp_codegen_mono_class_get_field(RuntimeClass* klass, uint32_t fieldToken)
+{
+    return mono_class_get_field(klass, fieldToken);
+}
+
+inline Il2CppMethodPointer il2cpp_codegen_get_method_pointer(const RuntimeMethod* method)
+{
+    MonoError unused;
+    il2cpp_mono_method_initialize_function_pointers(const_cast<RuntimeMethod*>(method), &unused);
+    return (Il2CppMethodPointer)mono_unity_method_get_method_pointer(const_cast<RuntimeMethod*>(method));
+}
+
+inline RuntimeType* il2cpp_codegen_method_return_type(const RuntimeMethod* method)
+{
+    return mono_signature_get_return_type(mono_method_signature(const_cast<RuntimeMethod*>(method)));
+}
+
+inline int il2cpp_codegen_method_parameter_count(const RuntimeMethod* method)
+{
+    return mono_signature_get_param_count(mono_method_signature(const_cast<RuntimeMethod*>(method)));
+}
+
+template<class T>
+T il2cpp_mono_cast_nullable_method_param(const RuntimeMethod *method, int index, void *value)
+{
+    if (value)
+        return *((T*)value);
+
+    T retVal;
+    RuntimeClass *klass = mono_unity_signature_get_class_for_param(mono_method_signature(const_cast<RuntimeMethod*>(method)), index);
+    mono_nullable_init((uint8_t*)&retVal, NULL, klass);
+    return retVal;
+}
+
+inline const RuntimeMethod* il2cpp_codegen_vtable_slot_method(const RuntimeClass* klass, RuntimeMethod* slot)
+{
+    return slot;
+}
+
+inline Il2CppMethodPointer il2cpp_codegen_vtable_slot_method_pointer(const RuntimeClass* klass, RuntimeMethod* slot)
+{
+    MonoError unused;
+    il2cpp_mono_method_initialize_function_pointers(slot, &unused);
+    return (Il2CppMethodPointer)mono_unity_method_get_method_pointer(slot);
+}
+
+inline bool il2cpp_codegen_is_import_or_windows_runtime(const RuntimeObject *object)
+{
+    assert(0 && "Not implemented yet.");
+    return false;
+}
+
+inline std::string il2cpp_codegen_format_exception(const RuntimeException* ex)
+{
+    return il2cpp_mono_format_exception(ex);
+}
+
+inline intptr_t il2cpp_codegen_get_com_interface_for_object(RuntimeObject* object, Type_t* type)
+{
+    assert(0 && "Not implemented yet.");
+    return 0;
+}
+
+inline NORETURN void il2cpp_codegen_raise_profile_exception(const RuntimeMethod* method)
+{
+    il2cpp_codegen_raise_exception(il2cpp_codegen_get_not_supported_exception(mono_unity_method_get_name(method)));
+}

App/LearnWithTouch_ios/Libraries/libil2cpp/include/codegen/il2cpp-codegen.h

@@ -0,0 +1,55 @@
+#pragma once
+
+struct String_t;
+struct Type_t;
+struct Exception_t;
+struct StringBuilder_t;
+struct MulticastDelegate_t;
+struct MethodBase_t;
+struct Assembly_t;
+
+#if RUNTIME_MONO
+extern "C"
+{
+#include <mono/metadata/class.h>
+#include <mono/metadata/image.h>
+#include <mono/metadata/metadata.h>
+#include <mono/metadata/object.h>
+#include <mono/metadata/object-internals.h>
+}
+
+typedef MonoClass RuntimeClass;
+typedef MonoMethod RuntimeMethod;
+typedef MonoClassField RuntimeField;
+typedef MonoType RuntimeType;
+typedef MonoObject RuntimeObject;
+typedef MonoImage RuntimeImage;
+typedef MonoException RuntimeException;
+typedef MonoArray RuntimeArray;
+typedef MonoAssembly RuntimeAssembly;
+typedef MonoString RuntimeString;
+typedef MonoStringBuilder RuntimeStringBuilder;
+typedef MonoDelegate RuntimeDelegate;
+#include "il2cpp-codegen-mono.h"
+
+
+#else
+struct TypeInfo;
+struct MethodInfo;
+struct FieldInfo;
+struct Il2CppType;
+typedef Il2CppClass RuntimeClass;
+typedef MethodInfo RuntimeMethod;
+typedef FieldInfo RuntimeField;
+typedef Il2CppType RuntimeType;
+typedef Il2CppObject RuntimeObject;
+typedef Il2CppImage RuntimeImage;
+typedef Il2CppException RuntimeException;
+typedef Il2CppArray RuntimeArray;
+typedef Il2CppAssembly RuntimeAssembly;
+typedef Il2CppString RuntimeString;
+struct Il2CppStringBuilder;
+typedef Il2CppStringBuilder RuntimeStringBuilder;
+typedef Il2CppDelegate RuntimeDelegate;
+#include "il2cpp-codegen-il2cpp.h"
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/google/sparsehash/dense_hash_map.h

@@ -0,0 +1,243 @@
+// Copyright (c) 2005, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// ----
+// Author: Craig Silverstein
+//
+// This is just a very thin wrapper over densehashtable.h, just
+// like sgi stl's stl_hash_map is a very thin wrapper over
+// stl_hashtable.  The major thing we define is operator[], because
+// we have a concept of a data_type which stl_hashtable doesn't
+// (it only has a key and a value).
+//
+// NOTE: this is exactly like sparse_hash_map.h, with the word
+// "sparse" replaced by "dense", except for the addition of
+// set_empty_key().
+//
+//   YOU MUST CALL SET_EMPTY_KEY() IMMEDIATELY AFTER CONSTRUCTION.
+//
+// Otherwise your program will die in mysterious ways.
+//
+// In other respects, we adhere mostly to the STL semantics for
+// hash-map.  One important exception is that insert() invalidates
+// iterators entirely.  On the plus side, though, erase() doesn't
+// invalidate iterators at all, or even change the ordering of elements.
+//
+// Here are a few "power user" tips:
+//
+//    1) set_deleted_key():
+//         If you want to use erase() you must call set_deleted_key(),
+//         in addition to set_empty_key(), after construction.
+//         The deleted and empty keys must differ.
+//
+//    2) resize(0):
+//         When an item is deleted, its memory isn't freed right
+//         away.  This allows you to iterate over a hashtable,
+//         and call erase(), without invalidating the iterator.
+//         To force the memory to be freed, call resize(0).
+//
+// Guide to what kind of hash_map to use:
+//   (1) dense_hash_map: fastest, uses the most memory
+//   (2) sparse_hash_map: slowest, uses the least memory
+//   (3) hash_map (STL): in the middle
+// Typically I use sparse_hash_map when I care about space and/or when
+// I need to save the hashtable on disk.  I use hash_map otherwise.  I
+// don't personally use dense_hash_map ever; the only use of
+// dense_hash_map I know of is to work around malloc() bugs in some
+// systems (dense_hash_map has a particularly simple allocation scheme).
+//
+// - dense_hash_map has, typically, a factor of 2 memory overhead (if your
+//   data takes up X bytes, the hash_map uses X more bytes in overhead).
+// - sparse_hash_map has about 2 bits overhead per entry.
+// - sparse_hash_map can be 3-7 times slower than the others for lookup and,
+//   especially, inserts.  See time_hash_map.cc for details.
+//
+// See /usr/(local/)?doc/sparsehash-0.1/dense_hash_map.html
+// for information about how to use this class.
+
+#ifndef _DENSE_HASH_MAP_H_
+#define _DENSE_HASH_MAP_H_
+
+//#include <google/sparsehash/sparseconfig.h>
+#include <stdio.h>                   // for FILE * in read()/write()
+#include <algorithm>                 // for the default template args
+#include <functional>                // for equal_to
+#include <memory>                    // for alloc<>
+#include <utility>                   // for pair<>
+//#include <ext/hash_fun.h>                  // defined in config.h
+#include "densehashtable.h"
+
+
+using std::pair;
+
+template <class Key, class T,
+          class HashFcn,
+          class EqualKey = std::equal_to<Key>,
+		  class Alloc = std::allocator< std::pair<const Key, T> > >
+class dense_hash_map {
+ private:
+  // Apparently select1st is not stl-standard, so we define our own
+  struct SelectKey {
+    const Key& operator()(const pair<const Key, T>& p) const {
+      return p.first;
+    }
+  };
+
+  // The actual data
+  typedef dense_hashtable<pair<const Key, T>, Key, HashFcn,
+                          SelectKey, EqualKey, Alloc> ht;
+  ht rep;
+
+ public:
+  typedef typename ht::key_type key_type;
+  typedef T data_type;
+  typedef T mapped_type;
+  typedef typename ht::value_type value_type;
+  typedef typename ht::hasher hasher;
+  typedef typename ht::key_equal key_equal;
+
+  typedef typename ht::size_type size_type;
+  typedef typename ht::difference_type difference_type;
+  typedef typename ht::pointer pointer;
+  typedef typename ht::const_pointer const_pointer;
+  typedef typename ht::reference reference;
+  typedef typename ht::const_reference const_reference;
+
+  typedef typename ht::iterator iterator;
+  typedef typename ht::const_iterator const_iterator;
+
+  // Iterator functions
+  iterator begin()                    { return rep.begin(); }
+  iterator end()                      { return rep.end(); }
+  const_iterator begin() const        { return rep.begin(); }
+  const_iterator end() const          { return rep.end(); }
+
+
+  // Accessor functions
+  hasher hash_funct() const { return rep.hash_funct(); }
+  key_equal key_eq() const  { return rep.key_eq(); }
+
+
+  // Constructors
+  explicit dense_hash_map(size_type n = 0,
+                          const hasher& hf = hasher(),
+                          const key_equal& eql = key_equal())
+    : rep(n, hf, eql) { }
+
+  template <class InputIterator>
+  dense_hash_map(InputIterator f, InputIterator l,
+                 size_type n = 0,
+                 const hasher& hf = hasher(),
+                 const key_equal& eql = key_equal())
+    : rep(n, hf, eql) {
+    rep.insert(f, l);
+  }
+  // We use the default copy constructor
+  // We use the default operator=()
+  // We use the default destructor
+
+  void clear()                        { rep.clear(); }
+  // This clears the hash map without resizing it down to the minimum
+  // bucket count, but rather keeps the number of buckets constant
+  void clear_no_resize()              { rep.clear_no_resize(); }
+  void swap(dense_hash_map& hs)       { rep.swap(hs.rep); }
+
+
+  // Functions concerning size
+  size_type size() const              { return rep.size(); }
+  size_type max_size() const          { return rep.max_size(); }
+  bool empty() const                  { return rep.empty(); }
+  size_type bucket_count() const      { return rep.bucket_count(); }
+  size_type max_bucket_count() const  { return rep.max_bucket_count(); }
+
+  void resize(size_type hint)         { rep.resize(hint); }
+
+
+  // Lookup routines
+  iterator find(const key_type& key)                 { return rep.find(key); }
+  const_iterator find(const key_type& key) const     { return rep.find(key); }
+
+  data_type& operator[](const key_type& key) {       // This is our value-add!
+    iterator it = find(key);
+    if (it != end()) {
+      return it->second;
+    } else {
+      return insert(value_type(key, data_type())).first->second;
+    }
+  }
+
+  size_type count(const key_type& key) const         { return rep.count(key); }
+
+  pair<iterator, iterator> equal_range(const key_type& key) {
+    return rep.equal_range(key);
+  }
+  pair<const_iterator, const_iterator> equal_range(const key_type& key) const {
+    return rep.equal_range(key);
+  }
+
+  // Insertion routines
+  pair<iterator, bool> insert(const value_type& obj) { return rep.insert(obj); }
+  template <class InputIterator>
+  void insert(InputIterator f, InputIterator l)      { rep.insert(f, l); }
+  void insert(const_iterator f, const_iterator l)    { rep.insert(f, l); }
+  // required for std::insert_iterator; the passed-in iterator is ignored
+  iterator insert(iterator, const value_type& obj)   { return insert(obj).first; }
+
+
+  // Deletion and empty routines
+  // THESE ARE NON-STANDARD!  I make you specify an "impossible" key
+  // value to identify deleted and empty buckets.  You can change the
+  // deleted key as time goes on, or get rid of it entirely to be insert-only.
+  void set_empty_key(const key_type& key)   {           // YOU MUST CALL THIS!
+    rep.set_empty_key(value_type(key, data_type()));    // rep wants a value
+  }
+  void set_deleted_key(const key_type& key)   {
+    rep.set_deleted_key(value_type(key, data_type()));  // rep wants a value
+  }
+  void clear_deleted_key()                    { rep.clear_deleted_key(); }
+
+  // These are standard
+  size_type erase(const key_type& key)               { return rep.erase(key); }
+  void erase(iterator it)                            { rep.erase(it); }
+  void erase(iterator f, iterator l)                 { rep.erase(f, l); }
+
+
+  // Comparison
+  bool operator==(const dense_hash_map& hs) const    { return rep == hs.rep; }
+  bool operator!=(const dense_hash_map& hs) const    { return rep != hs.rep; }
+};
+
+// We need a global swap as well
+template <class Key, class T, class HashFcn, class EqualKey, class Alloc>
+inline void swap(dense_hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm1,
+                 dense_hash_map<Key, T, HashFcn, EqualKey, Alloc>& hm2) {
+  hm1.swap(hm2);
+}
+
+#endif /* _DENSE_HASH_MAP_H_ */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/google/sparsehash/dense_hash_set.h

@@ -0,0 +1,227 @@
+// Copyright (c) 2005, Google Inc.
+// All rights reserved.
+// 
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+// 
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+// 
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// ---
+// Author: Craig Silverstein
+//
+// This is just a very thin wrapper over densehashtable.h, just
+// like sgi stl's stl_hash_set is a very thin wrapper over
+// stl_hashtable.  The major thing we define is operator[], because
+// we have a concept of a data_type which stl_hashtable doesn't
+// (it only has a key and a value).
+//
+// This is more different from dense_hash_map than you might think,
+// because all iterators for sets are const (you obviously can't
+// change the key, and for sets there is no value).
+//
+// NOTE: this is exactly like sparse_hash_set.h, with the word
+// "sparse" replaced by "dense", except for the addition of
+// set_empty_key().
+//
+//   YOU MUST CALL SET_EMPTY_KEY() IMMEDIATELY AFTER CONSTRUCTION.
+//
+// Otherwise your program will die in mysterious ways.
+//
+// In other respects, we adhere mostly to the STL semantics for
+// hash-set.  One important exception is that insert() invalidates
+// iterators entirely.  On the plus side, though, erase() doesn't
+// invalidate iterators at all, or even change the ordering of elements.
+//
+// Here are a few "power user" tips:
+//
+//    1) set_deleted_key():
+//         If you want to use erase() you must call set_deleted_key(),
+//         in addition to set_empty_key(), after construction.
+//         The deleted and empty keys must differ.
+//
+//    2) resize(0):
+//         When an item is deleted, its memory isn't freed right
+//         away.  This allows you to iterate over a hashtable,
+//         and call erase(), without invalidating the iterator.
+//         To force the memory to be freed, call resize(0).
+//
+// Guide to what kind of hash_set to use:
+//   (1) dense_hash_set: fastest, uses the most memory
+//   (2) sparse_hash_set: slowest, uses the least memory
+//   (3) hash_set (STL): in the middle
+// Typically I use sparse_hash_set when I care about space and/or when
+// I need to save the hashtable on disk.  I use hash_set otherwise.  I
+// don't personally use dense_hash_set ever; the only use of
+// dense_hash_set I know of is to work around malloc() bugs in some
+// systems (dense_hash_set has a particularly simple allocation scheme).
+//
+// - dense_hash_set has, typically, a factor of 2 memory overhead (if your
+//   data takes up X bytes, the hash_set uses X more bytes in overhead).
+// - sparse_hash_set has about 2 bits overhead per entry.
+// - sparse_hash_map can be 3-7 times slower than the others for lookup and,
+//   especially, inserts.  See time_hash_map.cc for details.
+//
+// See /usr/(local/)?doc/sparsehash-0.1/dense_hash_set.html
+// for information about how to use this class.
+
+#ifndef _DENSE_HASH_SET_H_
+#define _DENSE_HASH_SET_H_
+
+//#include <google/sparsehash/sparseconfig.h>
+#include <stdio.h>                   // for FILE * in read()/write()
+#include <algorithm>                 // for the default template args
+#include <functional>                // for equal_to
+#include <memory>                    // for alloc<>
+#include <utility>                   // for pair<>
+//#include HASH_FUN_H                  // defined in config.h
+#include "densehashtable.h"
+
+using std::pair;
+
+template <class Value,
+          class HashFcn,  
+          class EqualKey = std::equal_to<Value>, 
+          class Alloc = std::allocator<Value> >
+class dense_hash_set {
+ private:
+  // Apparently identity is not stl-standard, so we define our own
+  struct Identity {
+    Value& operator()(Value& v) const { return v; }
+    const Value& operator()(const Value& v) const { return v; }
+  };
+
+  // The actual data
+  typedef dense_hashtable<Value, Value, HashFcn, Identity, EqualKey, Alloc> ht;
+  ht rep;
+
+ public:
+  typedef typename ht::key_type key_type;
+  typedef typename ht::value_type value_type;
+  typedef typename ht::hasher hasher;
+  typedef typename ht::key_equal key_equal;
+
+  typedef typename ht::size_type size_type;
+  typedef typename ht::difference_type difference_type;
+  typedef typename ht::const_pointer pointer;
+  typedef typename ht::const_pointer const_pointer;
+  typedef typename ht::const_reference reference;
+  typedef typename ht::const_reference const_reference;
+
+  typedef typename ht::const_iterator iterator;
+  typedef typename ht::const_iterator const_iterator;
+
+
+  // Iterator functions -- recall all iterators are const
+  iterator begin() const              { return rep.begin(); }
+  iterator end() const                { return rep.end(); }
+
+
+  // Accessor functions
+  hasher hash_funct() const { return rep.hash_funct(); }
+  key_equal key_eq() const  { return rep.key_eq(); }
+
+
+  // Constructors
+  explicit dense_hash_set(size_type n = 0,
+                          const hasher& hf = hasher(),
+                          const key_equal& eql = key_equal())
+    : rep(n, hf, eql) { }
+
+  template <class InputIterator>
+  dense_hash_set(InputIterator f, InputIterator l,
+                 size_type n = 0,
+                 const hasher& hf = hasher(),
+                 const key_equal& eql = key_equal()) 
+	: rep(n, hf, eql) {
+    rep.insert(f, l);
+  }
+  // We use the default copy constructor
+  // We use the default operator=()
+  // We use the default destructor
+
+  void clear()                        { rep.clear(); }
+  // This clears the hash set without resizing it down to the minimum
+  // bucket count, but rather keeps the number of buckets constant
+  void clear_no_resize()              { rep.clear_no_resize(); }
+  void swap(dense_hash_set& hs)       { rep.swap(hs.rep); }
+
+
+  // Functions concerning size
+  size_type size() const              { return rep.size(); }
+  size_type max_size() const          { return rep.max_size(); }
+  bool empty() const                  { return rep.empty(); }
+  size_type bucket_count() const      { return rep.bucket_count(); }
+  size_type max_bucket_count() const  { return rep.max_bucket_count(); }
+
+  void resize(size_type hint)         { rep.resize(hint); }
+
+
+  // Lookup routines
+  iterator find(const key_type& key) const           { return rep.find(key); }
+
+  size_type count(const key_type& key) const         { return rep.count(key); }
+
+  pair<iterator, iterator> equal_range(const key_type& key) const {
+    return rep.equal_range(key);
+  }
+
+  // Insertion routines
+  pair<iterator, bool> insert(const value_type& obj) {
+    pair<typename ht::iterator, bool> p = rep.insert(obj);
+    return pair<iterator, bool>(p.first, p.second);   // const to non-const
+  }
+  template <class InputIterator>
+  void insert(InputIterator f, InputIterator l)      { rep.insert(f, l); }
+  void insert(const_iterator f, const_iterator l)    { rep.insert(f, l); }
+  // required for std::insert_iterator; the passed-in iterator is ignored
+  iterator insert(iterator, const value_type& obj)   { return insert(obj).first; }
+
+
+  // Deletion and empty routines
+  // THESE ARE NON-STANDARD!  I make you specify an "impossible" key
+  // value to identify deleted and empty buckets.  You can change the
+  // deleted key as time goes on, or get rid of it entirely to be insert-only.
+  void set_empty_key(const key_type& key)     { rep.set_empty_key(key); }
+  void set_deleted_key(const key_type& key)   { rep.set_deleted_key(key); }
+  void clear_deleted_key()                    { rep.clear_deleted_key(); }
+
+  // These are standard
+  size_type erase(const key_type& key)               { return rep.erase(key); }
+  void erase(iterator it)                            { rep.erase(it); }
+  void erase(iterator f, iterator l)                 { rep.erase(f, l); }
+
+
+  // Comparison
+  bool operator==(const dense_hash_set& hs) const    { return rep == hs.rep; }
+  bool operator!=(const dense_hash_set& hs) const    { return rep != hs.rep; }
+};
+
+template <class Val, class HashFcn, class EqualKey, class Alloc>
+inline void swap(dense_hash_set<Val, HashFcn, EqualKey, Alloc>& hs1,
+                 dense_hash_set<Val, HashFcn, EqualKey, Alloc>& hs2) {
+  hs1.swap(hs2);
+}
+
+
+#endif /* _DENSE_HASH_SET_H_ */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/google/sparsehash/type_traits.h

@@ -0,0 +1,250 @@
+// Copyright (c) 2006, Google Inc.
+// All rights reserved.
+//
+// Redistribution and use in source and binary forms, with or without
+// modification, are permitted provided that the following conditions are
+// met:
+//
+//     * Redistributions of source code must retain the above copyright
+// notice, this list of conditions and the following disclaimer.
+//     * Redistributions in binary form must reproduce the above
+// copyright notice, this list of conditions and the following disclaimer
+// in the documentation and/or other materials provided with the
+// distribution.
+//     * Neither the name of Google Inc. nor the names of its
+// contributors may be used to endorse or promote products derived from
+// this software without specific prior written permission.
+//
+// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
+// "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
+// LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR
+// A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT
+// OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
+// SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT
+// LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE,
+// DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY
+// THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE
+// OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+
+// ----
+// Author: Matt Austern
+//
+// Define a small subset of tr1 type traits. The traits we define are:
+//   is_integral
+//   is_floating_point
+//   is_pointer
+//   is_reference
+//   is_pod
+//   has_trivial_constructor
+//   has_trivial_copy
+//   has_trivial_assign
+//   has_trivial_destructor
+//   remove_const
+//   remove_volatile
+//   remove_cv
+//   remove_reference
+//   remove_pointer
+//   is_convertible
+// We can add more type traits as required.
+
+#ifndef BASE_TYPE_TRAITS_H_
+#define BASE_TYPE_TRAITS_H_
+
+//#include <google/sparsehash/sparseconfig.h>
+#include <utility>                  // For pair
+
+namespace dense_hash_map_traits
+{
+
+// integral_constant, defined in tr1, is a wrapper for an integer
+// value. We don't really need this generality; we could get away
+// with hardcoding the integer type to bool. We use the fully
+// general integer_constant for compatibility with tr1.
+
+template<class T, T v>
+struct integral_constant {
+  static const T value = v;
+  typedef T value_type;
+  typedef integral_constant<T, v> type;
+};
+
+template <class T, T v> const T integral_constant<T, v>::value;
+
+// Abbreviations: true_type and false_type are structs that represent
+// boolean true and false values.
+typedef integral_constant<bool, true>  true_type;
+typedef integral_constant<bool, false> false_type;
+
+// Types small_ and big_ are guaranteed such that sizeof(small_) <
+// sizeof(big_)
+typedef char small_;
+
+struct big_ {
+  char dummy[2];
+};
+
+// is_integral is false except for the built-in integer types.
+template <class T> struct is_integral : false_type { };
+template<> struct is_integral<bool> : true_type { };
+template<> struct is_integral<char> : true_type { };
+template<> struct is_integral<unsigned char> : true_type { };
+template<> struct is_integral<signed char> : true_type { };
+#if defined(_MSC_VER)
+// wchar_t is not by default a distinct type from unsigned short in
+// Microsoft C.
+// See http://msdn2.microsoft.com/en-us/library/dh8che7s(VS.80).aspx
+template<> struct is_integral<__wchar_t> : true_type { };
+#else
+template<> struct is_integral<wchar_t> : true_type { };
+#endif
+template<> struct is_integral<short> : true_type { };
+template<> struct is_integral<unsigned short> : true_type { };
+template<> struct is_integral<int> : true_type { };
+template<> struct is_integral<unsigned int> : true_type { };
+template<> struct is_integral<long> : true_type { };
+template<> struct is_integral<unsigned long> : true_type { };
+#ifdef HAVE_LONG_LONG
+template<> struct is_integral<long long> : true_type { };
+template<> struct is_integral<unsigned long long> : true_type { };
+#endif
+
+
+// is_floating_point is false except for the built-in floating-point types.
+template <class T> struct is_floating_point : false_type { };
+template<> struct is_floating_point<float> : true_type { };
+template<> struct is_floating_point<double> : true_type { };
+template<> struct is_floating_point<long double> : true_type { };
+
+
+// is_pointer is false except for pointer types.
+template <class T> struct is_pointer : false_type { };
+template <class T> struct is_pointer<T*> : true_type { };
+
+
+// is_reference is false except for reference types.
+template<typename T> struct is_reference : false_type {};
+template<typename T> struct is_reference<T&> : true_type {};
+
+
+// We can't get is_pod right without compiler help, so fail conservatively.
+// We will assume it's false except for arithmetic types and pointers,
+// and const versions thereof. Note that std::pair is not a POD.
+template <class T> struct is_pod
+ : integral_constant<bool, (is_integral<T>::value ||
+                            is_floating_point<T>::value ||
+                            is_pointer<T>::value)> { };
+template <class T> struct is_pod<const T> : is_pod<T> { };
+
+
+// We can't get has_trivial_constructor right without compiler help, so
+// fail conservatively. We will assume it's false except for: (1) types
+// for which is_pod is true. (2) std::pair of types with trivial
+// constructors. (3) array of a type with a trivial constructor.
+// (4) const versions thereof.
+template <class T> struct has_trivial_constructor : is_pod<T> { };
+template <class T, class U> struct has_trivial_constructor<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_constructor<T>::value &&
+                       has_trivial_constructor<U>::value)> { };
+template <class A, int N> struct has_trivial_constructor<A[N]>
+  : has_trivial_constructor<A> { };
+template <class T> struct has_trivial_constructor<const T>
+  : has_trivial_constructor<T> { };
+
+// We can't get has_trivial_copy right without compiler help, so fail
+// conservatively. We will assume it's false except for: (1) types
+// for which is_pod is true. (2) std::pair of types with trivial copy
+// constructors. (3) array of a type with a trivial copy constructor.
+// (4) const versions thereof.
+template <class T> struct has_trivial_copy : is_pod<T> { };
+template <class T, class U> struct has_trivial_copy<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_copy<T>::value &&
+                       has_trivial_copy<U>::value)> { };
+template <class A, int N> struct has_trivial_copy<A[N]>
+  : has_trivial_copy<A> { };
+template <class T> struct has_trivial_copy<const T> : has_trivial_copy<T> { };
+
+// We can't get has_trivial_assign right without compiler help, so fail
+// conservatively. We will assume it's false except for: (1) types
+// for which is_pod is true. (2) std::pair of types with trivial copy
+// constructors. (3) array of a type with a trivial assign constructor.
+template <class T> struct has_trivial_assign : is_pod<T> { };
+template <class T, class U> struct has_trivial_assign<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_assign<T>::value &&
+                       has_trivial_assign<U>::value)> { };
+template <class A, int N> struct has_trivial_assign<A[N]>
+  : has_trivial_assign<A> { };
+
+// We can't get has_trivial_destructor right without compiler help, so
+// fail conservatively. We will assume it's false except for: (1) types
+// for which is_pod is true. (2) std::pair of types with trivial
+// destructors. (3) array of a type with a trivial destructor.
+// (4) const versions thereof.
+template <class T> struct has_trivial_destructor : is_pod<T> { };
+template <class T, class U> struct has_trivial_destructor<std::pair<T, U> >
+  : integral_constant<bool,
+                      (has_trivial_destructor<T>::value &&
+                       has_trivial_destructor<U>::value)> { };
+template <class A, int N> struct has_trivial_destructor<A[N]>
+  : has_trivial_destructor<A> { };
+template <class T> struct has_trivial_destructor<const T>
+  : has_trivial_destructor<T> { };
+
+// Specified by TR1 [4.7.1]
+template<typename T> struct remove_const { typedef T type; };
+template<typename T> struct remove_const<T const> { typedef T type; };
+template<typename T> struct remove_volatile { typedef T type; };
+template<typename T> struct remove_volatile<T volatile> { typedef T type; };
+template<typename T> struct remove_cv {
+  typedef typename remove_const<typename remove_volatile<T>::type>::type type;
+};
+
+
+// Specified by TR1 [4.7.2]
+template<typename T> struct remove_reference { typedef T type; };
+template<typename T> struct remove_reference<T&> { typedef T type; };
+
+// Specified by TR1 [4.7.4] Pointer modifications.
+template<typename T> struct remove_pointer { typedef T type; };
+template<typename T> struct remove_pointer<T*> { typedef T type; };
+template<typename T> struct remove_pointer<T* const> { typedef T type; };
+template<typename T> struct remove_pointer<T* volatile> { typedef T type; };
+template<typename T> struct remove_pointer<T* const volatile> {
+  typedef T type; };
+
+// Specified by TR1 [4.6] Relationships between types
+#ifndef _MSC_VER
+namespace internal_type_traits {
+
+// This class is an implementation detail for is_convertible, and you
+// don't need to know how it works to use is_convertible. For those
+// who care: we declare two different functions, one whose argument is
+// of type To and one with a variadic argument list. We give them
+// return types of different size, so we can use sizeof to trick the
+// compiler into telling us which function it would have chosen if we
+// had called it with an argument of type From.  See Alexandrescu's
+// _Modern C++ Design_ for more details on this sort of trick.
+
+template <typename From, typename To>
+struct ConvertHelper {
+  static small_ Test(To);
+  static big_ Test(...);
+  static From Create();
+};
+}  // namespace internal
+
+// Inherits from true_type if From is convertible to To, false_type otherwise.
+template <typename From, typename To>
+struct is_convertible
+    : integral_constant<bool,
+                        sizeof(internal_type_traits::ConvertHelper<From, To>::Test(
+                                  internal_type_traits::ConvertHelper<From, To>::Create()))
+                        == sizeof(small_)> {
+};
+#endif
+
+}
+#endif  // BASE_TYPE_TRAITS_H_

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/xamarin-android/logger.h

@@ -0,0 +1,74 @@
+#ifndef __MONODROID_LOGGER_H__
+#define __MONODROID_LOGGER_H__
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+#ifndef ANDROID
+typedef enum android_LogPriority
+{
+    ANDROID_LOG_UNKNOWN = 0,
+    ANDROID_LOG_DEFAULT,    /* only for SetMinPriority() */
+    ANDROID_LOG_VERBOSE,
+    ANDROID_LOG_DEBUG,
+    ANDROID_LOG_INFO,
+    ANDROID_LOG_WARN,
+    ANDROID_LOG_ERROR,
+    ANDROID_LOG_FATAL,
+    ANDROID_LOG_SILENT,     /* only for SetMinPriority(); must be last */
+} android_LogPriority;
+#endif
+
+// Keep in sync with Mono.Android/src/Runtime/Logger.cs!LogCategories enum
+typedef enum _LogCategories
+{
+    LOG_NONE      = 0,
+    LOG_DEFAULT   = 1 << 0,
+    LOG_ASSEMBLY  = 1 << 1,
+    LOG_DEBUGGER  = 1 << 2,
+    LOG_GC        = 1 << 3,
+    LOG_GREF      = 1 << 4,
+    LOG_LREF      = 1 << 5,
+    LOG_TIMING    = 1 << 6,
+    LOG_BUNDLE    = 1 << 7,
+    LOG_NET       = 1 << 8,
+    LOG_NETLINK   = 1 << 9,
+} LogCategories;
+
+#if 0
+
+extern unsigned int log_categories;
+
+#if DEBUG
+extern int gc_spew_enabled;
+#endif
+
+void init_categories(const char *override_dir);
+
+void log_error(LogCategories category, const char *format, ...);
+
+void log_fatal(LogCategories category, const char *format, ...);
+
+void log_info(LogCategories category, const char *format, ...);
+
+void log_warn(LogCategories category, const char *format, ...);
+
+void log_debug(LogCategories category, const char *format, ...);
+
+#else
+
+#define init_categories(override_dir)
+#define log_error(category, format, ...)
+#define log_fatal(category, format, ...)
+#define log_info(category, format, ...)
+#define log_warn(category, format, ...)
+#define log_debug(category, format, ...)
+
+#endif
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif /* __MONODROID_LOGGER_H__ */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/xamarin-android/monodroid.h

@@ -0,0 +1,54 @@
+#ifndef __MONODROID_H
+#define __MONODROID_H
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* VS 2010 and later have stdint.h */
+#if defined(_MSC_VER)
+
+    #define MONO_API_EXPORT __declspec(dllexport)
+    #define MONO_API_IMPORT __declspec(dllimport)
+
+#else   /* defined(_MSC_VER */
+
+    #define MONO_API_EXPORT __attribute__ ((visibility ("default")))
+    #define MONO_API_IMPORT
+
+#endif  /* !defined(_MSC_VER) */
+
+#if defined(MONO_DLL_EXPORT)
+    #define MONO_API MONO_API_EXPORT
+#elif defined(MONO_DLL_IMPORT)
+    #define MONO_API MONO_API_IMPORT
+#else   /* !defined(MONO_DLL_IMPORT) && !defined(MONO_API_IMPORT) */
+    #define MONO_API
+#endif  /* MONO_DLL_EXPORT... */
+
+enum FatalExitCodes
+{
+    FATAL_EXIT_CANNOT_FIND_MONO           =  1,
+    FATAL_EXIT_ATTACH_JVM_FAILED          =  2,
+    FATAL_EXIT_DEBUGGER_CONNECT           =  3,
+    FATAL_EXIT_CANNOT_FIND_JNIENV         =  4,
+    FATAL_EXIT_CANNOT_FIND_APK            = 10,
+    FATAL_EXIT_TRIAL_EXPIRED              = 11,
+    FATAL_EXIT_PTHREAD_FAILED             = 12,
+    FATAL_EXIT_MISSING_ASSEMBLY           = 13,
+    FATAL_EXIT_CANNOT_LOAD_BUNDLE         = 14,
+    FATAL_EXIT_CANNOT_FIND_LIBMONOSGEN    = 15,
+    FATAL_EXIT_NO_ASSEMBLIES              = 'A',
+    FATAL_EXIT_MONO_MISSING_SYMBOLS       = 'B',
+    FATAL_EXIT_FORK_FAILED                = 'F',
+    FATAL_EXIT_MISSING_INIT               = 'I',
+    FATAL_EXIT_MISSING_TIMEZONE_MEMBERS   = 'T',
+    FATAL_EXIT_MISSING_ZIPALIGN           = 'Z',
+    FATAL_EXIT_OUT_OF_MEMORY              = 'M',
+};
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif  /* defined __MONODROID_H */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/xamarin-android/xamarin_getifaddrs.h

@@ -0,0 +1,50 @@
+#ifndef __XAMARIN_GETIFADDRS_H
+
+#include "monodroid.h"
+
+#ifdef __cplusplus
+extern "C" {
+#endif
+
+/* We're implementing getifaddrs behavior, this is the structure we use. It is exactly the same as
+ * struct ifaddrs defined in ifaddrs.h but since bionics doesn't have it we need to mirror it here.
+ */
+struct _monodroid_ifaddrs
+{
+    struct _monodroid_ifaddrs *ifa_next; /* Pointer to the next structure.      */
+
+    char *ifa_name;                      /* Name of this network interface.     */
+    unsigned int ifa_flags;              /* Flags as from SIOCGIFFLAGS ioctl.   */
+
+    struct sockaddr *ifa_addr;           /* Network address of this interface.  */
+    struct sockaddr *ifa_netmask;        /* Netmask of this interface.          */
+    union
+    {
+        /* At most one of the following two is valid.  If the IFF_BROADCAST
+           bit is set in `ifa_flags', then `ifa_broadaddr' is valid.  If the
+           IFF_POINTOPOINT bit is set, then `ifa_dstaddr' is valid.
+           It is never the case that both these bits are set at once.  */
+        struct sockaddr *ifu_broadaddr;  /* Broadcast address of this interface. */
+        struct sockaddr *ifu_dstaddr;    /* Point-to-point destination address.  */
+    } ifa_ifu;
+    /* These very same macros are defined by <net/if.h> for `struct ifaddr'.
+       So if they are defined already, the existing definitions will be fine.  */
+# ifndef _monodroid_ifa_broadaddr
+#  define _monodroid_ifa_broadaddr ifa_ifu.ifu_broadaddr
+# endif
+# ifndef _monodroid_ifa_dstaddr
+#  define _monodroid_ifa_dstaddr   ifa_ifu.ifu_dstaddr
+# endif
+
+    void *ifa_data;               /* Address-specific data (may be unused).  */
+};
+
+void _monodroid_getifaddrs_init(void);
+MONO_API  int  _monodroid_getifaddrs(struct _monodroid_ifaddrs **ifap);
+MONO_API  void _monodroid_freeifaddrs(struct _monodroid_ifaddrs *ifa);
+
+#ifdef __cplusplus
+}
+#endif
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/zlib/crc32.h

@@ -0,0 +1,441 @@
+/* crc32.h -- tables for rapid CRC calculation
+ * Generated automatically by crc32.c
+ */
+
+local const z_crc_t FAR crc_table[TBLS][256] =
+{
+  {
+    0x00000000UL, 0x77073096UL, 0xee0e612cUL, 0x990951baUL, 0x076dc419UL,
+    0x706af48fUL, 0xe963a535UL, 0x9e6495a3UL, 0x0edb8832UL, 0x79dcb8a4UL,
+    0xe0d5e91eUL, 0x97d2d988UL, 0x09b64c2bUL, 0x7eb17cbdUL, 0xe7b82d07UL,
+    0x90bf1d91UL, 0x1db71064UL, 0x6ab020f2UL, 0xf3b97148UL, 0x84be41deUL,
+    0x1adad47dUL, 0x6ddde4ebUL, 0xf4d4b551UL, 0x83d385c7UL, 0x136c9856UL,
+    0x646ba8c0UL, 0xfd62f97aUL, 0x8a65c9ecUL, 0x14015c4fUL, 0x63066cd9UL,
+    0xfa0f3d63UL, 0x8d080df5UL, 0x3b6e20c8UL, 0x4c69105eUL, 0xd56041e4UL,
+    0xa2677172UL, 0x3c03e4d1UL, 0x4b04d447UL, 0xd20d85fdUL, 0xa50ab56bUL,
+    0x35b5a8faUL, 0x42b2986cUL, 0xdbbbc9d6UL, 0xacbcf940UL, 0x32d86ce3UL,
+    0x45df5c75UL, 0xdcd60dcfUL, 0xabd13d59UL, 0x26d930acUL, 0x51de003aUL,
+    0xc8d75180UL, 0xbfd06116UL, 0x21b4f4b5UL, 0x56b3c423UL, 0xcfba9599UL,
+    0xb8bda50fUL, 0x2802b89eUL, 0x5f058808UL, 0xc60cd9b2UL, 0xb10be924UL,
+    0x2f6f7c87UL, 0x58684c11UL, 0xc1611dabUL, 0xb6662d3dUL, 0x76dc4190UL,
+    0x01db7106UL, 0x98d220bcUL, 0xefd5102aUL, 0x71b18589UL, 0x06b6b51fUL,
+    0x9fbfe4a5UL, 0xe8b8d433UL, 0x7807c9a2UL, 0x0f00f934UL, 0x9609a88eUL,
+    0xe10e9818UL, 0x7f6a0dbbUL, 0x086d3d2dUL, 0x91646c97UL, 0xe6635c01UL,
+    0x6b6b51f4UL, 0x1c6c6162UL, 0x856530d8UL, 0xf262004eUL, 0x6c0695edUL,
+    0x1b01a57bUL, 0x8208f4c1UL, 0xf50fc457UL, 0x65b0d9c6UL, 0x12b7e950UL,
+    0x8bbeb8eaUL, 0xfcb9887cUL, 0x62dd1ddfUL, 0x15da2d49UL, 0x8cd37cf3UL,
+    0xfbd44c65UL, 0x4db26158UL, 0x3ab551ceUL, 0xa3bc0074UL, 0xd4bb30e2UL,
+    0x4adfa541UL, 0x3dd895d7UL, 0xa4d1c46dUL, 0xd3d6f4fbUL, 0x4369e96aUL,
+    0x346ed9fcUL, 0xad678846UL, 0xda60b8d0UL, 0x44042d73UL, 0x33031de5UL,
+    0xaa0a4c5fUL, 0xdd0d7cc9UL, 0x5005713cUL, 0x270241aaUL, 0xbe0b1010UL,
+    0xc90c2086UL, 0x5768b525UL, 0x206f85b3UL, 0xb966d409UL, 0xce61e49fUL,
+    0x5edef90eUL, 0x29d9c998UL, 0xb0d09822UL, 0xc7d7a8b4UL, 0x59b33d17UL,
+    0x2eb40d81UL, 0xb7bd5c3bUL, 0xc0ba6cadUL, 0xedb88320UL, 0x9abfb3b6UL,
+    0x03b6e20cUL, 0x74b1d29aUL, 0xead54739UL, 0x9dd277afUL, 0x04db2615UL,
+    0x73dc1683UL, 0xe3630b12UL, 0x94643b84UL, 0x0d6d6a3eUL, 0x7a6a5aa8UL,
+    0xe40ecf0bUL, 0x9309ff9dUL, 0x0a00ae27UL, 0x7d079eb1UL, 0xf00f9344UL,
+    0x8708a3d2UL, 0x1e01f268UL, 0x6906c2feUL, 0xf762575dUL, 0x806567cbUL,
+    0x196c3671UL, 0x6e6b06e7UL, 0xfed41b76UL, 0x89d32be0UL, 0x10da7a5aUL,
+    0x67dd4accUL, 0xf9b9df6fUL, 0x8ebeeff9UL, 0x17b7be43UL, 0x60b08ed5UL,
+    0xd6d6a3e8UL, 0xa1d1937eUL, 0x38d8c2c4UL, 0x4fdff252UL, 0xd1bb67f1UL,
+    0xa6bc5767UL, 0x3fb506ddUL, 0x48b2364bUL, 0xd80d2bdaUL, 0xaf0a1b4cUL,
+    0x36034af6UL, 0x41047a60UL, 0xdf60efc3UL, 0xa867df55UL, 0x316e8eefUL,
+    0x4669be79UL, 0xcb61b38cUL, 0xbc66831aUL, 0x256fd2a0UL, 0x5268e236UL,
+    0xcc0c7795UL, 0xbb0b4703UL, 0x220216b9UL, 0x5505262fUL, 0xc5ba3bbeUL,
+    0xb2bd0b28UL, 0x2bb45a92UL, 0x5cb36a04UL, 0xc2d7ffa7UL, 0xb5d0cf31UL,
+    0x2cd99e8bUL, 0x5bdeae1dUL, 0x9b64c2b0UL, 0xec63f226UL, 0x756aa39cUL,
+    0x026d930aUL, 0x9c0906a9UL, 0xeb0e363fUL, 0x72076785UL, 0x05005713UL,
+    0x95bf4a82UL, 0xe2b87a14UL, 0x7bb12baeUL, 0x0cb61b38UL, 0x92d28e9bUL,
+    0xe5d5be0dUL, 0x7cdcefb7UL, 0x0bdbdf21UL, 0x86d3d2d4UL, 0xf1d4e242UL,
+    0x68ddb3f8UL, 0x1fda836eUL, 0x81be16cdUL, 0xf6b9265bUL, 0x6fb077e1UL,
+    0x18b74777UL, 0x88085ae6UL, 0xff0f6a70UL, 0x66063bcaUL, 0x11010b5cUL,
+    0x8f659effUL, 0xf862ae69UL, 0x616bffd3UL, 0x166ccf45UL, 0xa00ae278UL,
+    0xd70dd2eeUL, 0x4e048354UL, 0x3903b3c2UL, 0xa7672661UL, 0xd06016f7UL,
+    0x4969474dUL, 0x3e6e77dbUL, 0xaed16a4aUL, 0xd9d65adcUL, 0x40df0b66UL,
+    0x37d83bf0UL, 0xa9bcae53UL, 0xdebb9ec5UL, 0x47b2cf7fUL, 0x30b5ffe9UL,
+    0xbdbdf21cUL, 0xcabac28aUL, 0x53b39330UL, 0x24b4a3a6UL, 0xbad03605UL,
+    0xcdd70693UL, 0x54de5729UL, 0x23d967bfUL, 0xb3667a2eUL, 0xc4614ab8UL,
+    0x5d681b02UL, 0x2a6f2b94UL, 0xb40bbe37UL, 0xc30c8ea1UL, 0x5a05df1bUL,
+    0x2d02ef8dUL
+#ifdef BYFOUR
+  },
+  {
+    0x00000000UL, 0x191b3141UL, 0x32366282UL, 0x2b2d53c3UL, 0x646cc504UL,
+    0x7d77f445UL, 0x565aa786UL, 0x4f4196c7UL, 0xc8d98a08UL, 0xd1c2bb49UL,
+    0xfaefe88aUL, 0xe3f4d9cbUL, 0xacb54f0cUL, 0xb5ae7e4dUL, 0x9e832d8eUL,
+    0x87981ccfUL, 0x4ac21251UL, 0x53d92310UL, 0x78f470d3UL, 0x61ef4192UL,
+    0x2eaed755UL, 0x37b5e614UL, 0x1c98b5d7UL, 0x05838496UL, 0x821b9859UL,
+    0x9b00a918UL, 0xb02dfadbUL, 0xa936cb9aUL, 0xe6775d5dUL, 0xff6c6c1cUL,
+    0xd4413fdfUL, 0xcd5a0e9eUL, 0x958424a2UL, 0x8c9f15e3UL, 0xa7b24620UL,
+    0xbea97761UL, 0xf1e8e1a6UL, 0xe8f3d0e7UL, 0xc3de8324UL, 0xdac5b265UL,
+    0x5d5daeaaUL, 0x44469febUL, 0x6f6bcc28UL, 0x7670fd69UL, 0x39316baeUL,
+    0x202a5aefUL, 0x0b07092cUL, 0x121c386dUL, 0xdf4636f3UL, 0xc65d07b2UL,
+    0xed705471UL, 0xf46b6530UL, 0xbb2af3f7UL, 0xa231c2b6UL, 0x891c9175UL,
+    0x9007a034UL, 0x179fbcfbUL, 0x0e848dbaUL, 0x25a9de79UL, 0x3cb2ef38UL,
+    0x73f379ffUL, 0x6ae848beUL, 0x41c51b7dUL, 0x58de2a3cUL, 0xf0794f05UL,
+    0xe9627e44UL, 0xc24f2d87UL, 0xdb541cc6UL, 0x94158a01UL, 0x8d0ebb40UL,
+    0xa623e883UL, 0xbf38d9c2UL, 0x38a0c50dUL, 0x21bbf44cUL, 0x0a96a78fUL,
+    0x138d96ceUL, 0x5ccc0009UL, 0x45d73148UL, 0x6efa628bUL, 0x77e153caUL,
+    0xbabb5d54UL, 0xa3a06c15UL, 0x888d3fd6UL, 0x91960e97UL, 0xded79850UL,
+    0xc7cca911UL, 0xece1fad2UL, 0xf5facb93UL, 0x7262d75cUL, 0x6b79e61dUL,
+    0x4054b5deUL, 0x594f849fUL, 0x160e1258UL, 0x0f152319UL, 0x243870daUL,
+    0x3d23419bUL, 0x65fd6ba7UL, 0x7ce65ae6UL, 0x57cb0925UL, 0x4ed03864UL,
+    0x0191aea3UL, 0x188a9fe2UL, 0x33a7cc21UL, 0x2abcfd60UL, 0xad24e1afUL,
+    0xb43fd0eeUL, 0x9f12832dUL, 0x8609b26cUL, 0xc94824abUL, 0xd05315eaUL,
+    0xfb7e4629UL, 0xe2657768UL, 0x2f3f79f6UL, 0x362448b7UL, 0x1d091b74UL,
+    0x04122a35UL, 0x4b53bcf2UL, 0x52488db3UL, 0x7965de70UL, 0x607eef31UL,
+    0xe7e6f3feUL, 0xfefdc2bfUL, 0xd5d0917cUL, 0xcccba03dUL, 0x838a36faUL,
+    0x9a9107bbUL, 0xb1bc5478UL, 0xa8a76539UL, 0x3b83984bUL, 0x2298a90aUL,
+    0x09b5fac9UL, 0x10aecb88UL, 0x5fef5d4fUL, 0x46f46c0eUL, 0x6dd93fcdUL,
+    0x74c20e8cUL, 0xf35a1243UL, 0xea412302UL, 0xc16c70c1UL, 0xd8774180UL,
+    0x9736d747UL, 0x8e2de606UL, 0xa500b5c5UL, 0xbc1b8484UL, 0x71418a1aUL,
+    0x685abb5bUL, 0x4377e898UL, 0x5a6cd9d9UL, 0x152d4f1eUL, 0x0c367e5fUL,
+    0x271b2d9cUL, 0x3e001cddUL, 0xb9980012UL, 0xa0833153UL, 0x8bae6290UL,
+    0x92b553d1UL, 0xddf4c516UL, 0xc4eff457UL, 0xefc2a794UL, 0xf6d996d5UL,
+    0xae07bce9UL, 0xb71c8da8UL, 0x9c31de6bUL, 0x852aef2aUL, 0xca6b79edUL,
+    0xd37048acUL, 0xf85d1b6fUL, 0xe1462a2eUL, 0x66de36e1UL, 0x7fc507a0UL,
+    0x54e85463UL, 0x4df36522UL, 0x02b2f3e5UL, 0x1ba9c2a4UL, 0x30849167UL,
+    0x299fa026UL, 0xe4c5aeb8UL, 0xfdde9ff9UL, 0xd6f3cc3aUL, 0xcfe8fd7bUL,
+    0x80a96bbcUL, 0x99b25afdUL, 0xb29f093eUL, 0xab84387fUL, 0x2c1c24b0UL,
+    0x350715f1UL, 0x1e2a4632UL, 0x07317773UL, 0x4870e1b4UL, 0x516bd0f5UL,
+    0x7a468336UL, 0x635db277UL, 0xcbfad74eUL, 0xd2e1e60fUL, 0xf9ccb5ccUL,
+    0xe0d7848dUL, 0xaf96124aUL, 0xb68d230bUL, 0x9da070c8UL, 0x84bb4189UL,
+    0x03235d46UL, 0x1a386c07UL, 0x31153fc4UL, 0x280e0e85UL, 0x674f9842UL,
+    0x7e54a903UL, 0x5579fac0UL, 0x4c62cb81UL, 0x8138c51fUL, 0x9823f45eUL,
+    0xb30ea79dUL, 0xaa1596dcUL, 0xe554001bUL, 0xfc4f315aUL, 0xd7626299UL,
+    0xce7953d8UL, 0x49e14f17UL, 0x50fa7e56UL, 0x7bd72d95UL, 0x62cc1cd4UL,
+    0x2d8d8a13UL, 0x3496bb52UL, 0x1fbbe891UL, 0x06a0d9d0UL, 0x5e7ef3ecUL,
+    0x4765c2adUL, 0x6c48916eUL, 0x7553a02fUL, 0x3a1236e8UL, 0x230907a9UL,
+    0x0824546aUL, 0x113f652bUL, 0x96a779e4UL, 0x8fbc48a5UL, 0xa4911b66UL,
+    0xbd8a2a27UL, 0xf2cbbce0UL, 0xebd08da1UL, 0xc0fdde62UL, 0xd9e6ef23UL,
+    0x14bce1bdUL, 0x0da7d0fcUL, 0x268a833fUL, 0x3f91b27eUL, 0x70d024b9UL,
+    0x69cb15f8UL, 0x42e6463bUL, 0x5bfd777aUL, 0xdc656bb5UL, 0xc57e5af4UL,
+    0xee530937UL, 0xf7483876UL, 0xb809aeb1UL, 0xa1129ff0UL, 0x8a3fcc33UL,
+    0x9324fd72UL
+  },
+  {
+    0x00000000UL, 0x01c26a37UL, 0x0384d46eUL, 0x0246be59UL, 0x0709a8dcUL,
+    0x06cbc2ebUL, 0x048d7cb2UL, 0x054f1685UL, 0x0e1351b8UL, 0x0fd13b8fUL,
+    0x0d9785d6UL, 0x0c55efe1UL, 0x091af964UL, 0x08d89353UL, 0x0a9e2d0aUL,
+    0x0b5c473dUL, 0x1c26a370UL, 0x1de4c947UL, 0x1fa2771eUL, 0x1e601d29UL,
+    0x1b2f0bacUL, 0x1aed619bUL, 0x18abdfc2UL, 0x1969b5f5UL, 0x1235f2c8UL,
+    0x13f798ffUL, 0x11b126a6UL, 0x10734c91UL, 0x153c5a14UL, 0x14fe3023UL,
+    0x16b88e7aUL, 0x177ae44dUL, 0x384d46e0UL, 0x398f2cd7UL, 0x3bc9928eUL,
+    0x3a0bf8b9UL, 0x3f44ee3cUL, 0x3e86840bUL, 0x3cc03a52UL, 0x3d025065UL,
+    0x365e1758UL, 0x379c7d6fUL, 0x35dac336UL, 0x3418a901UL, 0x3157bf84UL,
+    0x3095d5b3UL, 0x32d36beaUL, 0x331101ddUL, 0x246be590UL, 0x25a98fa7UL,
+    0x27ef31feUL, 0x262d5bc9UL, 0x23624d4cUL, 0x22a0277bUL, 0x20e69922UL,
+    0x2124f315UL, 0x2a78b428UL, 0x2bbade1fUL, 0x29fc6046UL, 0x283e0a71UL,
+    0x2d711cf4UL, 0x2cb376c3UL, 0x2ef5c89aUL, 0x2f37a2adUL, 0x709a8dc0UL,
+    0x7158e7f7UL, 0x731e59aeUL, 0x72dc3399UL, 0x7793251cUL, 0x76514f2bUL,
+    0x7417f172UL, 0x75d59b45UL, 0x7e89dc78UL, 0x7f4bb64fUL, 0x7d0d0816UL,
+    0x7ccf6221UL, 0x798074a4UL, 0x78421e93UL, 0x7a04a0caUL, 0x7bc6cafdUL,
+    0x6cbc2eb0UL, 0x6d7e4487UL, 0x6f38fadeUL, 0x6efa90e9UL, 0x6bb5866cUL,
+    0x6a77ec5bUL, 0x68315202UL, 0x69f33835UL, 0x62af7f08UL, 0x636d153fUL,
+    0x612bab66UL, 0x60e9c151UL, 0x65a6d7d4UL, 0x6464bde3UL, 0x662203baUL,
+    0x67e0698dUL, 0x48d7cb20UL, 0x4915a117UL, 0x4b531f4eUL, 0x4a917579UL,
+    0x4fde63fcUL, 0x4e1c09cbUL, 0x4c5ab792UL, 0x4d98dda5UL, 0x46c49a98UL,
+    0x4706f0afUL, 0x45404ef6UL, 0x448224c1UL, 0x41cd3244UL, 0x400f5873UL,
+    0x4249e62aUL, 0x438b8c1dUL, 0x54f16850UL, 0x55330267UL, 0x5775bc3eUL,
+    0x56b7d609UL, 0x53f8c08cUL, 0x523aaabbUL, 0x507c14e2UL, 0x51be7ed5UL,
+    0x5ae239e8UL, 0x5b2053dfUL, 0x5966ed86UL, 0x58a487b1UL, 0x5deb9134UL,
+    0x5c29fb03UL, 0x5e6f455aUL, 0x5fad2f6dUL, 0xe1351b80UL, 0xe0f771b7UL,
+    0xe2b1cfeeUL, 0xe373a5d9UL, 0xe63cb35cUL, 0xe7fed96bUL, 0xe5b86732UL,
+    0xe47a0d05UL, 0xef264a38UL, 0xeee4200fUL, 0xeca29e56UL, 0xed60f461UL,
+    0xe82fe2e4UL, 0xe9ed88d3UL, 0xebab368aUL, 0xea695cbdUL, 0xfd13b8f0UL,
+    0xfcd1d2c7UL, 0xfe976c9eUL, 0xff5506a9UL, 0xfa1a102cUL, 0xfbd87a1bUL,
+    0xf99ec442UL, 0xf85cae75UL, 0xf300e948UL, 0xf2c2837fUL, 0xf0843d26UL,
+    0xf1465711UL, 0xf4094194UL, 0xf5cb2ba3UL, 0xf78d95faUL, 0xf64fffcdUL,
+    0xd9785d60UL, 0xd8ba3757UL, 0xdafc890eUL, 0xdb3ee339UL, 0xde71f5bcUL,
+    0xdfb39f8bUL, 0xddf521d2UL, 0xdc374be5UL, 0xd76b0cd8UL, 0xd6a966efUL,
+    0xd4efd8b6UL, 0xd52db281UL, 0xd062a404UL, 0xd1a0ce33UL, 0xd3e6706aUL,
+    0xd2241a5dUL, 0xc55efe10UL, 0xc49c9427UL, 0xc6da2a7eUL, 0xc7184049UL,
+    0xc25756ccUL, 0xc3953cfbUL, 0xc1d382a2UL, 0xc011e895UL, 0xcb4dafa8UL,
+    0xca8fc59fUL, 0xc8c97bc6UL, 0xc90b11f1UL, 0xcc440774UL, 0xcd866d43UL,
+    0xcfc0d31aUL, 0xce02b92dUL, 0x91af9640UL, 0x906dfc77UL, 0x922b422eUL,
+    0x93e92819UL, 0x96a63e9cUL, 0x976454abUL, 0x9522eaf2UL, 0x94e080c5UL,
+    0x9fbcc7f8UL, 0x9e7eadcfUL, 0x9c381396UL, 0x9dfa79a1UL, 0x98b56f24UL,
+    0x99770513UL, 0x9b31bb4aUL, 0x9af3d17dUL, 0x8d893530UL, 0x8c4b5f07UL,
+    0x8e0de15eUL, 0x8fcf8b69UL, 0x8a809decUL, 0x8b42f7dbUL, 0x89044982UL,
+    0x88c623b5UL, 0x839a6488UL, 0x82580ebfUL, 0x801eb0e6UL, 0x81dcdad1UL,
+    0x8493cc54UL, 0x8551a663UL, 0x8717183aUL, 0x86d5720dUL, 0xa9e2d0a0UL,
+    0xa820ba97UL, 0xaa6604ceUL, 0xaba46ef9UL, 0xaeeb787cUL, 0xaf29124bUL,
+    0xad6fac12UL, 0xacadc625UL, 0xa7f18118UL, 0xa633eb2fUL, 0xa4755576UL,
+    0xa5b73f41UL, 0xa0f829c4UL, 0xa13a43f3UL, 0xa37cfdaaUL, 0xa2be979dUL,
+    0xb5c473d0UL, 0xb40619e7UL, 0xb640a7beUL, 0xb782cd89UL, 0xb2cddb0cUL,
+    0xb30fb13bUL, 0xb1490f62UL, 0xb08b6555UL, 0xbbd72268UL, 0xba15485fUL,
+    0xb853f606UL, 0xb9919c31UL, 0xbcde8ab4UL, 0xbd1ce083UL, 0xbf5a5edaUL,
+    0xbe9834edUL
+  },
+  {
+    0x00000000UL, 0xb8bc6765UL, 0xaa09c88bUL, 0x12b5afeeUL, 0x8f629757UL,
+    0x37def032UL, 0x256b5fdcUL, 0x9dd738b9UL, 0xc5b428efUL, 0x7d084f8aUL,
+    0x6fbde064UL, 0xd7018701UL, 0x4ad6bfb8UL, 0xf26ad8ddUL, 0xe0df7733UL,
+    0x58631056UL, 0x5019579fUL, 0xe8a530faUL, 0xfa109f14UL, 0x42acf871UL,
+    0xdf7bc0c8UL, 0x67c7a7adUL, 0x75720843UL, 0xcdce6f26UL, 0x95ad7f70UL,
+    0x2d111815UL, 0x3fa4b7fbUL, 0x8718d09eUL, 0x1acfe827UL, 0xa2738f42UL,
+    0xb0c620acUL, 0x087a47c9UL, 0xa032af3eUL, 0x188ec85bUL, 0x0a3b67b5UL,
+    0xb28700d0UL, 0x2f503869UL, 0x97ec5f0cUL, 0x8559f0e2UL, 0x3de59787UL,
+    0x658687d1UL, 0xdd3ae0b4UL, 0xcf8f4f5aUL, 0x7733283fUL, 0xeae41086UL,
+    0x525877e3UL, 0x40edd80dUL, 0xf851bf68UL, 0xf02bf8a1UL, 0x48979fc4UL,
+    0x5a22302aUL, 0xe29e574fUL, 0x7f496ff6UL, 0xc7f50893UL, 0xd540a77dUL,
+    0x6dfcc018UL, 0x359fd04eUL, 0x8d23b72bUL, 0x9f9618c5UL, 0x272a7fa0UL,
+    0xbafd4719UL, 0x0241207cUL, 0x10f48f92UL, 0xa848e8f7UL, 0x9b14583dUL,
+    0x23a83f58UL, 0x311d90b6UL, 0x89a1f7d3UL, 0x1476cf6aUL, 0xaccaa80fUL,
+    0xbe7f07e1UL, 0x06c36084UL, 0x5ea070d2UL, 0xe61c17b7UL, 0xf4a9b859UL,
+    0x4c15df3cUL, 0xd1c2e785UL, 0x697e80e0UL, 0x7bcb2f0eUL, 0xc377486bUL,
+    0xcb0d0fa2UL, 0x73b168c7UL, 0x6104c729UL, 0xd9b8a04cUL, 0x446f98f5UL,
+    0xfcd3ff90UL, 0xee66507eUL, 0x56da371bUL, 0x0eb9274dUL, 0xb6054028UL,
+    0xa4b0efc6UL, 0x1c0c88a3UL, 0x81dbb01aUL, 0x3967d77fUL, 0x2bd27891UL,
+    0x936e1ff4UL, 0x3b26f703UL, 0x839a9066UL, 0x912f3f88UL, 0x299358edUL,
+    0xb4446054UL, 0x0cf80731UL, 0x1e4da8dfUL, 0xa6f1cfbaUL, 0xfe92dfecUL,
+    0x462eb889UL, 0x549b1767UL, 0xec277002UL, 0x71f048bbUL, 0xc94c2fdeUL,
+    0xdbf98030UL, 0x6345e755UL, 0x6b3fa09cUL, 0xd383c7f9UL, 0xc1366817UL,
+    0x798a0f72UL, 0xe45d37cbUL, 0x5ce150aeUL, 0x4e54ff40UL, 0xf6e89825UL,
+    0xae8b8873UL, 0x1637ef16UL, 0x048240f8UL, 0xbc3e279dUL, 0x21e91f24UL,
+    0x99557841UL, 0x8be0d7afUL, 0x335cb0caUL, 0xed59b63bUL, 0x55e5d15eUL,
+    0x47507eb0UL, 0xffec19d5UL, 0x623b216cUL, 0xda874609UL, 0xc832e9e7UL,
+    0x708e8e82UL, 0x28ed9ed4UL, 0x9051f9b1UL, 0x82e4565fUL, 0x3a58313aUL,
+    0xa78f0983UL, 0x1f336ee6UL, 0x0d86c108UL, 0xb53aa66dUL, 0xbd40e1a4UL,
+    0x05fc86c1UL, 0x1749292fUL, 0xaff54e4aUL, 0x322276f3UL, 0x8a9e1196UL,
+    0x982bbe78UL, 0x2097d91dUL, 0x78f4c94bUL, 0xc048ae2eUL, 0xd2fd01c0UL,
+    0x6a4166a5UL, 0xf7965e1cUL, 0x4f2a3979UL, 0x5d9f9697UL, 0xe523f1f2UL,
+    0x4d6b1905UL, 0xf5d77e60UL, 0xe762d18eUL, 0x5fdeb6ebUL, 0xc2098e52UL,
+    0x7ab5e937UL, 0x680046d9UL, 0xd0bc21bcUL, 0x88df31eaUL, 0x3063568fUL,
+    0x22d6f961UL, 0x9a6a9e04UL, 0x07bda6bdUL, 0xbf01c1d8UL, 0xadb46e36UL,
+    0x15080953UL, 0x1d724e9aUL, 0xa5ce29ffUL, 0xb77b8611UL, 0x0fc7e174UL,
+    0x9210d9cdUL, 0x2aacbea8UL, 0x38191146UL, 0x80a57623UL, 0xd8c66675UL,
+    0x607a0110UL, 0x72cfaefeUL, 0xca73c99bUL, 0x57a4f122UL, 0xef189647UL,
+    0xfdad39a9UL, 0x45115eccUL, 0x764dee06UL, 0xcef18963UL, 0xdc44268dUL,
+    0x64f841e8UL, 0xf92f7951UL, 0x41931e34UL, 0x5326b1daUL, 0xeb9ad6bfUL,
+    0xb3f9c6e9UL, 0x0b45a18cUL, 0x19f00e62UL, 0xa14c6907UL, 0x3c9b51beUL,
+    0x842736dbUL, 0x96929935UL, 0x2e2efe50UL, 0x2654b999UL, 0x9ee8defcUL,
+    0x8c5d7112UL, 0x34e11677UL, 0xa9362eceUL, 0x118a49abUL, 0x033fe645UL,
+    0xbb838120UL, 0xe3e09176UL, 0x5b5cf613UL, 0x49e959fdUL, 0xf1553e98UL,
+    0x6c820621UL, 0xd43e6144UL, 0xc68bceaaUL, 0x7e37a9cfUL, 0xd67f4138UL,
+    0x6ec3265dUL, 0x7c7689b3UL, 0xc4caeed6UL, 0x591dd66fUL, 0xe1a1b10aUL,
+    0xf3141ee4UL, 0x4ba87981UL, 0x13cb69d7UL, 0xab770eb2UL, 0xb9c2a15cUL,
+    0x017ec639UL, 0x9ca9fe80UL, 0x241599e5UL, 0x36a0360bUL, 0x8e1c516eUL,
+    0x866616a7UL, 0x3eda71c2UL, 0x2c6fde2cUL, 0x94d3b949UL, 0x090481f0UL,
+    0xb1b8e695UL, 0xa30d497bUL, 0x1bb12e1eUL, 0x43d23e48UL, 0xfb6e592dUL,
+    0xe9dbf6c3UL, 0x516791a6UL, 0xccb0a91fUL, 0x740cce7aUL, 0x66b96194UL,
+    0xde0506f1UL
+  },
+  {
+    0x00000000UL, 0x96300777UL, 0x2c610eeeUL, 0xba510999UL, 0x19c46d07UL,
+    0x8ff46a70UL, 0x35a563e9UL, 0xa395649eUL, 0x3288db0eUL, 0xa4b8dc79UL,
+    0x1ee9d5e0UL, 0x88d9d297UL, 0x2b4cb609UL, 0xbd7cb17eUL, 0x072db8e7UL,
+    0x911dbf90UL, 0x6410b71dUL, 0xf220b06aUL, 0x4871b9f3UL, 0xde41be84UL,
+    0x7dd4da1aUL, 0xebe4dd6dUL, 0x51b5d4f4UL, 0xc785d383UL, 0x56986c13UL,
+    0xc0a86b64UL, 0x7af962fdUL, 0xecc9658aUL, 0x4f5c0114UL, 0xd96c0663UL,
+    0x633d0ffaUL, 0xf50d088dUL, 0xc8206e3bUL, 0x5e10694cUL, 0xe44160d5UL,
+    0x727167a2UL, 0xd1e4033cUL, 0x47d4044bUL, 0xfd850dd2UL, 0x6bb50aa5UL,
+    0xfaa8b535UL, 0x6c98b242UL, 0xd6c9bbdbUL, 0x40f9bcacUL, 0xe36cd832UL,
+    0x755cdf45UL, 0xcf0dd6dcUL, 0x593dd1abUL, 0xac30d926UL, 0x3a00de51UL,
+    0x8051d7c8UL, 0x1661d0bfUL, 0xb5f4b421UL, 0x23c4b356UL, 0x9995bacfUL,
+    0x0fa5bdb8UL, 0x9eb80228UL, 0x0888055fUL, 0xb2d90cc6UL, 0x24e90bb1UL,
+    0x877c6f2fUL, 0x114c6858UL, 0xab1d61c1UL, 0x3d2d66b6UL, 0x9041dc76UL,
+    0x0671db01UL, 0xbc20d298UL, 0x2a10d5efUL, 0x8985b171UL, 0x1fb5b606UL,
+    0xa5e4bf9fUL, 0x33d4b8e8UL, 0xa2c90778UL, 0x34f9000fUL, 0x8ea80996UL,
+    0x18980ee1UL, 0xbb0d6a7fUL, 0x2d3d6d08UL, 0x976c6491UL, 0x015c63e6UL,
+    0xf4516b6bUL, 0x62616c1cUL, 0xd8306585UL, 0x4e0062f2UL, 0xed95066cUL,
+    0x7ba5011bUL, 0xc1f40882UL, 0x57c40ff5UL, 0xc6d9b065UL, 0x50e9b712UL,
+    0xeab8be8bUL, 0x7c88b9fcUL, 0xdf1ddd62UL, 0x492dda15UL, 0xf37cd38cUL,
+    0x654cd4fbUL, 0x5861b24dUL, 0xce51b53aUL, 0x7400bca3UL, 0xe230bbd4UL,
+    0x41a5df4aUL, 0xd795d83dUL, 0x6dc4d1a4UL, 0xfbf4d6d3UL, 0x6ae96943UL,
+    0xfcd96e34UL, 0x468867adUL, 0xd0b860daUL, 0x732d0444UL, 0xe51d0333UL,
+    0x5f4c0aaaUL, 0xc97c0dddUL, 0x3c710550UL, 0xaa410227UL, 0x10100bbeUL,
+    0x86200cc9UL, 0x25b56857UL, 0xb3856f20UL, 0x09d466b9UL, 0x9fe461ceUL,
+    0x0ef9de5eUL, 0x98c9d929UL, 0x2298d0b0UL, 0xb4a8d7c7UL, 0x173db359UL,
+    0x810db42eUL, 0x3b5cbdb7UL, 0xad6cbac0UL, 0x2083b8edUL, 0xb6b3bf9aUL,
+    0x0ce2b603UL, 0x9ad2b174UL, 0x3947d5eaUL, 0xaf77d29dUL, 0x1526db04UL,
+    0x8316dc73UL, 0x120b63e3UL, 0x843b6494UL, 0x3e6a6d0dUL, 0xa85a6a7aUL,
+    0x0bcf0ee4UL, 0x9dff0993UL, 0x27ae000aUL, 0xb19e077dUL, 0x44930ff0UL,
+    0xd2a30887UL, 0x68f2011eUL, 0xfec20669UL, 0x5d5762f7UL, 0xcb676580UL,
+    0x71366c19UL, 0xe7066b6eUL, 0x761bd4feUL, 0xe02bd389UL, 0x5a7ada10UL,
+    0xcc4add67UL, 0x6fdfb9f9UL, 0xf9efbe8eUL, 0x43beb717UL, 0xd58eb060UL,
+    0xe8a3d6d6UL, 0x7e93d1a1UL, 0xc4c2d838UL, 0x52f2df4fUL, 0xf167bbd1UL,
+    0x6757bca6UL, 0xdd06b53fUL, 0x4b36b248UL, 0xda2b0dd8UL, 0x4c1b0aafUL,
+    0xf64a0336UL, 0x607a0441UL, 0xc3ef60dfUL, 0x55df67a8UL, 0xef8e6e31UL,
+    0x79be6946UL, 0x8cb361cbUL, 0x1a8366bcUL, 0xa0d26f25UL, 0x36e26852UL,
+    0x95770cccUL, 0x03470bbbUL, 0xb9160222UL, 0x2f260555UL, 0xbe3bbac5UL,
+    0x280bbdb2UL, 0x925ab42bUL, 0x046ab35cUL, 0xa7ffd7c2UL, 0x31cfd0b5UL,
+    0x8b9ed92cUL, 0x1daede5bUL, 0xb0c2649bUL, 0x26f263ecUL, 0x9ca36a75UL,
+    0x0a936d02UL, 0xa906099cUL, 0x3f360eebUL, 0x85670772UL, 0x13570005UL,
+    0x824abf95UL, 0x147ab8e2UL, 0xae2bb17bUL, 0x381bb60cUL, 0x9b8ed292UL,
+    0x0dbed5e5UL, 0xb7efdc7cUL, 0x21dfdb0bUL, 0xd4d2d386UL, 0x42e2d4f1UL,
+    0xf8b3dd68UL, 0x6e83da1fUL, 0xcd16be81UL, 0x5b26b9f6UL, 0xe177b06fUL,
+    0x7747b718UL, 0xe65a0888UL, 0x706a0fffUL, 0xca3b0666UL, 0x5c0b0111UL,
+    0xff9e658fUL, 0x69ae62f8UL, 0xd3ff6b61UL, 0x45cf6c16UL, 0x78e20aa0UL,
+    0xeed20dd7UL, 0x5483044eUL, 0xc2b30339UL, 0x612667a7UL, 0xf71660d0UL,
+    0x4d476949UL, 0xdb776e3eUL, 0x4a6ad1aeUL, 0xdc5ad6d9UL, 0x660bdf40UL,
+    0xf03bd837UL, 0x53aebca9UL, 0xc59ebbdeUL, 0x7fcfb247UL, 0xe9ffb530UL,
+    0x1cf2bdbdUL, 0x8ac2bacaUL, 0x3093b353UL, 0xa6a3b424UL, 0x0536d0baUL,
+    0x9306d7cdUL, 0x2957de54UL, 0xbf67d923UL, 0x2e7a66b3UL, 0xb84a61c4UL,
+    0x021b685dUL, 0x942b6f2aUL, 0x37be0bb4UL, 0xa18e0cc3UL, 0x1bdf055aUL,
+    0x8def022dUL
+  },
+  {
+    0x00000000UL, 0x41311b19UL, 0x82623632UL, 0xc3532d2bUL, 0x04c56c64UL,
+    0x45f4777dUL, 0x86a75a56UL, 0xc796414fUL, 0x088ad9c8UL, 0x49bbc2d1UL,
+    0x8ae8effaUL, 0xcbd9f4e3UL, 0x0c4fb5acUL, 0x4d7eaeb5UL, 0x8e2d839eUL,
+    0xcf1c9887UL, 0x5112c24aUL, 0x1023d953UL, 0xd370f478UL, 0x9241ef61UL,
+    0x55d7ae2eUL, 0x14e6b537UL, 0xd7b5981cUL, 0x96848305UL, 0x59981b82UL,
+    0x18a9009bUL, 0xdbfa2db0UL, 0x9acb36a9UL, 0x5d5d77e6UL, 0x1c6c6cffUL,
+    0xdf3f41d4UL, 0x9e0e5acdUL, 0xa2248495UL, 0xe3159f8cUL, 0x2046b2a7UL,
+    0x6177a9beUL, 0xa6e1e8f1UL, 0xe7d0f3e8UL, 0x2483dec3UL, 0x65b2c5daUL,
+    0xaaae5d5dUL, 0xeb9f4644UL, 0x28cc6b6fUL, 0x69fd7076UL, 0xae6b3139UL,
+    0xef5a2a20UL, 0x2c09070bUL, 0x6d381c12UL, 0xf33646dfUL, 0xb2075dc6UL,
+    0x715470edUL, 0x30656bf4UL, 0xf7f32abbUL, 0xb6c231a2UL, 0x75911c89UL,
+    0x34a00790UL, 0xfbbc9f17UL, 0xba8d840eUL, 0x79dea925UL, 0x38efb23cUL,
+    0xff79f373UL, 0xbe48e86aUL, 0x7d1bc541UL, 0x3c2ade58UL, 0x054f79f0UL,
+    0x447e62e9UL, 0x872d4fc2UL, 0xc61c54dbUL, 0x018a1594UL, 0x40bb0e8dUL,
+    0x83e823a6UL, 0xc2d938bfUL, 0x0dc5a038UL, 0x4cf4bb21UL, 0x8fa7960aUL,
+    0xce968d13UL, 0x0900cc5cUL, 0x4831d745UL, 0x8b62fa6eUL, 0xca53e177UL,
+    0x545dbbbaUL, 0x156ca0a3UL, 0xd63f8d88UL, 0x970e9691UL, 0x5098d7deUL,
+    0x11a9ccc7UL, 0xd2fae1ecUL, 0x93cbfaf5UL, 0x5cd76272UL, 0x1de6796bUL,
+    0xdeb55440UL, 0x9f844f59UL, 0x58120e16UL, 0x1923150fUL, 0xda703824UL,
+    0x9b41233dUL, 0xa76bfd65UL, 0xe65ae67cUL, 0x2509cb57UL, 0x6438d04eUL,
+    0xa3ae9101UL, 0xe29f8a18UL, 0x21cca733UL, 0x60fdbc2aUL, 0xafe124adUL,
+    0xeed03fb4UL, 0x2d83129fUL, 0x6cb20986UL, 0xab2448c9UL, 0xea1553d0UL,
+    0x29467efbUL, 0x687765e2UL, 0xf6793f2fUL, 0xb7482436UL, 0x741b091dUL,
+    0x352a1204UL, 0xf2bc534bUL, 0xb38d4852UL, 0x70de6579UL, 0x31ef7e60UL,
+    0xfef3e6e7UL, 0xbfc2fdfeUL, 0x7c91d0d5UL, 0x3da0cbccUL, 0xfa368a83UL,
+    0xbb07919aUL, 0x7854bcb1UL, 0x3965a7a8UL, 0x4b98833bUL, 0x0aa99822UL,
+    0xc9fab509UL, 0x88cbae10UL, 0x4f5def5fUL, 0x0e6cf446UL, 0xcd3fd96dUL,
+    0x8c0ec274UL, 0x43125af3UL, 0x022341eaUL, 0xc1706cc1UL, 0x804177d8UL,
+    0x47d73697UL, 0x06e62d8eUL, 0xc5b500a5UL, 0x84841bbcUL, 0x1a8a4171UL,
+    0x5bbb5a68UL, 0x98e87743UL, 0xd9d96c5aUL, 0x1e4f2d15UL, 0x5f7e360cUL,
+    0x9c2d1b27UL, 0xdd1c003eUL, 0x120098b9UL, 0x533183a0UL, 0x9062ae8bUL,
+    0xd153b592UL, 0x16c5f4ddUL, 0x57f4efc4UL, 0x94a7c2efUL, 0xd596d9f6UL,
+    0xe9bc07aeUL, 0xa88d1cb7UL, 0x6bde319cUL, 0x2aef2a85UL, 0xed796bcaUL,
+    0xac4870d3UL, 0x6f1b5df8UL, 0x2e2a46e1UL, 0xe136de66UL, 0xa007c57fUL,
+    0x6354e854UL, 0x2265f34dUL, 0xe5f3b202UL, 0xa4c2a91bUL, 0x67918430UL,
+    0x26a09f29UL, 0xb8aec5e4UL, 0xf99fdefdUL, 0x3accf3d6UL, 0x7bfde8cfUL,
+    0xbc6ba980UL, 0xfd5ab299UL, 0x3e099fb2UL, 0x7f3884abUL, 0xb0241c2cUL,
+    0xf1150735UL, 0x32462a1eUL, 0x73773107UL, 0xb4e17048UL, 0xf5d06b51UL,
+    0x3683467aUL, 0x77b25d63UL, 0x4ed7facbUL, 0x0fe6e1d2UL, 0xccb5ccf9UL,
+    0x8d84d7e0UL, 0x4a1296afUL, 0x0b238db6UL, 0xc870a09dUL, 0x8941bb84UL,
+    0x465d2303UL, 0x076c381aUL, 0xc43f1531UL, 0x850e0e28UL, 0x42984f67UL,
+    0x03a9547eUL, 0xc0fa7955UL, 0x81cb624cUL, 0x1fc53881UL, 0x5ef42398UL,
+    0x9da70eb3UL, 0xdc9615aaUL, 0x1b0054e5UL, 0x5a314ffcUL, 0x996262d7UL,
+    0xd85379ceUL, 0x174fe149UL, 0x567efa50UL, 0x952dd77bUL, 0xd41ccc62UL,
+    0x138a8d2dUL, 0x52bb9634UL, 0x91e8bb1fUL, 0xd0d9a006UL, 0xecf37e5eUL,
+    0xadc26547UL, 0x6e91486cUL, 0x2fa05375UL, 0xe836123aUL, 0xa9070923UL,
+    0x6a542408UL, 0x2b653f11UL, 0xe479a796UL, 0xa548bc8fUL, 0x661b91a4UL,
+    0x272a8abdUL, 0xe0bccbf2UL, 0xa18dd0ebUL, 0x62defdc0UL, 0x23efe6d9UL,
+    0xbde1bc14UL, 0xfcd0a70dUL, 0x3f838a26UL, 0x7eb2913fUL, 0xb924d070UL,
+    0xf815cb69UL, 0x3b46e642UL, 0x7a77fd5bUL, 0xb56b65dcUL, 0xf45a7ec5UL,
+    0x370953eeUL, 0x763848f7UL, 0xb1ae09b8UL, 0xf09f12a1UL, 0x33cc3f8aUL,
+    0x72fd2493UL
+  },
+  {
+    0x00000000UL, 0x376ac201UL, 0x6ed48403UL, 0x59be4602UL, 0xdca80907UL,
+    0xebc2cb06UL, 0xb27c8d04UL, 0x85164f05UL, 0xb851130eUL, 0x8f3bd10fUL,
+    0xd685970dUL, 0xe1ef550cUL, 0x64f91a09UL, 0x5393d808UL, 0x0a2d9e0aUL,
+    0x3d475c0bUL, 0x70a3261cUL, 0x47c9e41dUL, 0x1e77a21fUL, 0x291d601eUL,
+    0xac0b2f1bUL, 0x9b61ed1aUL, 0xc2dfab18UL, 0xf5b56919UL, 0xc8f23512UL,
+    0xff98f713UL, 0xa626b111UL, 0x914c7310UL, 0x145a3c15UL, 0x2330fe14UL,
+    0x7a8eb816UL, 0x4de47a17UL, 0xe0464d38UL, 0xd72c8f39UL, 0x8e92c93bUL,
+    0xb9f80b3aUL, 0x3cee443fUL, 0x0b84863eUL, 0x523ac03cUL, 0x6550023dUL,
+    0x58175e36UL, 0x6f7d9c37UL, 0x36c3da35UL, 0x01a91834UL, 0x84bf5731UL,
+    0xb3d59530UL, 0xea6bd332UL, 0xdd011133UL, 0x90e56b24UL, 0xa78fa925UL,
+    0xfe31ef27UL, 0xc95b2d26UL, 0x4c4d6223UL, 0x7b27a022UL, 0x2299e620UL,
+    0x15f32421UL, 0x28b4782aUL, 0x1fdeba2bUL, 0x4660fc29UL, 0x710a3e28UL,
+    0xf41c712dUL, 0xc376b32cUL, 0x9ac8f52eUL, 0xada2372fUL, 0xc08d9a70UL,
+    0xf7e75871UL, 0xae591e73UL, 0x9933dc72UL, 0x1c259377UL, 0x2b4f5176UL,
+    0x72f11774UL, 0x459bd575UL, 0x78dc897eUL, 0x4fb64b7fUL, 0x16080d7dUL,
+    0x2162cf7cUL, 0xa4748079UL, 0x931e4278UL, 0xcaa0047aUL, 0xfdcac67bUL,
+    0xb02ebc6cUL, 0x87447e6dUL, 0xdefa386fUL, 0xe990fa6eUL, 0x6c86b56bUL,
+    0x5bec776aUL, 0x02523168UL, 0x3538f369UL, 0x087faf62UL, 0x3f156d63UL,
+    0x66ab2b61UL, 0x51c1e960UL, 0xd4d7a665UL, 0xe3bd6464UL, 0xba032266UL,
+    0x8d69e067UL, 0x20cbd748UL, 0x17a11549UL, 0x4e1f534bUL, 0x7975914aUL,
+    0xfc63de4fUL, 0xcb091c4eUL, 0x92b75a4cUL, 0xa5dd984dUL, 0x989ac446UL,
+    0xaff00647UL, 0xf64e4045UL, 0xc1248244UL, 0x4432cd41UL, 0x73580f40UL,
+    0x2ae64942UL, 0x1d8c8b43UL, 0x5068f154UL, 0x67023355UL, 0x3ebc7557UL,
+    0x09d6b756UL, 0x8cc0f853UL, 0xbbaa3a52UL, 0xe2147c50UL, 0xd57ebe51UL,
+    0xe839e25aUL, 0xdf53205bUL, 0x86ed6659UL, 0xb187a458UL, 0x3491eb5dUL,
+    0x03fb295cUL, 0x5a456f5eUL, 0x6d2fad5fUL, 0x801b35e1UL, 0xb771f7e0UL,
+    0xeecfb1e2UL, 0xd9a573e3UL, 0x5cb33ce6UL, 0x6bd9fee7UL, 0x3267b8e5UL,
+    0x050d7ae4UL, 0x384a26efUL, 0x0f20e4eeUL, 0x569ea2ecUL, 0x61f460edUL,
+    0xe4e22fe8UL, 0xd388ede9UL, 0x8a36abebUL, 0xbd5c69eaUL, 0xf0b813fdUL,
+    0xc7d2d1fcUL, 0x9e6c97feUL, 0xa90655ffUL, 0x2c101afaUL, 0x1b7ad8fbUL,
+    0x42c49ef9UL, 0x75ae5cf8UL, 0x48e900f3UL, 0x7f83c2f2UL, 0x263d84f0UL,
+    0x115746f1UL, 0x944109f4UL, 0xa32bcbf5UL, 0xfa958df7UL, 0xcdff4ff6UL,
+    0x605d78d9UL, 0x5737bad8UL, 0x0e89fcdaUL, 0x39e33edbUL, 0xbcf571deUL,
+    0x8b9fb3dfUL, 0xd221f5ddUL, 0xe54b37dcUL, 0xd80c6bd7UL, 0xef66a9d6UL,
+    0xb6d8efd4UL, 0x81b22dd5UL, 0x04a462d0UL, 0x33cea0d1UL, 0x6a70e6d3UL,
+    0x5d1a24d2UL, 0x10fe5ec5UL, 0x27949cc4UL, 0x7e2adac6UL, 0x494018c7UL,
+    0xcc5657c2UL, 0xfb3c95c3UL, 0xa282d3c1UL, 0x95e811c0UL, 0xa8af4dcbUL,
+    0x9fc58fcaUL, 0xc67bc9c8UL, 0xf1110bc9UL, 0x740744ccUL, 0x436d86cdUL,
+    0x1ad3c0cfUL, 0x2db902ceUL, 0x4096af91UL, 0x77fc6d90UL, 0x2e422b92UL,
+    0x1928e993UL, 0x9c3ea696UL, 0xab546497UL, 0xf2ea2295UL, 0xc580e094UL,
+    0xf8c7bc9fUL, 0xcfad7e9eUL, 0x9613389cUL, 0xa179fa9dUL, 0x246fb598UL,
+    0x13057799UL, 0x4abb319bUL, 0x7dd1f39aUL, 0x3035898dUL, 0x075f4b8cUL,
+    0x5ee10d8eUL, 0x698bcf8fUL, 0xec9d808aUL, 0xdbf7428bUL, 0x82490489UL,
+    0xb523c688UL, 0x88649a83UL, 0xbf0e5882UL, 0xe6b01e80UL, 0xd1dadc81UL,
+    0x54cc9384UL, 0x63a65185UL, 0x3a181787UL, 0x0d72d586UL, 0xa0d0e2a9UL,
+    0x97ba20a8UL, 0xce0466aaUL, 0xf96ea4abUL, 0x7c78ebaeUL, 0x4b1229afUL,
+    0x12ac6fadUL, 0x25c6adacUL, 0x1881f1a7UL, 0x2feb33a6UL, 0x765575a4UL,
+    0x413fb7a5UL, 0xc429f8a0UL, 0xf3433aa1UL, 0xaafd7ca3UL, 0x9d97bea2UL,
+    0xd073c4b5UL, 0xe71906b4UL, 0xbea740b6UL, 0x89cd82b7UL, 0x0cdbcdb2UL,
+    0x3bb10fb3UL, 0x620f49b1UL, 0x55658bb0UL, 0x6822d7bbUL, 0x5f4815baUL,
+    0x06f653b8UL, 0x319c91b9UL, 0xb48adebcUL, 0x83e01cbdUL, 0xda5e5abfUL,
+    0xed3498beUL
+  },
+  {
+    0x00000000UL, 0x6567bcb8UL, 0x8bc809aaUL, 0xeeafb512UL, 0x5797628fUL,
+    0x32f0de37UL, 0xdc5f6b25UL, 0xb938d79dUL, 0xef28b4c5UL, 0x8a4f087dUL,
+    0x64e0bd6fUL, 0x018701d7UL, 0xb8bfd64aUL, 0xddd86af2UL, 0x3377dfe0UL,
+    0x56106358UL, 0x9f571950UL, 0xfa30a5e8UL, 0x149f10faUL, 0x71f8ac42UL,
+    0xc8c07bdfUL, 0xada7c767UL, 0x43087275UL, 0x266fcecdUL, 0x707fad95UL,
+    0x1518112dUL, 0xfbb7a43fUL, 0x9ed01887UL, 0x27e8cf1aUL, 0x428f73a2UL,
+    0xac20c6b0UL, 0xc9477a08UL, 0x3eaf32a0UL, 0x5bc88e18UL, 0xb5673b0aUL,
+    0xd00087b2UL, 0x6938502fUL, 0x0c5fec97UL, 0xe2f05985UL, 0x8797e53dUL,
+    0xd1878665UL, 0xb4e03addUL, 0x5a4f8fcfUL, 0x3f283377UL, 0x8610e4eaUL,
+    0xe3775852UL, 0x0dd8ed40UL, 0x68bf51f8UL, 0xa1f82bf0UL, 0xc49f9748UL,
+    0x2a30225aUL, 0x4f579ee2UL, 0xf66f497fUL, 0x9308f5c7UL, 0x7da740d5UL,
+    0x18c0fc6dUL, 0x4ed09f35UL, 0x2bb7238dUL, 0xc518969fUL, 0xa07f2a27UL,
+    0x1947fdbaUL, 0x7c204102UL, 0x928ff410UL, 0xf7e848a8UL, 0x3d58149bUL,
+    0x583fa823UL, 0xb6901d31UL, 0xd3f7a189UL, 0x6acf7614UL, 0x0fa8caacUL,
+    0xe1077fbeUL, 0x8460c306UL, 0xd270a05eUL, 0xb7171ce6UL, 0x59b8a9f4UL,
+    0x3cdf154cUL, 0x85e7c2d1UL, 0xe0807e69UL, 0x0e2fcb7bUL, 0x6b4877c3UL,
+    0xa20f0dcbUL, 0xc768b173UL, 0x29c70461UL, 0x4ca0b8d9UL, 0xf5986f44UL,
+    0x90ffd3fcUL, 0x7e5066eeUL, 0x1b37da56UL, 0x4d27b90eUL, 0x284005b6UL,
+    0xc6efb0a4UL, 0xa3880c1cUL, 0x1ab0db81UL, 0x7fd76739UL, 0x9178d22bUL,
+    0xf41f6e93UL, 0x03f7263bUL, 0x66909a83UL, 0x883f2f91UL, 0xed589329UL,
+    0x546044b4UL, 0x3107f80cUL, 0xdfa84d1eUL, 0xbacff1a6UL, 0xecdf92feUL,
+    0x89b82e46UL, 0x67179b54UL, 0x027027ecUL, 0xbb48f071UL, 0xde2f4cc9UL,
+    0x3080f9dbUL, 0x55e74563UL, 0x9ca03f6bUL, 0xf9c783d3UL, 0x176836c1UL,
+    0x720f8a79UL, 0xcb375de4UL, 0xae50e15cUL, 0x40ff544eUL, 0x2598e8f6UL,
+    0x73888baeUL, 0x16ef3716UL, 0xf8408204UL, 0x9d273ebcUL, 0x241fe921UL,
+    0x41785599UL, 0xafd7e08bUL, 0xcab05c33UL, 0x3bb659edUL, 0x5ed1e555UL,
+    0xb07e5047UL, 0xd519ecffUL, 0x6c213b62UL, 0x094687daUL, 0xe7e932c8UL,
+    0x828e8e70UL, 0xd49eed28UL, 0xb1f95190UL, 0x5f56e482UL, 0x3a31583aUL,
+    0x83098fa7UL, 0xe66e331fUL, 0x08c1860dUL, 0x6da63ab5UL, 0xa4e140bdUL,
+    0xc186fc05UL, 0x2f294917UL, 0x4a4ef5afUL, 0xf3762232UL, 0x96119e8aUL,
+    0x78be2b98UL, 0x1dd99720UL, 0x4bc9f478UL, 0x2eae48c0UL, 0xc001fdd2UL,
+    0xa566416aUL, 0x1c5e96f7UL, 0x79392a4fUL, 0x97969f5dUL, 0xf2f123e5UL,
+    0x05196b4dUL, 0x607ed7f5UL, 0x8ed162e7UL, 0xebb6de5fUL, 0x528e09c2UL,
+    0x37e9b57aUL, 0xd9460068UL, 0xbc21bcd0UL, 0xea31df88UL, 0x8f566330UL,
+    0x61f9d622UL, 0x049e6a9aUL, 0xbda6bd07UL, 0xd8c101bfUL, 0x366eb4adUL,
+    0x53090815UL, 0x9a4e721dUL, 0xff29cea5UL, 0x11867bb7UL, 0x74e1c70fUL,
+    0xcdd91092UL, 0xa8beac2aUL, 0x46111938UL, 0x2376a580UL, 0x7566c6d8UL,
+    0x10017a60UL, 0xfeaecf72UL, 0x9bc973caUL, 0x22f1a457UL, 0x479618efUL,
+    0xa939adfdUL, 0xcc5e1145UL, 0x06ee4d76UL, 0x6389f1ceUL, 0x8d2644dcUL,
+    0xe841f864UL, 0x51792ff9UL, 0x341e9341UL, 0xdab12653UL, 0xbfd69aebUL,
+    0xe9c6f9b3UL, 0x8ca1450bUL, 0x620ef019UL, 0x07694ca1UL, 0xbe519b3cUL,
+    0xdb362784UL, 0x35999296UL, 0x50fe2e2eUL, 0x99b95426UL, 0xfcdee89eUL,
+    0x12715d8cUL, 0x7716e134UL, 0xce2e36a9UL, 0xab498a11UL, 0x45e63f03UL,
+    0x208183bbUL, 0x7691e0e3UL, 0x13f65c5bUL, 0xfd59e949UL, 0x983e55f1UL,
+    0x2106826cUL, 0x44613ed4UL, 0xaace8bc6UL, 0xcfa9377eUL, 0x38417fd6UL,
+    0x5d26c36eUL, 0xb389767cUL, 0xd6eecac4UL, 0x6fd61d59UL, 0x0ab1a1e1UL,
+    0xe41e14f3UL, 0x8179a84bUL, 0xd769cb13UL, 0xb20e77abUL, 0x5ca1c2b9UL,
+    0x39c67e01UL, 0x80fea99cUL, 0xe5991524UL, 0x0b36a036UL, 0x6e511c8eUL,
+    0xa7166686UL, 0xc271da3eUL, 0x2cde6f2cUL, 0x49b9d394UL, 0xf0810409UL,
+    0x95e6b8b1UL, 0x7b490da3UL, 0x1e2eb11bUL, 0x483ed243UL, 0x2d596efbUL,
+    0xc3f6dbe9UL, 0xa6916751UL, 0x1fa9b0ccUL, 0x7ace0c74UL, 0x9461b966UL,
+    0xf10605deUL
+#endif
+  }
+};

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/zlib/deflate.h

@@ -0,0 +1,349 @@
+/* deflate.h -- internal compression state
+ * Copyright (C) 1995-2016 Jean-loup Gailly
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef DEFLATE_H
+#define DEFLATE_H
+
+#include "zutil.h"
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+   trailer creation by deflate().  NO_GZIP would be used to avoid linking in
+   the crc code when it is not needed.  For shared libraries, gzip encoding
+   should be left enabled. */
+#ifndef NO_GZIP
+#  define GZIP
+#endif
+
+/* ===========================================================================
+ * Internal compression state.
+ */
+
+#define LENGTH_CODES 29
+/* number of length codes, not counting the special END_BLOCK code */
+
+#define LITERALS  256
+/* number of literal bytes 0..255 */
+
+#define L_CODES (LITERALS+1+LENGTH_CODES)
+/* number of Literal or Length codes, including the END_BLOCK code */
+
+#define D_CODES   30
+/* number of distance codes */
+
+#define BL_CODES  19
+/* number of codes used to transfer the bit lengths */
+
+#define HEAP_SIZE (2*L_CODES+1)
+/* maximum heap size */
+
+#define MAX_BITS 15
+/* All codes must not exceed MAX_BITS bits */
+
+#define Buf_size 16
+/* size of bit buffer in bi_buf */
+
+#define INIT_STATE    42    /* zlib header -> BUSY_STATE */
+#ifdef GZIP
+#  define GZIP_STATE  57    /* gzip header -> BUSY_STATE | EXTRA_STATE */
+#endif
+#define EXTRA_STATE   69    /* gzip extra block -> NAME_STATE */
+#define NAME_STATE    73    /* gzip file name -> COMMENT_STATE */
+#define COMMENT_STATE 91    /* gzip comment -> HCRC_STATE */
+#define HCRC_STATE   103    /* gzip header CRC -> BUSY_STATE */
+#define BUSY_STATE   113    /* deflate -> FINISH_STATE */
+#define FINISH_STATE 666    /* stream complete */
+/* Stream status */
+
+
+/* Data structure describing a single value and its code string. */
+typedef struct ct_data_s {
+    union {
+        ush  freq;       /* frequency count */
+        ush  code;       /* bit string */
+    } fc;
+    union {
+        ush  dad;        /* father node in Huffman tree */
+        ush  len;        /* length of bit string */
+    } dl;
+} FAR ct_data;
+
+#define Freq fc.freq
+#define Code fc.code
+#define Dad  dl.dad
+#define Len  dl.len
+
+typedef struct static_tree_desc_s  static_tree_desc;
+
+typedef struct tree_desc_s {
+    ct_data *dyn_tree;           /* the dynamic tree */
+    int     max_code;            /* largest code with non zero frequency */
+    const static_tree_desc *stat_desc;  /* the corresponding static tree */
+} FAR tree_desc;
+
+typedef ush Pos;
+typedef Pos FAR Posf;
+typedef unsigned IPos;
+
+/* A Pos is an index in the character window. We use short instead of int to
+ * save space in the various tables. IPos is used only for parameter passing.
+ */
+
+typedef struct internal_state {
+    z_streamp strm;      /* pointer back to this zlib stream */
+    int   status;        /* as the name implies */
+    Bytef *pending_buf;  /* output still pending */
+    ulg   pending_buf_size; /* size of pending_buf */
+    Bytef *pending_out;  /* next pending byte to output to the stream */
+    ulg   pending;       /* nb of bytes in the pending buffer */
+    int   wrap;          /* bit 0 true for zlib, bit 1 true for gzip */
+    gz_headerp  gzhead;  /* gzip header information to write */
+    ulg   gzindex;       /* where in extra, name, or comment */
+    Byte  method;        /* can only be DEFLATED */
+    int   last_flush;    /* value of flush param for previous deflate call */
+
+                /* used by deflate.c: */
+
+    uInt  w_size;        /* LZ77 window size (32K by default) */
+    uInt  w_bits;        /* log2(w_size)  (8..16) */
+    uInt  w_mask;        /* w_size - 1 */
+
+    Bytef *window;
+    /* Sliding window. Input bytes are read into the second half of the window,
+     * and move to the first half later to keep a dictionary of at least wSize
+     * bytes. With this organization, matches are limited to a distance of
+     * wSize-MAX_MATCH bytes, but this ensures that IO is always
+     * performed with a length multiple of the block size. Also, it limits
+     * the window size to 64K, which is quite useful on MSDOS.
+     * To do: use the user input buffer as sliding window.
+     */
+
+    ulg window_size;
+    /* Actual size of window: 2*wSize, except when the user input buffer
+     * is directly used as sliding window.
+     */
+
+    Posf *prev;
+    /* Link to older string with same hash index. To limit the size of this
+     * array to 64K, this link is maintained only for the last 32K strings.
+     * An index in this array is thus a window index modulo 32K.
+     */
+
+    Posf *head; /* Heads of the hash chains or NIL. */
+
+    uInt  ins_h;          /* hash index of string to be inserted */
+    uInt  hash_size;      /* number of elements in hash table */
+    uInt  hash_bits;      /* log2(hash_size) */
+    uInt  hash_mask;      /* hash_size-1 */
+
+    uInt  hash_shift;
+    /* Number of bits by which ins_h must be shifted at each input
+     * step. It must be such that after MIN_MATCH steps, the oldest
+     * byte no longer takes part in the hash key, that is:
+     *   hash_shift * MIN_MATCH >= hash_bits
+     */
+
+    long block_start;
+    /* Window position at the beginning of the current output block. Gets
+     * negative when the window is moved backwards.
+     */
+
+    uInt match_length;           /* length of best match */
+    IPos prev_match;             /* previous match */
+    int match_available;         /* set if previous match exists */
+    uInt strstart;               /* start of string to insert */
+    uInt match_start;            /* start of matching string */
+    uInt lookahead;              /* number of valid bytes ahead in window */
+
+    uInt prev_length;
+    /* Length of the best match at previous step. Matches not greater than this
+     * are discarded. This is used in the lazy match evaluation.
+     */
+
+    uInt max_chain_length;
+    /* To speed up deflation, hash chains are never searched beyond this
+     * length.  A higher limit improves compression ratio but degrades the
+     * speed.
+     */
+
+    uInt max_lazy_match;
+    /* Attempt to find a better match only when the current match is strictly
+     * smaller than this value. This mechanism is used only for compression
+     * levels >= 4.
+     */
+#   define max_insert_length  max_lazy_match
+    /* Insert new strings in the hash table only if the match length is not
+     * greater than this length. This saves time but degrades compression.
+     * max_insert_length is used only for compression levels <= 3.
+     */
+
+    int level;    /* compression level (1..9) */
+    int strategy; /* favor or force Huffman coding*/
+
+    uInt good_match;
+    /* Use a faster search when the previous match is longer than this */
+
+    int nice_match; /* Stop searching when current match exceeds this */
+
+                /* used by trees.c: */
+    /* Didn't use ct_data typedef below to suppress compiler warning */
+    struct ct_data_s dyn_ltree[HEAP_SIZE];   /* literal and length tree */
+    struct ct_data_s dyn_dtree[2*D_CODES+1]; /* distance tree */
+    struct ct_data_s bl_tree[2*BL_CODES+1];  /* Huffman tree for bit lengths */
+
+    struct tree_desc_s l_desc;               /* desc. for literal tree */
+    struct tree_desc_s d_desc;               /* desc. for distance tree */
+    struct tree_desc_s bl_desc;              /* desc. for bit length tree */
+
+    ush bl_count[MAX_BITS+1];
+    /* number of codes at each bit length for an optimal tree */
+
+    int heap[2*L_CODES+1];      /* heap used to build the Huffman trees */
+    int heap_len;               /* number of elements in the heap */
+    int heap_max;               /* element of largest frequency */
+    /* The sons of heap[n] are heap[2*n] and heap[2*n+1]. heap[0] is not used.
+     * The same heap array is used to build all trees.
+     */
+
+    uch depth[2*L_CODES+1];
+    /* Depth of each subtree used as tie breaker for trees of equal frequency
+     */
+
+    uchf *l_buf;          /* buffer for literals or lengths */
+
+    uInt  lit_bufsize;
+    /* Size of match buffer for literals/lengths.  There are 4 reasons for
+     * limiting lit_bufsize to 64K:
+     *   - frequencies can be kept in 16 bit counters
+     *   - if compression is not successful for the first block, all input
+     *     data is still in the window so we can still emit a stored block even
+     *     when input comes from standard input.  (This can also be done for
+     *     all blocks if lit_bufsize is not greater than 32K.)
+     *   - if compression is not successful for a file smaller than 64K, we can
+     *     even emit a stored file instead of a stored block (saving 5 bytes).
+     *     This is applicable only for zip (not gzip or zlib).
+     *   - creating new Huffman trees less frequently may not provide fast
+     *     adaptation to changes in the input data statistics. (Take for
+     *     example a binary file with poorly compressible code followed by
+     *     a highly compressible string table.) Smaller buffer sizes give
+     *     fast adaptation but have of course the overhead of transmitting
+     *     trees more frequently.
+     *   - I can't count above 4
+     */
+
+    uInt last_lit;      /* running index in l_buf */
+
+    ushf *d_buf;
+    /* Buffer for distances. To simplify the code, d_buf and l_buf have
+     * the same number of elements. To use different lengths, an extra flag
+     * array would be necessary.
+     */
+
+    ulg opt_len;        /* bit length of current block with optimal trees */
+    ulg static_len;     /* bit length of current block with static trees */
+    uInt matches;       /* number of string matches in current block */
+    uInt insert;        /* bytes at end of window left to insert */
+
+#ifdef ZLIB_DEBUG
+    ulg compressed_len; /* total bit length of compressed file mod 2^32 */
+    ulg bits_sent;      /* bit length of compressed data sent mod 2^32 */
+#endif
+
+    ush bi_buf;
+    /* Output buffer. bits are inserted starting at the bottom (least
+     * significant bits).
+     */
+    int bi_valid;
+    /* Number of valid bits in bi_buf.  All bits above the last valid bit
+     * are always zero.
+     */
+
+    ulg high_water;
+    /* High water mark offset in window for initialized bytes -- bytes above
+     * this are set to zero in order to avoid memory check warnings when
+     * longest match routines access bytes past the input.  This is then
+     * updated to the new high water mark.
+     */
+
+} FAR deflate_state;
+
+/* Output a byte on the stream.
+ * IN assertion: there is enough room in pending_buf.
+ */
+#define put_byte(s, c) {s->pending_buf[s->pending++] = (Bytef)(c);}
+
+
+#define MIN_LOOKAHEAD (MAX_MATCH+MIN_MATCH+1)
+/* Minimum amount of lookahead, except at the end of the input file.
+ * See deflate.c for comments about the MIN_MATCH+1.
+ */
+
+#define MAX_DIST(s)  ((s)->w_size-MIN_LOOKAHEAD)
+/* In order to simplify the code, particularly on 16 bit machines, match
+ * distances are limited to MAX_DIST instead of WSIZE.
+ */
+
+#define WIN_INIT MAX_MATCH
+/* Number of bytes after end of data in window to initialize in order to avoid
+   memory checker errors from longest match routines */
+
+        /* in trees.c */
+void ZLIB_INTERNAL _tr_init OF((deflate_state *s));
+int ZLIB_INTERNAL _tr_tally OF((deflate_state *s, unsigned dist, unsigned lc));
+void ZLIB_INTERNAL _tr_flush_block OF((deflate_state *s, charf *buf,
+                        ulg stored_len, int last));
+void ZLIB_INTERNAL _tr_flush_bits OF((deflate_state *s));
+void ZLIB_INTERNAL _tr_align OF((deflate_state *s));
+void ZLIB_INTERNAL _tr_stored_block OF((deflate_state *s, charf *buf,
+                        ulg stored_len, int last));
+
+#define d_code(dist) \
+   ((dist) < 256 ? _dist_code[dist] : _dist_code[256+((dist)>>7)])
+/* Mapping from a distance to a distance code. dist is the distance - 1 and
+ * must not have side effects. _dist_code[256] and _dist_code[257] are never
+ * used.
+ */
+
+#ifndef ZLIB_DEBUG
+/* Inline versions of _tr_tally for speed: */
+
+#if defined(GEN_TREES_H) || !defined(STDC)
+  extern uch ZLIB_INTERNAL _length_code[];
+  extern uch ZLIB_INTERNAL _dist_code[];
+#else
+  extern const uch ZLIB_INTERNAL _length_code[];
+  extern const uch ZLIB_INTERNAL _dist_code[];
+#endif
+
+# define _tr_tally_lit(s, c, flush) \
+  { uch cc = (c); \
+    s->d_buf[s->last_lit] = 0; \
+    s->l_buf[s->last_lit++] = cc; \
+    s->dyn_ltree[cc].Freq++; \
+    flush = (s->last_lit == s->lit_bufsize-1); \
+   }
+# define _tr_tally_dist(s, distance, length, flush) \
+  { uch len = (uch)(length); \
+    ush dist = (ush)(distance); \
+    s->d_buf[s->last_lit] = dist; \
+    s->l_buf[s->last_lit++] = len; \
+    dist--; \
+    s->dyn_ltree[_length_code[len]+LITERALS+1].Freq++; \
+    s->dyn_dtree[d_code(dist)].Freq++; \
+    flush = (s->last_lit == s->lit_bufsize-1); \
+  }
+#else
+# define _tr_tally_lit(s, c, flush) flush = _tr_tally(s, 0, c)
+# define _tr_tally_dist(s, distance, length, flush) \
+              flush = _tr_tally(s, distance, length)
+#endif
+
+#endif /* DEFLATE_H */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/zlib/gzguts.h

@@ -0,0 +1,220 @@
+/* gzguts.h -- zlib internal header definitions for gz* operations
+ * Copyright (C) 2004, 2005, 2010, 2011, 2012, 2013, 2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+#pragma once
+
+#ifdef _LARGEFILE64_SOURCE
+#  ifndef _LARGEFILE_SOURCE
+#    define _LARGEFILE_SOURCE 1
+#  endif
+#  ifdef _FILE_OFFSET_BITS
+#    undef _FILE_OFFSET_BITS
+#  endif
+#endif
+
+#ifdef HAVE_HIDDEN
+#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
+#else
+#  define ZLIB_INTERNAL
+#endif
+
+#include <stdio.h>
+#include "zlib.h"
+#ifdef STDC
+#  include <string.h>
+#  include <stdlib.h>
+#  include <limits.h>
+#endif
+
+#ifndef _POSIX_SOURCE
+#  define _POSIX_SOURCE
+#endif
+#include <fcntl.h>
+
+#ifdef _WIN32
+#  include <stddef.h>
+#endif
+
+#if defined(__TURBOC__) || defined(_MSC_VER) || defined(_WIN32)
+#  include <io.h>
+#endif
+
+#if defined(_WIN32) || defined(__CYGWIN__)
+#  define WIDECHAR
+#endif
+
+#ifdef WINAPI_FAMILY
+#  define open _open
+#  define read _read
+#  define write _write
+#  define close _close
+#endif
+
+#ifdef NO_DEFLATE       /* for compatibility with old definition */
+#  define NO_GZCOMPRESS
+#endif
+
+#if defined(STDC99) || (defined(__TURBOC__) && __TURBOC__ >= 0x550)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+
+#if defined(__CYGWIN__)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+
+#if defined(MSDOS) && defined(__BORLANDC__) && (BORLANDC > 0x410)
+#  ifndef HAVE_VSNPRINTF
+#    define HAVE_VSNPRINTF
+#  endif
+#endif
+
+#ifndef HAVE_VSNPRINTF
+#  ifdef MSDOS
+/* vsnprintf may exist on some MS-DOS compilers (DJGPP?),
+   but for now we just assume it doesn't. */
+#    define NO_vsnprintf
+#  endif
+#  ifdef __TURBOC__
+#    define NO_vsnprintf
+#  endif
+#  ifdef WIN32
+/* In Win32, vsnprintf is available as the "non-ANSI" _vsnprintf. */
+#    if !defined(vsnprintf) && !defined(NO_vsnprintf)
+#      if !defined(_MSC_VER) || ( defined(_MSC_VER) && _MSC_VER < 1500 )
+#         define vsnprintf _vsnprintf
+#      endif
+#    endif
+#  endif
+#  ifdef __SASC
+#    define NO_vsnprintf
+#  endif
+#  ifdef VMS
+#    define NO_vsnprintf
+#  endif
+#  ifdef __OS400__
+#    define NO_vsnprintf
+#  endif
+#  ifdef __MVS__
+#    define NO_vsnprintf
+#  endif
+#endif
+
+/* unlike snprintf (which is required in C99), _snprintf does not guarantee
+   null termination of the result -- however this is only used in gzlib.c where
+   the result is assured to fit in the space provided */
+#if defined(_MSC_VER) && _MSC_VER < 1900
+#  define snprintf _snprintf
+#endif
+
+#ifndef local
+#  define local static
+#endif
+/* since "static" is used to mean two completely different things in C, we
+   define "local" for the non-static meaning of "static", for readability
+   (compile with -Dlocal if your debugger can't find static symbols) */
+
+/* gz* functions always use library allocation functions */
+#ifndef STDC
+  extern voidp  malloc OF((uInt size));
+  extern void   free   OF((voidpf ptr));
+#endif
+
+/* get errno and strerror definition */
+#if defined UNDER_CE
+#  include <windows.h>
+#  define zstrerror() gz_strwinerror((DWORD)GetLastError())
+#else
+#  ifndef NO_STRERROR
+#    include <errno.h>
+#    define zstrerror() strerror(errno)
+#  else
+#    define zstrerror() "stdio error (consult errno)"
+#  endif
+#endif
+
+/* provide prototypes for these when building zlib without LFS */
+#if !defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0
+    ZEXTERN gzFile ZEXPORT gzopen64 OF((const char *, const char *));
+    ZEXTERN z_off64_t ZEXPORT gzseek64 OF((gzFile, z_off64_t, int));
+    ZEXTERN z_off64_t ZEXPORT gztell64 OF((gzFile));
+    ZEXTERN z_off64_t ZEXPORT gzoffset64 OF((gzFile));
+#endif
+
+/* default memLevel */
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+
+/* default i/o buffer size -- double this for output when reading (this and
+   twice this must be able to fit in an unsigned type) */
+#define GZBUFSIZE 8192
+
+/* gzip modes, also provide a little integrity check on the passed structure */
+#define GZ_NONE 0
+#define GZ_READ 7247
+#define GZ_WRITE 31153
+#define GZ_APPEND 1     /* mode set to GZ_WRITE after the file is opened */
+
+/* values for gz_state how */
+#define LOOK 0      /* look for a gzip header */
+#define COPY 1      /* copy input directly */
+#define GZIP 2      /* decompress a gzip stream */
+
+/* internal gzip file state data structure */
+typedef struct {
+        /* exposed contents for gzgetc() macro */
+    struct gzFile_s x;      /* "x" for exposed */
+                            /* x.have: number of bytes available at x.next */
+                            /* x.next: next output data to deliver or write */
+                            /* x.pos: current position in uncompressed data */
+        /* used for both reading and writing */
+    int mode;               /* see gzip modes above */
+    int fd;                 /* file descriptor */
+    char *path;             /* path or fd for error messages */
+    unsigned size;          /* buffer size, zero if not allocated yet */
+    unsigned want;          /* requested buffer size, default is GZBUFSIZE */
+    unsigned char *in;      /* input buffer (double-sized when writing) */
+    unsigned char *out;     /* output buffer (double-sized when reading) */
+    int direct;             /* 0 if processing gzip, 1 if transparent */
+        /* just for reading */
+    int how;                /* 0: get header, 1: copy, 2: decompress */
+    z_off64_t start;        /* where the gzip data started, for rewinding */
+    int eof;                /* true if end of input file reached */
+    int past;               /* true if read requested past end */
+        /* just for writing */
+    int level;              /* compression level */
+    int strategy;           /* compression strategy */
+        /* seek request */
+    z_off64_t skip;         /* amount to skip (already rewound if backwards) */
+    int seek;               /* true if seek request pending */
+        /* error information */
+    int err;                /* error code */
+    char *msg;              /* error message */
+        /* zlib inflate or deflate stream */
+    z_stream strm;          /* stream structure in-place (not a pointer) */
+} gz_state;
+typedef gz_state FAR *gz_statep;
+
+/* shared functions */
+void ZLIB_INTERNAL gz_error OF((gz_statep, int, const char *));
+#if defined UNDER_CE
+char ZLIB_INTERNAL *gz_strwinerror OF((DWORD error));
+#endif
+
+/* GT_OFF(x), where x is an unsigned value, is true if x > maximum z_off64_t
+   value -- needed when comparing unsigned to z_off64_t, which is signed
+   (possible z_off64_t types off_t, off64_t, and long are all signed) */
+#ifdef INT_MAX
+#  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > INT_MAX)
+#else
+unsigned ZLIB_INTERNAL gz_intmax OF((void));
+#  define GT_OFF(x) (sizeof(int) == sizeof(z_off64_t) && (x) > gz_intmax())
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/zlib/inffast.h

@@ -0,0 +1,11 @@
+/* inffast.h -- header to use inffast.c
+ * Copyright (C) 1995-2003, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+void ZLIB_INTERNAL inflate_fast OF((z_streamp strm, unsigned start));

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/zlib/inffixed.h

@@ -0,0 +1,94 @@
+    /* inffixed.h -- table for decoding fixed codes
+     * Generated automatically by makefixed().
+     */
+
+    /* WARNING: this file should *not* be used by applications.
+       It is part of the implementation of this library and is
+       subject to change. Applications should only use zlib.h.
+     */
+
+    static const code lenfix[512] = {
+        {96,7,0},{0,8,80},{0,8,16},{20,8,115},{18,7,31},{0,8,112},{0,8,48},
+        {0,9,192},{16,7,10},{0,8,96},{0,8,32},{0,9,160},{0,8,0},{0,8,128},
+        {0,8,64},{0,9,224},{16,7,6},{0,8,88},{0,8,24},{0,9,144},{19,7,59},
+        {0,8,120},{0,8,56},{0,9,208},{17,7,17},{0,8,104},{0,8,40},{0,9,176},
+        {0,8,8},{0,8,136},{0,8,72},{0,9,240},{16,7,4},{0,8,84},{0,8,20},
+        {21,8,227},{19,7,43},{0,8,116},{0,8,52},{0,9,200},{17,7,13},{0,8,100},
+        {0,8,36},{0,9,168},{0,8,4},{0,8,132},{0,8,68},{0,9,232},{16,7,8},
+        {0,8,92},{0,8,28},{0,9,152},{20,7,83},{0,8,124},{0,8,60},{0,9,216},
+        {18,7,23},{0,8,108},{0,8,44},{0,9,184},{0,8,12},{0,8,140},{0,8,76},
+        {0,9,248},{16,7,3},{0,8,82},{0,8,18},{21,8,163},{19,7,35},{0,8,114},
+        {0,8,50},{0,9,196},{17,7,11},{0,8,98},{0,8,34},{0,9,164},{0,8,2},
+        {0,8,130},{0,8,66},{0,9,228},{16,7,7},{0,8,90},{0,8,26},{0,9,148},
+        {20,7,67},{0,8,122},{0,8,58},{0,9,212},{18,7,19},{0,8,106},{0,8,42},
+        {0,9,180},{0,8,10},{0,8,138},{0,8,74},{0,9,244},{16,7,5},{0,8,86},
+        {0,8,22},{64,8,0},{19,7,51},{0,8,118},{0,8,54},{0,9,204},{17,7,15},
+        {0,8,102},{0,8,38},{0,9,172},{0,8,6},{0,8,134},{0,8,70},{0,9,236},
+        {16,7,9},{0,8,94},{0,8,30},{0,9,156},{20,7,99},{0,8,126},{0,8,62},
+        {0,9,220},{18,7,27},{0,8,110},{0,8,46},{0,9,188},{0,8,14},{0,8,142},
+        {0,8,78},{0,9,252},{96,7,0},{0,8,81},{0,8,17},{21,8,131},{18,7,31},
+        {0,8,113},{0,8,49},{0,9,194},{16,7,10},{0,8,97},{0,8,33},{0,9,162},
+        {0,8,1},{0,8,129},{0,8,65},{0,9,226},{16,7,6},{0,8,89},{0,8,25},
+        {0,9,146},{19,7,59},{0,8,121},{0,8,57},{0,9,210},{17,7,17},{0,8,105},
+        {0,8,41},{0,9,178},{0,8,9},{0,8,137},{0,8,73},{0,9,242},{16,7,4},
+        {0,8,85},{0,8,21},{16,8,258},{19,7,43},{0,8,117},{0,8,53},{0,9,202},
+        {17,7,13},{0,8,101},{0,8,37},{0,9,170},{0,8,5},{0,8,133},{0,8,69},
+        {0,9,234},{16,7,8},{0,8,93},{0,8,29},{0,9,154},{20,7,83},{0,8,125},
+        {0,8,61},{0,9,218},{18,7,23},{0,8,109},{0,8,45},{0,9,186},{0,8,13},
+        {0,8,141},{0,8,77},{0,9,250},{16,7,3},{0,8,83},{0,8,19},{21,8,195},
+        {19,7,35},{0,8,115},{0,8,51},{0,9,198},{17,7,11},{0,8,99},{0,8,35},
+        {0,9,166},{0,8,3},{0,8,131},{0,8,67},{0,9,230},{16,7,7},{0,8,91},
+        {0,8,27},{0,9,150},{20,7,67},{0,8,123},{0,8,59},{0,9,214},{18,7,19},
+        {0,8,107},{0,8,43},{0,9,182},{0,8,11},{0,8,139},{0,8,75},{0,9,246},
+        {16,7,5},{0,8,87},{0,8,23},{64,8,0},{19,7,51},{0,8,119},{0,8,55},
+        {0,9,206},{17,7,15},{0,8,103},{0,8,39},{0,9,174},{0,8,7},{0,8,135},
+        {0,8,71},{0,9,238},{16,7,9},{0,8,95},{0,8,31},{0,9,158},{20,7,99},
+        {0,8,127},{0,8,63},{0,9,222},{18,7,27},{0,8,111},{0,8,47},{0,9,190},
+        {0,8,15},{0,8,143},{0,8,79},{0,9,254},{96,7,0},{0,8,80},{0,8,16},
+        {20,8,115},{18,7,31},{0,8,112},{0,8,48},{0,9,193},{16,7,10},{0,8,96},
+        {0,8,32},{0,9,161},{0,8,0},{0,8,128},{0,8,64},{0,9,225},{16,7,6},
+        {0,8,88},{0,8,24},{0,9,145},{19,7,59},{0,8,120},{0,8,56},{0,9,209},
+        {17,7,17},{0,8,104},{0,8,40},{0,9,177},{0,8,8},{0,8,136},{0,8,72},
+        {0,9,241},{16,7,4},{0,8,84},{0,8,20},{21,8,227},{19,7,43},{0,8,116},
+        {0,8,52},{0,9,201},{17,7,13},{0,8,100},{0,8,36},{0,9,169},{0,8,4},
+        {0,8,132},{0,8,68},{0,9,233},{16,7,8},{0,8,92},{0,8,28},{0,9,153},
+        {20,7,83},{0,8,124},{0,8,60},{0,9,217},{18,7,23},{0,8,108},{0,8,44},
+        {0,9,185},{0,8,12},{0,8,140},{0,8,76},{0,9,249},{16,7,3},{0,8,82},
+        {0,8,18},{21,8,163},{19,7,35},{0,8,114},{0,8,50},{0,9,197},{17,7,11},
+        {0,8,98},{0,8,34},{0,9,165},{0,8,2},{0,8,130},{0,8,66},{0,9,229},
+        {16,7,7},{0,8,90},{0,8,26},{0,9,149},{20,7,67},{0,8,122},{0,8,58},
+        {0,9,213},{18,7,19},{0,8,106},{0,8,42},{0,9,181},{0,8,10},{0,8,138},
+        {0,8,74},{0,9,245},{16,7,5},{0,8,86},{0,8,22},{64,8,0},{19,7,51},
+        {0,8,118},{0,8,54},{0,9,205},{17,7,15},{0,8,102},{0,8,38},{0,9,173},
+        {0,8,6},{0,8,134},{0,8,70},{0,9,237},{16,7,9},{0,8,94},{0,8,30},
+        {0,9,157},{20,7,99},{0,8,126},{0,8,62},{0,9,221},{18,7,27},{0,8,110},
+        {0,8,46},{0,9,189},{0,8,14},{0,8,142},{0,8,78},{0,9,253},{96,7,0},
+        {0,8,81},{0,8,17},{21,8,131},{18,7,31},{0,8,113},{0,8,49},{0,9,195},
+        {16,7,10},{0,8,97},{0,8,33},{0,9,163},{0,8,1},{0,8,129},{0,8,65},
+        {0,9,227},{16,7,6},{0,8,89},{0,8,25},{0,9,147},{19,7,59},{0,8,121},
+        {0,8,57},{0,9,211},{17,7,17},{0,8,105},{0,8,41},{0,9,179},{0,8,9},
+        {0,8,137},{0,8,73},{0,9,243},{16,7,4},{0,8,85},{0,8,21},{16,8,258},
+        {19,7,43},{0,8,117},{0,8,53},{0,9,203},{17,7,13},{0,8,101},{0,8,37},
+        {0,9,171},{0,8,5},{0,8,133},{0,8,69},{0,9,235},{16,7,8},{0,8,93},
+        {0,8,29},{0,9,155},{20,7,83},{0,8,125},{0,8,61},{0,9,219},{18,7,23},
+        {0,8,109},{0,8,45},{0,9,187},{0,8,13},{0,8,141},{0,8,77},{0,9,251},
+        {16,7,3},{0,8,83},{0,8,19},{21,8,195},{19,7,35},{0,8,115},{0,8,51},
+        {0,9,199},{17,7,11},{0,8,99},{0,8,35},{0,9,167},{0,8,3},{0,8,131},
+        {0,8,67},{0,9,231},{16,7,7},{0,8,91},{0,8,27},{0,9,151},{20,7,67},
+        {0,8,123},{0,8,59},{0,9,215},{18,7,19},{0,8,107},{0,8,43},{0,9,183},
+        {0,8,11},{0,8,139},{0,8,75},{0,9,247},{16,7,5},{0,8,87},{0,8,23},
+        {64,8,0},{19,7,51},{0,8,119},{0,8,55},{0,9,207},{17,7,15},{0,8,103},
+        {0,8,39},{0,9,175},{0,8,7},{0,8,135},{0,8,71},{0,9,239},{16,7,9},
+        {0,8,95},{0,8,31},{0,9,159},{20,7,99},{0,8,127},{0,8,63},{0,9,223},
+        {18,7,27},{0,8,111},{0,8,47},{0,9,191},{0,8,15},{0,8,143},{0,8,79},
+        {0,9,255}
+    };
+
+    static const code distfix[32] = {
+        {16,5,1},{23,5,257},{19,5,17},{27,5,4097},{17,5,5},{25,5,1025},
+        {21,5,65},{29,5,16385},{16,5,3},{24,5,513},{20,5,33},{28,5,8193},
+        {18,5,9},{26,5,2049},{22,5,129},{64,5,0},{16,5,2},{23,5,385},
+        {19,5,25},{27,5,6145},{17,5,7},{25,5,1537},{21,5,97},{29,5,24577},
+        {16,5,4},{24,5,769},{20,5,49},{28,5,12289},{18,5,13},{26,5,3073},
+        {22,5,193},{64,5,0}
+    };

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/zlib/inflate.h

@@ -0,0 +1,125 @@
+/* inflate.h -- internal inflate state definition
+ * Copyright (C) 1995-2016 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* define NO_GZIP when compiling if you want to disable gzip header and
+   trailer decoding by inflate().  NO_GZIP would be used to avoid linking in
+   the crc code when it is not needed.  For shared libraries, gzip decoding
+   should be left enabled. */
+#ifndef NO_GZIP
+#  define GUNZIP
+#endif
+
+/* Possible inflate modes between inflate() calls */
+typedef enum {
+    HEAD = 16180,   /* i: waiting for magic header */
+    FLAGS,      /* i: waiting for method and flags (gzip) */
+    TIME,       /* i: waiting for modification time (gzip) */
+    OS,         /* i: waiting for extra flags and operating system (gzip) */
+    EXLEN,      /* i: waiting for extra length (gzip) */
+    EXTRA,      /* i: waiting for extra bytes (gzip) */
+    NAME,       /* i: waiting for end of file name (gzip) */
+    COMMENT,    /* i: waiting for end of comment (gzip) */
+    HCRC,       /* i: waiting for header crc (gzip) */
+    DICTID,     /* i: waiting for dictionary check value */
+    DICT,       /* waiting for inflateSetDictionary() call */
+        TYPE,       /* i: waiting for type bits, including last-flag bit */
+        TYPEDO,     /* i: same, but skip check to exit inflate on new block */
+        STORED,     /* i: waiting for stored size (length and complement) */
+        COPY_,      /* i/o: same as COPY below, but only first time in */
+        COPY,       /* i/o: waiting for input or output to copy stored block */
+        TABLE,      /* i: waiting for dynamic block table lengths */
+        LENLENS,    /* i: waiting for code length code lengths */
+        CODELENS,   /* i: waiting for length/lit and distance code lengths */
+            LEN_,       /* i: same as LEN below, but only first time in */
+            LEN,        /* i: waiting for length/lit/eob code */
+            LENEXT,     /* i: waiting for length extra bits */
+            DIST,       /* i: waiting for distance code */
+            DISTEXT,    /* i: waiting for distance extra bits */
+            MATCH,      /* o: waiting for output space to copy string */
+            LIT,        /* o: waiting for output space to write literal */
+    CHECK,      /* i: waiting for 32-bit check value */
+    LENGTH,     /* i: waiting for 32-bit length (gzip) */
+    DONE,       /* finished check, done -- remain here until reset */
+    BAD,        /* got a data error -- remain here until reset */
+    MEM,        /* got an inflate() memory error -- remain here until reset */
+    SYNC        /* looking for synchronization bytes to restart inflate() */
+} inflate_mode;
+
+/*
+    State transitions between above modes -
+
+    (most modes can go to BAD or MEM on error -- not shown for clarity)
+
+    Process header:
+        HEAD -> (gzip) or (zlib) or (raw)
+        (gzip) -> FLAGS -> TIME -> OS -> EXLEN -> EXTRA -> NAME -> COMMENT ->
+                  HCRC -> TYPE
+        (zlib) -> DICTID or TYPE
+        DICTID -> DICT -> TYPE
+        (raw) -> TYPEDO
+    Read deflate blocks:
+            TYPE -> TYPEDO -> STORED or TABLE or LEN_ or CHECK
+            STORED -> COPY_ -> COPY -> TYPE
+            TABLE -> LENLENS -> CODELENS -> LEN_
+            LEN_ -> LEN
+    Read deflate codes in fixed or dynamic block:
+                LEN -> LENEXT or LIT or TYPE
+                LENEXT -> DIST -> DISTEXT -> MATCH -> LEN
+                LIT -> LEN
+    Process trailer:
+        CHECK -> LENGTH -> DONE
+ */
+
+/* State maintained between inflate() calls -- approximately 7K bytes, not
+   including the allocated sliding window, which is up to 32K bytes. */
+struct inflate_state {
+    z_streamp strm;             /* pointer back to this zlib stream */
+    inflate_mode mode;          /* current inflate mode */
+    int last;                   /* true if processing last block */
+    int wrap;                   /* bit 0 true for zlib, bit 1 true for gzip,
+                                   bit 2 true to validate check value */
+    int havedict;               /* true if dictionary provided */
+    int flags;                  /* gzip header method and flags (0 if zlib) */
+    unsigned dmax;              /* zlib header max distance (INFLATE_STRICT) */
+    unsigned long check;        /* protected copy of check value */
+    unsigned long total;        /* protected copy of output count */
+    gz_headerp head;            /* where to save gzip header information */
+        /* sliding window */
+    unsigned wbits;             /* log base 2 of requested window size */
+    unsigned wsize;             /* window size or zero if not using window */
+    unsigned whave;             /* valid bytes in the window */
+    unsigned wnext;             /* window write index */
+    unsigned char FAR *window;  /* allocated sliding window, if needed */
+        /* bit accumulator */
+    unsigned long hold;         /* input bit accumulator */
+    unsigned bits;              /* number of bits in "in" */
+        /* for string and stored block copying */
+    unsigned length;            /* literal or length of data to copy */
+    unsigned offset;            /* distance back to copy string from */
+        /* for table and code decoding */
+    unsigned extra;             /* extra bits needed */
+        /* fixed and dynamic code tables */
+    code const FAR *lencode;    /* starting table for length/literal codes */
+    code const FAR *distcode;   /* starting table for distance codes */
+    unsigned lenbits;           /* index bits for lencode */
+    unsigned distbits;          /* index bits for distcode */
+        /* dynamic table building */
+    unsigned ncode;             /* number of code length code lengths */
+    unsigned nlen;              /* number of length code lengths */
+    unsigned ndist;             /* number of distance code lengths */
+    unsigned have;              /* number of code lengths in lens[] */
+    code FAR *next;             /* next available space in codes[] */
+    unsigned short lens[320];   /* temporary storage for code lengths */
+    unsigned short work[288];   /* work area for code table building */
+    code codes[ENOUGH];         /* space for code tables */
+    int sane;                   /* if false, allow invalid distance too far */
+    int back;                   /* bits back of last unprocessed length/lit */
+    unsigned was;               /* initial length of match */
+};

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/zlib/inftrees.h

@@ -0,0 +1,62 @@
+/* inftrees.h -- header to use inftrees.c
+ * Copyright (C) 1995-2005, 2010 Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* Structure for decoding tables.  Each entry provides either the
+   information needed to do the operation requested by the code that
+   indexed that table entry, or it provides a pointer to another
+   table that indexes more bits of the code.  op indicates whether
+   the entry is a pointer to another table, a literal, a length or
+   distance, an end-of-block, or an invalid code.  For a table
+   pointer, the low four bits of op is the number of index bits of
+   that table.  For a length or distance, the low four bits of op
+   is the number of extra bits to get after the code.  bits is
+   the number of bits in this code or part of the code to drop off
+   of the bit buffer.  val is the actual byte to output in the case
+   of a literal, the base length or distance, or the offset from
+   the current table to the next table.  Each entry is four bytes. */
+typedef struct {
+    unsigned char op;           /* operation, extra bits, table bits */
+    unsigned char bits;         /* bits in this part of the code */
+    unsigned short val;         /* offset in table or code value */
+} code;
+
+/* op values as set by inflate_table():
+    00000000 - literal
+    0000tttt - table link, tttt != 0 is the number of table index bits
+    0001eeee - length or distance, eeee is the number of extra bits
+    01100000 - end of block
+    01000000 - invalid code
+ */
+
+/* Maximum size of the dynamic table.  The maximum number of code structures is
+   1444, which is the sum of 852 for literal/length codes and 592 for distance
+   codes.  These values were found by exhaustive searches using the program
+   examples/enough.c found in the zlib distribtution.  The arguments to that
+   program are the number of symbols, the initial root table size, and the
+   maximum bit length of a code.  "enough 286 9 15" for literal/length codes
+   returns returns 852, and "enough 30 6 15" for distance codes returns 592.
+   The initial root table size (9 or 6) is found in the fifth argument of the
+   inflate_table() calls in inflate.c and infback.c.  If the root table size is
+   changed, then these maximum sizes would be need to be recalculated and
+   updated. */
+#define ENOUGH_LENS 852
+#define ENOUGH_DISTS 592
+#define ENOUGH (ENOUGH_LENS+ENOUGH_DISTS)
+
+/* Type of code to build for inflate_table() */
+typedef enum {
+    CODES,
+    LENS,
+    DISTS
+} codetype;
+
+int ZLIB_INTERNAL inflate_table OF((codetype type, unsigned short FAR *lens,
+                             unsigned codes, code FAR * FAR *table,
+                             unsigned FAR *bits, unsigned short FAR *work));

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/zlib/trees.h

@@ -0,0 +1,128 @@
+/* header created automatically with -DGEN_TREES_H */
+
+local const ct_data static_ltree[L_CODES+2] = {
+{{ 12},{  8}}, {{140},{  8}}, {{ 76},{  8}}, {{204},{  8}}, {{ 44},{  8}},
+{{172},{  8}}, {{108},{  8}}, {{236},{  8}}, {{ 28},{  8}}, {{156},{  8}},
+{{ 92},{  8}}, {{220},{  8}}, {{ 60},{  8}}, {{188},{  8}}, {{124},{  8}},
+{{252},{  8}}, {{  2},{  8}}, {{130},{  8}}, {{ 66},{  8}}, {{194},{  8}},
+{{ 34},{  8}}, {{162},{  8}}, {{ 98},{  8}}, {{226},{  8}}, {{ 18},{  8}},
+{{146},{  8}}, {{ 82},{  8}}, {{210},{  8}}, {{ 50},{  8}}, {{178},{  8}},
+{{114},{  8}}, {{242},{  8}}, {{ 10},{  8}}, {{138},{  8}}, {{ 74},{  8}},
+{{202},{  8}}, {{ 42},{  8}}, {{170},{  8}}, {{106},{  8}}, {{234},{  8}},
+{{ 26},{  8}}, {{154},{  8}}, {{ 90},{  8}}, {{218},{  8}}, {{ 58},{  8}},
+{{186},{  8}}, {{122},{  8}}, {{250},{  8}}, {{  6},{  8}}, {{134},{  8}},
+{{ 70},{  8}}, {{198},{  8}}, {{ 38},{  8}}, {{166},{  8}}, {{102},{  8}},
+{{230},{  8}}, {{ 22},{  8}}, {{150},{  8}}, {{ 86},{  8}}, {{214},{  8}},
+{{ 54},{  8}}, {{182},{  8}}, {{118},{  8}}, {{246},{  8}}, {{ 14},{  8}},
+{{142},{  8}}, {{ 78},{  8}}, {{206},{  8}}, {{ 46},{  8}}, {{174},{  8}},
+{{110},{  8}}, {{238},{  8}}, {{ 30},{  8}}, {{158},{  8}}, {{ 94},{  8}},
+{{222},{  8}}, {{ 62},{  8}}, {{190},{  8}}, {{126},{  8}}, {{254},{  8}},
+{{  1},{  8}}, {{129},{  8}}, {{ 65},{  8}}, {{193},{  8}}, {{ 33},{  8}},
+{{161},{  8}}, {{ 97},{  8}}, {{225},{  8}}, {{ 17},{  8}}, {{145},{  8}},
+{{ 81},{  8}}, {{209},{  8}}, {{ 49},{  8}}, {{177},{  8}}, {{113},{  8}},
+{{241},{  8}}, {{  9},{  8}}, {{137},{  8}}, {{ 73},{  8}}, {{201},{  8}},
+{{ 41},{  8}}, {{169},{  8}}, {{105},{  8}}, {{233},{  8}}, {{ 25},{  8}},
+{{153},{  8}}, {{ 89},{  8}}, {{217},{  8}}, {{ 57},{  8}}, {{185},{  8}},
+{{121},{  8}}, {{249},{  8}}, {{  5},{  8}}, {{133},{  8}}, {{ 69},{  8}},
+{{197},{  8}}, {{ 37},{  8}}, {{165},{  8}}, {{101},{  8}}, {{229},{  8}},
+{{ 21},{  8}}, {{149},{  8}}, {{ 85},{  8}}, {{213},{  8}}, {{ 53},{  8}},
+{{181},{  8}}, {{117},{  8}}, {{245},{  8}}, {{ 13},{  8}}, {{141},{  8}},
+{{ 77},{  8}}, {{205},{  8}}, {{ 45},{  8}}, {{173},{  8}}, {{109},{  8}},
+{{237},{  8}}, {{ 29},{  8}}, {{157},{  8}}, {{ 93},{  8}}, {{221},{  8}},
+{{ 61},{  8}}, {{189},{  8}}, {{125},{  8}}, {{253},{  8}}, {{ 19},{  9}},
+{{275},{  9}}, {{147},{  9}}, {{403},{  9}}, {{ 83},{  9}}, {{339},{  9}},
+{{211},{  9}}, {{467},{  9}}, {{ 51},{  9}}, {{307},{  9}}, {{179},{  9}},
+{{435},{  9}}, {{115},{  9}}, {{371},{  9}}, {{243},{  9}}, {{499},{  9}},
+{{ 11},{  9}}, {{267},{  9}}, {{139},{  9}}, {{395},{  9}}, {{ 75},{  9}},
+{{331},{  9}}, {{203},{  9}}, {{459},{  9}}, {{ 43},{  9}}, {{299},{  9}},
+{{171},{  9}}, {{427},{  9}}, {{107},{  9}}, {{363},{  9}}, {{235},{  9}},
+{{491},{  9}}, {{ 27},{  9}}, {{283},{  9}}, {{155},{  9}}, {{411},{  9}},
+{{ 91},{  9}}, {{347},{  9}}, {{219},{  9}}, {{475},{  9}}, {{ 59},{  9}},
+{{315},{  9}}, {{187},{  9}}, {{443},{  9}}, {{123},{  9}}, {{379},{  9}},
+{{251},{  9}}, {{507},{  9}}, {{  7},{  9}}, {{263},{  9}}, {{135},{  9}},
+{{391},{  9}}, {{ 71},{  9}}, {{327},{  9}}, {{199},{  9}}, {{455},{  9}},
+{{ 39},{  9}}, {{295},{  9}}, {{167},{  9}}, {{423},{  9}}, {{103},{  9}},
+{{359},{  9}}, {{231},{  9}}, {{487},{  9}}, {{ 23},{  9}}, {{279},{  9}},
+{{151},{  9}}, {{407},{  9}}, {{ 87},{  9}}, {{343},{  9}}, {{215},{  9}},
+{{471},{  9}}, {{ 55},{  9}}, {{311},{  9}}, {{183},{  9}}, {{439},{  9}},
+{{119},{  9}}, {{375},{  9}}, {{247},{  9}}, {{503},{  9}}, {{ 15},{  9}},
+{{271},{  9}}, {{143},{  9}}, {{399},{  9}}, {{ 79},{  9}}, {{335},{  9}},
+{{207},{  9}}, {{463},{  9}}, {{ 47},{  9}}, {{303},{  9}}, {{175},{  9}},
+{{431},{  9}}, {{111},{  9}}, {{367},{  9}}, {{239},{  9}}, {{495},{  9}},
+{{ 31},{  9}}, {{287},{  9}}, {{159},{  9}}, {{415},{  9}}, {{ 95},{  9}},
+{{351},{  9}}, {{223},{  9}}, {{479},{  9}}, {{ 63},{  9}}, {{319},{  9}},
+{{191},{  9}}, {{447},{  9}}, {{127},{  9}}, {{383},{  9}}, {{255},{  9}},
+{{511},{  9}}, {{  0},{  7}}, {{ 64},{  7}}, {{ 32},{  7}}, {{ 96},{  7}},
+{{ 16},{  7}}, {{ 80},{  7}}, {{ 48},{  7}}, {{112},{  7}}, {{  8},{  7}},
+{{ 72},{  7}}, {{ 40},{  7}}, {{104},{  7}}, {{ 24},{  7}}, {{ 88},{  7}},
+{{ 56},{  7}}, {{120},{  7}}, {{  4},{  7}}, {{ 68},{  7}}, {{ 36},{  7}},
+{{100},{  7}}, {{ 20},{  7}}, {{ 84},{  7}}, {{ 52},{  7}}, {{116},{  7}},
+{{  3},{  8}}, {{131},{  8}}, {{ 67},{  8}}, {{195},{  8}}, {{ 35},{  8}},
+{{163},{  8}}, {{ 99},{  8}}, {{227},{  8}}
+};
+
+local const ct_data static_dtree[D_CODES] = {
+{{ 0},{ 5}}, {{16},{ 5}}, {{ 8},{ 5}}, {{24},{ 5}}, {{ 4},{ 5}},
+{{20},{ 5}}, {{12},{ 5}}, {{28},{ 5}}, {{ 2},{ 5}}, {{18},{ 5}},
+{{10},{ 5}}, {{26},{ 5}}, {{ 6},{ 5}}, {{22},{ 5}}, {{14},{ 5}},
+{{30},{ 5}}, {{ 1},{ 5}}, {{17},{ 5}}, {{ 9},{ 5}}, {{25},{ 5}},
+{{ 5},{ 5}}, {{21},{ 5}}, {{13},{ 5}}, {{29},{ 5}}, {{ 3},{ 5}},
+{{19},{ 5}}, {{11},{ 5}}, {{27},{ 5}}, {{ 7},{ 5}}, {{23},{ 5}}
+};
+
+const uch ZLIB_INTERNAL _dist_code[DIST_CODE_LEN] = {
+ 0,  1,  2,  3,  4,  4,  5,  5,  6,  6,  6,  6,  7,  7,  7,  7,  8,  8,  8,  8,
+ 8,  8,  8,  8,  9,  9,  9,  9,  9,  9,  9,  9, 10, 10, 10, 10, 10, 10, 10, 10,
+10, 10, 10, 10, 10, 10, 10, 10, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11, 11,
+11, 11, 11, 11, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12,
+12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 12, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13, 13,
+13, 13, 13, 13, 13, 13, 13, 13, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14,
+14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 14, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,
+15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15, 15,  0,  0, 16, 17,
+18, 18, 19, 19, 20, 20, 20, 20, 21, 21, 21, 21, 22, 22, 22, 22, 22, 22, 22, 22,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28, 28,
+28, 28, 28, 28, 28, 28, 28, 28, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29,
+29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29, 29
+};
+
+const uch ZLIB_INTERNAL _length_code[MAX_MATCH-MIN_MATCH+1]= {
+ 0,  1,  2,  3,  4,  5,  6,  7,  8,  8,  9,  9, 10, 10, 11, 11, 12, 12, 12, 12,
+13, 13, 13, 13, 14, 14, 14, 14, 15, 15, 15, 15, 16, 16, 16, 16, 16, 16, 16, 16,
+17, 17, 17, 17, 17, 17, 17, 17, 18, 18, 18, 18, 18, 18, 18, 18, 19, 19, 19, 19,
+19, 19, 19, 19, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20, 20,
+21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 21, 22, 22, 22, 22,
+22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 22, 23, 23, 23, 23, 23, 23, 23, 23,
+23, 23, 23, 23, 23, 23, 23, 23, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24, 24,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25,
+25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 25, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26, 26,
+26, 26, 26, 26, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27,
+27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 27, 28
+};
+
+local const int base_length[LENGTH_CODES] = {
+0, 1, 2, 3, 4, 5, 6, 7, 8, 10, 12, 14, 16, 20, 24, 28, 32, 40, 48, 56,
+64, 80, 96, 112, 128, 160, 192, 224, 0
+};
+
+local const int base_dist[D_CODES] = {
+    0,     1,     2,     3,     4,     6,     8,    12,    16,    24,
+   32,    48,    64,    96,   128,   192,   256,   384,   512,   768,
+ 1024,  1536,  2048,  3072,  4096,  6144,  8192, 12288, 16384, 24576
+};
+

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/zlib/zconf.h

@@ -0,0 +1,533 @@
+/* zconf.h -- configuration of the zlib compression library
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZCONF_H
+#define ZCONF_H
+
+#if !defined(WINDOWS) && !defined(WIN32)
+#define HAVE_UNISTD_H
+#endif
+
+/*
+ * If you *really* need a unique prefix for all types and library functions,
+ * compile with -DZ_PREFIX. The "standard" zlib should be compiled without it.
+ * Even better than compiling with -DZ_PREFIX would be to use configure to set
+ * this permanently in zconf.h using "./configure --zprefix".
+ */
+#define Z_PREFIX 1
+#ifdef Z_PREFIX     /* may be set to #if 1 by ./configure */
+
+/* all linked symbols and init macros */
+#  define _dist_code            il2cpp_z__dist_code
+#  define _length_code          il2cpp_z__length_code
+#  define _tr_align             il2cpp_z__tr_align
+#  define _tr_flush_bits        il2cpp_z__tr_flush_bits
+#  define _tr_flush_block       il2cpp_z__tr_flush_block
+#  define _tr_init              il2cpp_z__tr_init
+#  define _tr_stored_block      il2cpp_z__tr_stored_block
+#  define _tr_tally             il2cpp_z__tr_tally
+#  define adler32               il2cpp_z_adler32
+#  define adler32_combine       il2cpp_z_adler32_combine
+#  define adler32_combine64     il2cpp_z_adler32_combine64
+#  define adler32_z             il2cpp_z_adler32_z
+#  ifndef Z_SOLO
+#    define compress              il2cpp_z_compress
+#    define compress2             il2cpp_z_compress2
+#    define compressBound         il2cpp_z_compressBound
+#  endif
+#  define crc32                 il2cpp_z_crc32
+#  define crc32_combine         il2cpp_z_crc32_combine
+#  define crc32_combine64       il2cpp_z_crc32_combine64
+#  define crc32_z               il2cpp_z_crc32_z
+#  define deflate               il2cpp_z_deflate
+#  define deflateBound          il2cpp_z_deflateBound
+#  define deflateCopy           il2cpp_z_deflateCopy
+#  define deflateEnd            il2cpp_z_deflateEnd
+#  define deflateGetDictionary  il2cpp_z_deflateGetDictionary
+#  define deflateInit2_         il2cpp_z_deflateInit2_
+#  define deflateInit_          il2cpp_z_deflateInit_
+#  define deflateParams         il2cpp_z_deflateParams
+#  define deflatePending        il2cpp_z_deflatePending
+#  define deflatePrime          il2cpp_z_deflatePrime
+#  define deflateReset          il2cpp_z_deflateReset
+#  define deflateResetKeep      il2cpp_z_deflateResetKeep
+#  define deflateSetDictionary  il2cpp_z_deflateSetDictionary
+#  define deflateSetHeader      il2cpp_z_deflateSetHeader
+#  define deflateTune           il2cpp_z_deflateTune
+#  define deflate_copyright     il2cpp_z_deflate_copyright
+#  define get_crc_table         il2cpp_z_get_crc_table
+#  ifndef Z_SOLO
+#    define gz_error              il2cpp_z_gz_error
+#    define gz_intmax             il2cpp_z_gz_intmax
+#    define gz_strwinerror        il2cpp_z_gz_strwinerror
+#    define gzbuffer              il2cpp_z_gzbuffer
+#    define gzclearerr            il2cpp_z_gzclearerr
+#    define gzclose               il2cpp_z_gzclose
+#    define gzclose_r             il2cpp_z_gzclose_r
+#    define gzclose_w             il2cpp_z_gzclose_w
+#    define gzdirect              il2cpp_z_gzdirect
+#    define gzdopen               il2cpp_z_gzdopen
+#    define gzeof                 il2cpp_z_gzeof
+#    define gzerror               il2cpp_z_gzerror
+#    define gzflush               il2cpp_z_gzflush
+#    define gzfread               il2cpp_z_gzfread
+#    define gzfwrite              il2cpp_z_gzfwrite
+#    define gzgetc_               il2cpp_z_gzgetc_
+#    define gzgets                il2cpp_z_gzgets
+#    define gzoffset              il2cpp_z_gzoffset
+#    define gzoffset64            il2cpp_z_gzoffset64
+#    define gzopen                il2cpp_z_gzopen
+#    define gzopen64              il2cpp_z_gzopen64
+#    ifdef _WIN32
+#      define gzopen_w              il2cpp_z_gzopen_w
+#    endif
+#    define gzprintf              il2cpp_z_gzprintf
+#    define gzputc                il2cpp_z_gzputc
+#    define gzputs                il2cpp_z_gzputs
+#    define gzread                il2cpp_z_gzread
+#    define gzrewind              il2cpp_z_gzrewind
+#    define gzseek                il2cpp_z_gzseek
+#    define gzseek64              il2cpp_z_gzseek64
+#    define gzsetparams           il2cpp_z_gzsetparams
+#    define gztell                il2cpp_z_gztell
+#    define gztell64              il2cpp_z_gztell64
+#    define gzungetc              il2cpp_z_gzungetc
+#    define gzvprintf             il2cpp_z_gzvprintf
+#    define gzwrite               il2cpp_z_gzwrite
+#  endif
+#  define inflate               il2cpp_z_inflate
+#  define inflateBack           il2cpp_z_inflateBack
+#  define inflateBackEnd        il2cpp_z_inflateBackEnd
+#  define inflateBackInit_      il2cpp_z_inflateBackInit_
+#  define inflateCodesUsed      il2cpp_z_inflateCodesUsed
+#  define inflateCopy           il2cpp_z_inflateCopy
+#  define inflateEnd            il2cpp_z_inflateEnd
+#  define inflateGetDictionary  il2cpp_z_inflateGetDictionary
+#  define inflateGetHeader      il2cpp_z_inflateGetHeader
+#  define inflateInit2_         il2cpp_z_inflateInit2_
+#  define inflateInit_          il2cpp_z_inflateInit_
+#  define inflateMark           il2cpp_z_inflateMark
+#  define inflatePrime          il2cpp_z_inflatePrime
+#  define inflateReset          il2cpp_z_inflateReset
+#  define inflateReset2         il2cpp_z_inflateReset2
+#  define inflateResetKeep      il2cpp_z_inflateResetKeep
+#  define inflateSetDictionary  il2cpp_z_inflateSetDictionary
+#  define inflateSync           il2cpp_z_inflateSync
+#  define inflateSyncPoint      il2cpp_z_inflateSyncPoint
+#  define inflateUndermine      il2cpp_z_inflateUndermine
+#  define inflateValidate       il2cpp_z_inflateValidate
+#  define inflate_copyright     il2cpp_z_inflate_copyright
+#  define inflate_fast          il2cpp_z_inflate_fast
+#  define inflate_table         il2cpp_z_inflate_table
+#  ifndef Z_SOLO
+#    define uncompress            il2cpp_z_uncompress
+#    define uncompress2           il2cpp_z_uncompress2
+#  endif
+#  define zError                il2cpp_z_zError
+#  define z_errmsg              il2cpp_z_z_errmsg
+#  ifndef Z_SOLO
+#    define zcalloc               il2cpp_z_zcalloc
+#    define zcfree                il2cpp_z_zcfree
+#  endif
+#  define zlibCompileFlags      il2cpp_z_zlibCompileFlags
+#  define zlibVersion           il2cpp_z_zlibVersion
+
+/* all zlib typedefs in zlib.h and zconf.h */
+#  define Byte                  il2cpp_z_Byte
+#  define Bytef                 il2cpp_z_Bytef
+#  define alloc_func            il2cpp_z_alloc_func
+#  define charf                 il2cpp_z_charf
+#  define free_func             il2cpp_z_free_func
+#  ifndef Z_SOLO
+#    define gzFile                il2cpp_z_gzFile
+#  endif
+#  define gz_header             il2cpp_z_gz_header
+#  define gz_headerp            il2cpp_z_gz_headerp
+#  define in_func               il2cpp_z_in_func
+#  define intf                  il2cpp_z_intf
+#  define out_func              il2cpp_z_out_func
+#  define uInt                  il2cpp_z_uInt
+#  define uIntf                 il2cpp_z_uIntf
+#  define uLong                 il2cpp_z_uLong
+#  define uLongf                il2cpp_z_uLongf
+#  define voidp                 il2cpp_z_voidp
+#  define voidpc                il2cpp_z_voidpc
+#  define voidpf                il2cpp_z_voidpf
+
+/* all zlib structs in zlib.h and zconf.h */
+#  define gz_header_s           il2cpp_z_gz_header_s
+#  define internal_state        il2cpp_z_internal_state
+
+#endif
+
+#if defined(__MSDOS__) && !defined(MSDOS)
+#  define MSDOS
+#endif
+#if (defined(OS_2) || defined(__OS2__)) && !defined(OS2)
+#  define OS2
+#endif
+#if defined(_WINDOWS) && !defined(WINDOWS)
+#  define WINDOWS
+#endif
+#if defined(_WIN32) || defined(_WIN32_WCE) || defined(__WIN32__)
+#  ifndef WIN32
+#    define WIN32
+#  endif
+#endif
+#if (defined(MSDOS) || defined(OS2) || defined(WINDOWS)) && !defined(WIN32)
+#  if !defined(__GNUC__) && !defined(__FLAT__) && !defined(__386__)
+#    ifndef SYS16BIT
+#      define SYS16BIT
+#    endif
+#  endif
+#endif
+
+/*
+ * Compile with -DMAXSEG_64K if the alloc function cannot allocate more
+ * than 64k bytes at a time (needed on systems with 16-bit int).
+ */
+#ifdef SYS16BIT
+#  define MAXSEG_64K
+#endif
+#ifdef MSDOS
+#  define UNALIGNED_OK
+#endif
+
+#ifdef __STDC_VERSION__
+#  ifndef STDC
+#    define STDC
+#  endif
+#  if __STDC_VERSION__ >= 199901L
+#    ifndef STDC99
+#      define STDC99
+#    endif
+#  endif
+#endif
+#if !defined(STDC) && (defined(__STDC__) || defined(__cplusplus))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(__GNUC__) || defined(__BORLANDC__))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(MSDOS) || defined(WINDOWS) || defined(WIN32))
+#  define STDC
+#endif
+#if !defined(STDC) && (defined(OS2) || defined(__HOS_AIX__))
+#  define STDC
+#endif
+
+#if defined(__OS400__) && !defined(STDC)    /* iSeries (formerly AS/400). */
+#  define STDC
+#endif
+
+#ifndef STDC
+#  ifndef const /* cannot use !defined(STDC) && !defined(const) on Mac */
+#    define const       /* note: need a more gentle solution here */
+#  endif
+#endif
+
+#if defined(ZLIB_CONST) && !defined(z_const)
+#  define z_const const
+#else
+#  define z_const
+#endif
+
+#ifdef Z_SOLO
+   typedef unsigned long z_size_t;
+#else
+#  define z_longlong long long
+#  if defined(NO_SIZE_T)
+     typedef unsigned NO_SIZE_T z_size_t;
+#  elif defined(STDC)
+#    include <stddef.h>
+     typedef size_t z_size_t;
+#  else
+     typedef unsigned long z_size_t;
+#  endif
+#  undef z_longlong
+#endif
+
+/* Maximum value for memLevel in deflateInit2 */
+#ifndef MAX_MEM_LEVEL
+#  ifdef MAXSEG_64K
+#    define MAX_MEM_LEVEL 8
+#  else
+#    define MAX_MEM_LEVEL 9
+#  endif
+#endif
+
+/* Maximum value for windowBits in deflateInit2 and inflateInit2.
+ * WARNING: reducing MAX_WBITS makes minigzip unable to extract .gz files
+ * created by gzip. (Files created by minigzip can still be extracted by
+ * gzip.)
+ */
+#ifndef MAX_WBITS
+#  define MAX_WBITS   15 /* 32K LZ77 window */
+#endif
+
+/* The memory requirements for deflate are (in bytes):
+            (1 << (windowBits+2)) +  (1 << (memLevel+9))
+ that is: 128K for windowBits=15  +  128K for memLevel = 8  (default values)
+ plus a few kilobytes for small objects. For example, if you want to reduce
+ the default memory requirements from 256K to 128K, compile with
+     make CFLAGS="-O -DMAX_WBITS=14 -DMAX_MEM_LEVEL=7"
+ Of course this will generally degrade compression (there's no free lunch).
+
+   The memory requirements for inflate are (in bytes) 1 << windowBits
+ that is, 32K for windowBits=15 (default value) plus about 7 kilobytes
+ for small objects.
+*/
+
+                        /* Type declarations */
+
+#ifndef OF /* function prototypes */
+#  ifdef STDC
+#    define OF(args)  args
+#  else
+#    define OF(args)  ()
+#  endif
+#endif
+
+#ifndef Z_ARG /* function prototypes for stdarg */
+#  if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#    define Z_ARG(args)  args
+#  else
+#    define Z_ARG(args)  ()
+#  endif
+#endif
+
+/* The following definitions for FAR are needed only for MSDOS mixed
+ * model programming (small or medium model with some far allocations).
+ * This was tested only with MSC; for other MSDOS compilers you may have
+ * to define NO_MEMCPY in zutil.h.  If you don't need the mixed model,
+ * just define FAR to be empty.
+ */
+#ifdef SYS16BIT
+#  if defined(M_I86SM) || defined(M_I86MM)
+     /* MSC small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef _MSC_VER
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#  if (defined(__SMALL__) || defined(__MEDIUM__))
+     /* Turbo C small or medium model */
+#    define SMALL_MEDIUM
+#    ifdef __BORLANDC__
+#      define FAR _far
+#    else
+#      define FAR far
+#    endif
+#  endif
+#endif
+
+#if defined(WINDOWS) || defined(WIN32)
+   /* If building or using zlib as a DLL, define ZLIB_DLL.
+    * This is not mandatory, but it offers a little performance increase.
+    */
+#  ifdef ZLIB_DLL
+#    if defined(WIN32) && (!defined(__BORLANDC__) || (__BORLANDC__ >= 0x500))
+#      ifdef ZLIB_INTERNAL
+#        define ZEXTERN extern __declspec(dllexport)
+#      else
+#        define ZEXTERN extern __declspec(dllimport)
+#      endif
+#    endif
+#  endif  /* ZLIB_DLL */
+   /* If building or using zlib with the WINAPI/WINAPIV calling convention,
+    * define ZLIB_WINAPI.
+    * Caution: the standard ZLIB1.DLL is NOT compiled using ZLIB_WINAPI.
+    */
+#  ifdef ZLIB_WINAPI
+#    ifdef FAR
+#      undef FAR
+#    endif
+#    include <windows.h>
+     /* No need for _export, use ZLIB.DEF instead. */
+     /* For complete Windows compatibility, use WINAPI, not __stdcall. */
+#    define ZEXPORT WINAPI
+#    ifdef WIN32
+#      define ZEXPORTVA WINAPIV
+#    else
+#      define ZEXPORTVA FAR CDECL
+#    endif
+#  endif
+#endif
+
+#if defined (__BEOS__)
+#  ifdef ZLIB_DLL
+#    ifdef ZLIB_INTERNAL
+#      define ZEXPORT   __declspec(dllexport)
+#      define ZEXPORTVA __declspec(dllexport)
+#    else
+#      define ZEXPORT   __declspec(dllimport)
+#      define ZEXPORTVA __declspec(dllimport)
+#    endif
+#  endif
+#endif
+
+#ifndef ZEXTERN
+#  define ZEXTERN extern
+#endif
+#ifndef ZEXPORT
+#  define ZEXPORT
+#endif
+#ifndef ZEXPORTVA
+#  define ZEXPORTVA
+#endif
+
+#ifndef FAR
+#  define FAR
+#endif
+
+#if !defined(__MACTYPES__)
+typedef unsigned char  Byte;  /* 8 bits */
+#endif
+typedef unsigned int   uInt;  /* 16 bits or more */
+typedef unsigned long  uLong; /* 32 bits or more */
+
+#ifdef SMALL_MEDIUM
+   /* Borland C/C++ and some old MSC versions ignore FAR inside typedef */
+#  define Bytef Byte FAR
+#else
+   typedef Byte  FAR Bytef;
+#endif
+typedef char  FAR charf;
+typedef int   FAR intf;
+typedef uInt  FAR uIntf;
+typedef uLong FAR uLongf;
+
+#ifdef STDC
+   typedef void const *voidpc;
+   typedef void FAR   *voidpf;
+   typedef void       *voidp;
+#else
+   typedef Byte const *voidpc;
+   typedef Byte FAR   *voidpf;
+   typedef Byte       *voidp;
+#endif
+
+#if !defined(Z_U4) && !defined(Z_SOLO) && defined(STDC)
+#  include <limits.h>
+#  if (UINT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned
+#  elif (ULONG_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned long
+#  elif (USHRT_MAX == 0xffffffffUL)
+#    define Z_U4 unsigned short
+#  endif
+#endif
+
+#ifdef Z_U4
+   typedef Z_U4 z_crc_t;
+#else
+   typedef unsigned long z_crc_t;
+#endif
+
+#ifdef HAVE_UNISTD_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_UNISTD_H
+#endif
+
+#ifdef HAVE_STDARG_H    /* may be set to #if 1 by ./configure */
+#  define Z_HAVE_STDARG_H
+#endif
+
+#ifdef STDC
+#  ifndef Z_SOLO
+#    include <sys/types.h>      /* for off_t */
+#  endif
+#endif
+
+#if defined(STDC) || defined(Z_HAVE_STDARG_H)
+#  ifndef Z_SOLO
+#    include <stdarg.h>         /* for va_list */
+#  endif
+#endif
+
+#ifdef _WIN32
+#  ifndef Z_SOLO
+#    include <stddef.h>         /* for wchar_t */
+#  endif
+#endif
+
+/* a little trick to accommodate both "#define _LARGEFILE64_SOURCE" and
+ * "#define _LARGEFILE64_SOURCE 1" as requesting 64-bit operations, (even
+ * though the former does not conform to the LFS document), but considering
+ * both "#undef _LARGEFILE64_SOURCE" and "#define _LARGEFILE64_SOURCE 0" as
+ * equivalently requesting no 64-bit operations
+ */
+#if defined(_LARGEFILE64_SOURCE) && -_LARGEFILE64_SOURCE - -1 == 1
+#  undef _LARGEFILE64_SOURCE
+#endif
+
+#if defined(__WATCOMC__) && !defined(Z_HAVE_UNISTD_H)
+#  define Z_HAVE_UNISTD_H
+#endif
+#ifndef Z_SOLO
+#  if defined(Z_HAVE_UNISTD_H) || defined(_LARGEFILE64_SOURCE)
+#    include <unistd.h>         /* for SEEK_*, off_t, and _LFS64_LARGEFILE */
+#    ifdef VMS
+#      include <unixio.h>       /* for off_t */
+#    endif
+#    ifndef z_off_t
+#      define z_off_t off_t
+#    endif
+#  endif
+#endif
+
+#if defined(_LFS64_LARGEFILE) && _LFS64_LARGEFILE-0
+#  define Z_LFS64
+#endif
+
+#if defined(_LARGEFILE64_SOURCE) && defined(Z_LFS64)
+#  define Z_LARGE64
+#endif
+
+#if defined(_FILE_OFFSET_BITS) && _FILE_OFFSET_BITS-0 == 64 && defined(Z_LFS64)
+#  define Z_WANT64
+#endif
+
+#if !defined(SEEK_SET) && !defined(Z_SOLO)
+#  define SEEK_SET        0       /* Seek from beginning of file.  */
+#  define SEEK_CUR        1       /* Seek from current position.  */
+#  define SEEK_END        2       /* Set file pointer to EOF plus "offset" */
+#endif
+
+#ifndef z_off_t
+#  define z_off_t long
+#endif
+
+#if !defined(_WIN32) && defined(Z_LARGE64)
+#  define z_off64_t off64_t
+#else
+#  if defined(_WIN32) && !defined(__GNUC__) && !defined(Z_SOLO)
+#    define z_off64_t __int64
+#  else
+#    define z_off64_t z_off_t
+#  endif
+#endif
+
+/* MVS linker does not support external names larger than 8 bytes */
+#if defined(__MVS__)
+  #pragma map(deflateInit_,"DEIN")
+  #pragma map(deflateInit2_,"DEIN2")
+  #pragma map(deflateEnd,"DEEND")
+  #pragma map(deflateBound,"DEBND")
+  #pragma map(inflateInit_,"ININ")
+  #pragma map(inflateInit2_,"ININ2")
+  #pragma map(inflateEnd,"INEND")
+  #pragma map(inflateSync,"INSY")
+  #pragma map(inflateSetDictionary,"INSEDI")
+  #pragma map(compressBound,"CMBND")
+  #pragma map(inflate_table,"INTABL")
+  #pragma map(inflate_fast,"INFA")
+  #pragma map(inflate_copyright,"INCOPY")
+#endif
+
+#endif /* ZCONF_H */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/external/zlib/zutil.h

@@ -0,0 +1,271 @@
+/* zutil.h -- internal interface and configuration of the compression library
+ * Copyright (C) 1995-2016 Jean-loup Gailly, Mark Adler
+ * For conditions of distribution and use, see copyright notice in zlib.h
+ */
+
+/* WARNING: this file should *not* be used by applications. It is
+   part of the implementation of the compression library and is
+   subject to change. Applications should only use zlib.h.
+ */
+
+/* @(#) $Id$ */
+
+#ifndef ZUTIL_H
+#define ZUTIL_H
+
+#ifdef HAVE_HIDDEN
+#  define ZLIB_INTERNAL __attribute__((visibility ("hidden")))
+#else
+#  define ZLIB_INTERNAL
+#endif
+
+#include "zlib.h"
+
+#if defined(STDC) && !defined(Z_SOLO)
+#  if !(defined(_WIN32_WCE) && defined(_MSC_VER))
+#    include <stddef.h>
+#  endif
+#  include <string.h>
+#  include <stdlib.h>
+#endif
+
+#ifdef Z_SOLO
+   typedef long ptrdiff_t;  /* guess -- will be caught if guess is wrong */
+#endif
+
+#ifndef local
+#  define local static
+#endif
+/* since "static" is used to mean two completely different things in C, we
+   define "local" for the non-static meaning of "static", for readability
+   (compile with -Dlocal if your debugger can't find static symbols) */
+
+typedef unsigned char  uch;
+typedef uch FAR uchf;
+typedef unsigned short ush;
+typedef ush FAR ushf;
+typedef unsigned long  ulg;
+
+extern z_const char * const z_errmsg[10]; /* indexed by 2-zlib_error */
+/* (size given to avoid silly warnings with Visual C++) */
+
+#define ERR_MSG(err) z_errmsg[Z_NEED_DICT-(err)]
+
+#define ERR_RETURN(strm,err) \
+  return (strm->msg = ERR_MSG(err), (err))
+/* To be used only when the state is known to be valid */
+
+        /* common constants */
+
+#ifndef DEF_WBITS
+#  define DEF_WBITS MAX_WBITS
+#endif
+/* default windowBits for decompression. MAX_WBITS is for compression only */
+
+#if MAX_MEM_LEVEL >= 8
+#  define DEF_MEM_LEVEL 8
+#else
+#  define DEF_MEM_LEVEL  MAX_MEM_LEVEL
+#endif
+/* default memLevel */
+
+#define STORED_BLOCK 0
+#define STATIC_TREES 1
+#define DYN_TREES    2
+/* The three kinds of block type */
+
+#define MIN_MATCH  3
+#define MAX_MATCH  258
+/* The minimum and maximum match lengths */
+
+#define PRESET_DICT 0x20 /* preset dictionary flag in zlib header */
+
+        /* target dependencies */
+
+#if defined(MSDOS) || (defined(WINDOWS) && !defined(WIN32))
+#  define OS_CODE  0x00
+#  ifndef Z_SOLO
+#    if defined(__TURBOC__) || defined(__BORLANDC__)
+#      if (__STDC__ == 1) && (defined(__LARGE__) || defined(__COMPACT__))
+         /* Allow compilation with ANSI keywords only enabled */
+         void _Cdecl farfree( void *block );
+         void *_Cdecl farmalloc( unsigned long nbytes );
+#      else
+#        include <alloc.h>
+#      endif
+#    else /* MSC or DJGPP */
+#      include <malloc.h>
+#    endif
+#  endif
+#endif
+
+#ifdef AMIGA
+#  define OS_CODE  1
+#endif
+
+#if defined(VAXC) || defined(VMS)
+#  define OS_CODE  2
+#  define F_OPEN(name, mode) \
+     fopen((name), (mode), "mbc=60", "ctx=stm", "rfm=fix", "mrs=512")
+#endif
+
+#ifdef __370__
+#  if __TARGET_LIB__ < 0x20000000
+#    define OS_CODE 4
+#  elif __TARGET_LIB__ < 0x40000000
+#    define OS_CODE 11
+#  else
+#    define OS_CODE 8
+#  endif
+#endif
+
+#if defined(ATARI) || defined(atarist)
+#  define OS_CODE  5
+#endif
+
+#ifdef OS2
+#  define OS_CODE  6
+#  if defined(M_I86) && !defined(Z_SOLO)
+#    include <malloc.h>
+#  endif
+#endif
+
+#if defined(MACOS) || defined(TARGET_OS_MAC)
+#  define OS_CODE  7
+#  ifndef Z_SOLO
+#    if defined(__MWERKS__) && __dest_os != __be_os && __dest_os != __win32_os
+#      include <unix.h> /* for fdopen */
+#    else
+#      ifndef fdopen
+#        define fdopen(fd,mode) NULL /* No fdopen() */
+#      endif
+#    endif
+#  endif
+#endif
+
+#ifdef __acorn
+#  define OS_CODE 13
+#endif
+
+#if defined(WIN32) && !defined(__CYGWIN__)
+#  define OS_CODE  10
+#endif
+
+#ifdef _BEOS_
+#  define OS_CODE  16
+#endif
+
+#ifdef __TOS_OS400__
+#  define OS_CODE 18
+#endif
+
+#ifdef __APPLE__
+#  define OS_CODE 19
+#endif
+
+#if defined(_BEOS_) || defined(RISCOS)
+#  define fdopen(fd,mode) NULL /* No fdopen() */
+#endif
+
+#if (defined(_MSC_VER) && (_MSC_VER > 600)) && !defined __INTERIX
+#  if defined(_WIN32_WCE)
+#    define fdopen(fd,mode) NULL /* No fdopen() */
+#    ifndef _PTRDIFF_T_DEFINED
+       typedef int ptrdiff_t;
+#      define _PTRDIFF_T_DEFINED
+#    endif
+#  else
+#    define fdopen(fd,type)  _fdopen(fd,type)
+#  endif
+#endif
+
+#if defined(__BORLANDC__) && !defined(MSDOS)
+  #pragma warn -8004
+  #pragma warn -8008
+  #pragma warn -8066
+#endif
+
+/* provide prototypes for these when building zlib without LFS */
+#if !defined(_WIN32) && \
+    (!defined(_LARGEFILE64_SOURCE) || _LFS64_LARGEFILE-0 == 0)
+    ZEXTERN uLong ZEXPORT adler32_combine64 OF((uLong, uLong, z_off_t));
+    ZEXTERN uLong ZEXPORT crc32_combine64 OF((uLong, uLong, z_off_t));
+#endif
+
+        /* common defaults */
+
+#ifndef OS_CODE
+#  define OS_CODE  3     /* assume Unix */
+#endif
+
+#ifndef F_OPEN
+#  define F_OPEN(name, mode) fopen((name), (mode))
+#endif
+
+         /* functions */
+
+#if defined(pyr) || defined(Z_SOLO)
+#  define NO_MEMCPY
+#endif
+#if defined(SMALL_MEDIUM) && !defined(_MSC_VER) && !defined(__SC__)
+ /* Use our own functions for small and medium model with MSC <= 5.0.
+  * You may have to use the same strategy for Borland C (untested).
+  * The __SC__ check is for Symantec.
+  */
+#  define NO_MEMCPY
+#endif
+#if defined(STDC) && !defined(HAVE_MEMCPY) && !defined(NO_MEMCPY)
+#  define HAVE_MEMCPY
+#endif
+#ifdef HAVE_MEMCPY
+#  ifdef SMALL_MEDIUM /* MSDOS small or medium model */
+#    define zmemcpy _fmemcpy
+#    define zmemcmp _fmemcmp
+#    define zmemzero(dest, len) _fmemset(dest, 0, len)
+#  else
+#    define zmemcpy memcpy
+#    define zmemcmp memcmp
+#    define zmemzero(dest, len) memset(dest, 0, len)
+#  endif
+#else
+   void ZLIB_INTERNAL zmemcpy OF((Bytef* dest, const Bytef* source, uInt len));
+   int ZLIB_INTERNAL zmemcmp OF((const Bytef* s1, const Bytef* s2, uInt len));
+   void ZLIB_INTERNAL zmemzero OF((Bytef* dest, uInt len));
+#endif
+
+/* Diagnostic functions */
+#ifdef ZLIB_DEBUG
+#  include <stdio.h>
+   extern int ZLIB_INTERNAL z_verbose;
+   extern void ZLIB_INTERNAL z_error OF((char *m));
+#  define Assert(cond,msg) {if(!(cond)) z_error(msg);}
+#  define Trace(x) {if (z_verbose>=0) fprintf x ;}
+#  define Tracev(x) {if (z_verbose>0) fprintf x ;}
+#  define Tracevv(x) {if (z_verbose>1) fprintf x ;}
+#  define Tracec(c,x) {if (z_verbose>0 && (c)) fprintf x ;}
+#  define Tracecv(c,x) {if (z_verbose>1 && (c)) fprintf x ;}
+#else
+#  define Assert(cond,msg)
+#  define Trace(x)
+#  define Tracev(x)
+#  define Tracevv(x)
+#  define Tracec(c,x)
+#  define Tracecv(c,x)
+#endif
+
+#ifndef Z_SOLO
+   voidpf ZLIB_INTERNAL zcalloc OF((voidpf opaque, unsigned items,
+                                    unsigned size));
+   void ZLIB_INTERNAL zcfree  OF((voidpf opaque, voidpf ptr));
+#endif
+
+#define ZALLOC(strm, items, size) \
+           (*((strm)->zalloc))((strm)->opaque, (items), (size))
+#define ZFREE(strm, addr)  (*((strm)->zfree))((strm)->opaque, (voidpf)(addr))
+#define TRY_FREE(s, p) {if (p) ZFREE(s, p);}
+
+/* Reverse the bytes in a 32-bit value */
+#define ZSWAP32(q) ((((q) >> 24) & 0xff) + (((q) >> 8) & 0xff00) + \
+                    (((q) & 0xff00) << 8) + (((q) & 0xff) << 24))
+
+#endif /* ZUTIL_H */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/externals/MonoPosixHelper.h

@@ -0,0 +1,17 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+extern "C"
+{
+struct ZStream;
+
+IL2CPP_EXPORT intptr_t CreateZStream(int32_t compress, uint8_t gzip, Il2CppMethodPointer func, intptr_t gchandle);
+IL2CPP_EXPORT int32_t CloseZStream(intptr_t zstream);
+IL2CPP_EXPORT int32_t Flush(intptr_t zstream);
+IL2CPP_EXPORT int32_t ReadZStream(intptr_t zstream, intptr_t buffer, int32_t length);
+IL2CPP_EXPORT int32_t WriteZStream(intptr_t zstream, intptr_t buffer, int32_t length);
+}

App/LearnWithTouch_ios/Libraries/libil2cpp/include/gc/Allocator.h

@@ -0,0 +1,55 @@
+#pragma once
+#include "GarbageCollector.h"
+
+namespace il2cpp
+{
+namespace gc
+{
+    template<typename T>
+    class Allocator
+    {
+    public:
+        typedef size_t    size_type;
+        typedef ptrdiff_t difference_type;
+        typedef T*        pointer;
+        typedef const T*  const_pointer;
+        typedef T&        reference;
+        typedef const T&  const_reference;
+        typedef T         value_type;
+        typedef Allocator<T> allocator_type;
+        Allocator() {}
+        Allocator(const Allocator&) {}
+
+        pointer allocate(size_type n, const void * = 0)
+        {
+            T* t = (T*)GarbageCollector::AllocateFixed(n * sizeof(T), 0);
+            return t;
+        }
+
+        void deallocate(void* p, size_type)
+        {
+            if (p)
+            {
+                GarbageCollector::FreeFixed(p);
+            }
+        }
+
+        pointer address(reference x) const { return &x; }
+        const_pointer address(const_reference x) const { return &x; }
+        Allocator<T>& operator=(const Allocator&) { return *this; }
+        void construct(pointer p, const T& val) { new((T*)p)T(val); }
+        void destroy(pointer p) { p->~T(); }
+
+        size_type max_size() const { return size_t(-1); }
+
+        template<class U>
+        struct rebind { typedef Allocator<U> other; };
+
+        template<class U>
+        Allocator(const Allocator<U>&) {}
+
+        template<class U>
+        Allocator& operator=(const Allocator<U>&) { return *this; }
+    };
+}
+}

App/LearnWithTouch_ios/Libraries/libil2cpp/include/gc/AppendOnlyGCHashMap.h

@@ -0,0 +1,115 @@
+#pragma once
+
+#include "utils/Il2CppHashMap.h"
+#include "utils/NonCopyable.h"
+#include "GarbageCollector.h"
+
+namespace il2cpp
+{
+namespace gc
+{
+    template<class Key, class T,
+             class HashFcn,
+             class EqualKey = std::equal_to<Key> >
+    class AppendOnlyGCHashMap : public il2cpp::utils::NonCopyable
+    {
+        typedef Il2CppHashMap<Key, size_t, HashFcn, EqualKey> hash_map_type;
+        typedef typename Il2CppHashMap<Key, size_t, HashFcn, EqualKey>::const_iterator ConstIterator;
+    public:
+
+        typedef typename hash_map_type::key_type key_type;
+        typedef T data_type;
+        typedef typename hash_map_type::size_type size_type;
+        typedef typename hash_map_type::hasher hasher;
+        typedef typename hash_map_type::key_equal key_equal;
+
+        AppendOnlyGCHashMap() :
+            m_Data(NULL),
+            m_Size(0)
+        {
+        }
+
+        ~AppendOnlyGCHashMap()
+        {
+            if (m_Data)
+                il2cpp::gc::GarbageCollector::FreeFixed(m_Data);
+        }
+
+        bool Contains(const Key& k)
+        {
+            return m_Map.find(k) != m_Map.end();
+        }
+
+        // Returns true if value was added. False if it already existed
+        bool Add(const Key& k, T value)
+        {
+            if (m_Map.find(k) != m_Map.end())
+                return false;
+
+            if (m_Size == 0)
+            {
+                m_Size = 8;
+                m_Data = (T*)il2cpp::gc::GarbageCollector::AllocateFixed(m_Size * sizeof(T), NULL);
+                assert(m_Data);
+            }
+            else if (m_Map.size() == m_Size)
+            {
+                size_t newSize = 2 * m_Size;
+                T* newData = (T*)il2cpp::gc::GarbageCollector::AllocateFixed(newSize * sizeof(T), NULL);
+
+                MemCpyData memCpyData = { newData, m_Data, m_Size * sizeof(T) };
+                // perform memcpy with GC lock held so GC doesn't see torn pointer values.I think this is less of an issue with Boehm than other GCs, but being safe.
+                il2cpp::gc::GarbageCollector::CallWithAllocLockHeld(&CopyValues, &memCpyData);
+
+                il2cpp::gc::GarbageCollector::FreeFixed(m_Data);
+
+                GarbageCollector::SetWriteBarrier((void**)newData, m_Size * sizeof(T));
+
+                m_Size = newSize;
+                m_Data = newData;
+                assert(m_Data);
+            }
+
+            size_t index = m_Map.size();
+            m_Map.insert(std::make_pair(k, index));
+            m_Data[index] = value;
+
+            GarbageCollector::SetWriteBarrier((void**)(m_Data + index));
+
+            assert(m_Map.size() <= m_Size);
+            return true;
+        }
+
+        bool TryGetValue(const Key& k, T* value)
+        {
+            ConstIterator iter = m_Map.find(k);
+            if (iter == m_Map.end())
+                return false;
+
+            size_t index = iter->second;
+            assert(index <= m_Map.size());
+            *value = m_Data[index];
+            return true;
+        }
+
+    private:
+        struct MemCpyData
+        {
+            void* dst;
+            const void* src;
+            size_t size;
+        };
+
+        static void* CopyValues(void* arg)
+        {
+            MemCpyData* thisPtr = (MemCpyData*)arg;
+            memcpy(thisPtr->dst, thisPtr->src, thisPtr->size);
+            return NULL;
+        }
+
+        Il2CppHashMap<Key, size_t, HashFcn, EqualKey> m_Map;
+        T* m_Data;
+        size_t m_Size;
+    };
+}
+}

App/LearnWithTouch_ios/Libraries/libil2cpp/include/gc/GCHandle.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <stdint.h>
+
+struct Il2CppObject;
+
+namespace il2cpp
+{
+namespace gc
+{
+    enum GCHandleType
+    {
+        HANDLE_WEAK,
+        HANDLE_WEAK_TRACK,
+        HANDLE_NORMAL,
+        HANDLE_PINNED
+    };
+
+    class LIBIL2CPP_CODEGEN_API GCHandle
+    {
+    public:
+        // external
+        static uint32_t New(Il2CppObject *obj, bool pinned);
+        static uint32_t NewWeakref(Il2CppObject *obj, bool track_resurrection);
+        static Il2CppObject* GetTarget(uint32_t gchandle);
+        static GCHandleType GetHandleType(uint32_t gcHandle);
+        static void Free(uint32_t gchandle);
+    public:
+        //internal
+        static int32_t GetTargetHandle(Il2CppObject * obj, int32_t handle, int32_t type);
+
+        typedef void(*WalkGCHandleTargetsCallback)(Il2CppObject* obj, void* context);
+        static void WalkStrongGCHandleTargets(WalkGCHandleTargetsCallback callback, void* context);
+    };
+} /* gc */
+} /* il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/gc/GarbageCollector.h

@@ -0,0 +1,93 @@
+#pragma once
+
+struct Il2CppGuid;
+struct Il2CppIUnknown;
+struct Il2CppObject;
+struct Il2CppThread;
+
+namespace il2cpp
+{
+namespace gc
+{
+    class LIBIL2CPP_CODEGEN_API GarbageCollector
+    {
+    public:
+        static void Collect(int maxGeneration);
+        static int32_t CollectALittle();
+        static int32_t GetCollectionCount(int32_t generation);
+        static int64_t GetUsedHeapSize();
+#if IL2CPP_ENABLE_WRITE_BARRIERS
+        static void SetWriteBarrier(void **ptr);
+        static void SetWriteBarrier(void **ptr, size_t numBytes);
+#else
+        static inline void SetWriteBarrier(void **ptr) {}
+        static inline void SetWriteBarrier(void **ptr, size_t numBytes) {}
+#endif
+
+    public:
+        // internal
+        typedef void (*FinalizerCallback)(void* object, void* client_data);
+
+        // functions implemented in a GC agnostic manner
+        static void InitializeFinalizer();
+        static bool IsFinalizerThread(Il2CppThread* thread);
+        static int32_t GetGeneration(void* addr);
+        static void UninitializeFinalizers();
+        static void UninitializeGC();
+        static void NotifyFinalizers();
+        static void RunFinalizer(void *obj, void *data);
+        static void RegisterFinalizerForNewObject(Il2CppObject* obj);
+        static void RegisterFinalizer(Il2CppObject* obj);
+        static void SuppressFinalizer(Il2CppObject* obj);
+        static void WaitForPendingFinalizers();
+        static int32_t GetMaxGeneration();
+        static void AddMemoryPressure(int64_t value);
+        static Il2CppIUnknown* GetOrCreateCCW(Il2CppObject* obj, const Il2CppGuid& iid);
+
+        // functions implemented in a GC specific manner
+        static void Initialize();
+        static void Enable();
+        static void Disable();
+        static bool IsDisabled();
+
+        static FinalizerCallback RegisterFinalizerWithCallback(Il2CppObject* obj, FinalizerCallback callback);
+
+        static int64_t GetAllocatedHeapSize();
+
+        static void* MakeDescriptorForObject(size_t *bitmap, int numbits);
+        static void* MakeDescriptorForString();
+        static void* MakeDescriptorForArray();
+
+        static void* AllocateFixed(size_t size, void *descr);
+        static void FreeFixed(void* addr);
+
+        static bool RegisterThread(void *baseptr);
+        static bool UnregisterThread();
+
+        static bool HasPendingFinalizers();
+        static int32_t InvokeFinalizers();
+
+        static void AddWeakLink(void **link_addr, Il2CppObject *obj, bool track);
+        static void RemoveWeakLink(void **link_addr);
+        static Il2CppObject *GetWeakLink(void **link_addr);
+
+        /* Used by liveness code */
+        static void StopWorld();
+        static void StartWorld();
+
+        typedef void (*HeapSectionCallback) (void* user_data, void* start, void* end);
+        static void ForEachHeapSection(void* user_data, HeapSectionCallback callback);
+        static size_t GetSectionCount();
+
+        typedef void* (*GCCallWithAllocLockCallback)(void* user_data);
+        static void* CallWithAllocLockHeld(GCCallWithAllocLockCallback callback, void* user_data);
+
+        static void RegisterRoot(char *start, size_t size);
+        static void UnregisterRoot(char* start);
+
+#if NET_4_0
+        static void SetSkipThread(bool skip);
+#endif
+    };
+} /* namespace vm */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/gc/WriteBarrier.h

@@ -0,0 +1,15 @@
+#pragma once
+
+struct Il2CppObject;
+
+namespace il2cpp
+{
+namespace gc
+{
+    class WriteBarrier
+    {
+    public:
+        static void GenericStore(void* ptr, Il2CppObject* value);
+    };
+} /* gc */
+} /* il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/gc/gc_wrapper.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "il2cpp-config.h"
+
+#if IL2CPP_GC_BOEHM
+
+/* here is the defines we build Boehm with */
+    #define IGNORE_DYNAMIC_LOADING 1
+    #define GC_DONT_REGISTER_MAIN_STATIC_DATA 1
+    #if IL2CPP_HAS_GC_DESCRIPTORS
+    #define GC_GCJ_SUPPORT 1
+    #endif
+    #if IL2CPP_SUPPORT_THREADS
+        #define GC_THREADS 1
+    #endif
+
+    #include "gc.h"
+    #include "gc_typed.h"
+    #include "gc_mark.h"
+    #include "gc_gcj.h"
+
+    #define GC_NO_DESCRIPTOR ((void*)(0 | GC_DS_LENGTH))
+
+#else
+    #define GC_NO_DESCRIPTOR ((void*)0)
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icallincludes.h

@@ -0,0 +1,180 @@
+#include "icalls/mscorlib/Mono.Globalization.Unicode/Normalization.h"
+
+#include "icalls/mscorlib/Mono.Interop/ComInteropProxy.h"
+
+#include "icalls/mscorlib/Mono/Runtime.h"
+
+#include "icalls/mscorlib/Mono.Security.Cryptography/KeyPairPersistence.h"
+
+#include "icalls/mscorlib/Mono.Unity/UnityTls.h"
+
+#include "icalls/mscorlib/System/__ComObject.h"
+
+#include "icalls/mscorlib/System/Activator.h"
+#include "icalls/mscorlib/System/AppDomain.h"
+#include "icalls/mscorlib/System/ArgIterator.h"
+#include "icalls/mscorlib/System/Array.h"
+#include "icalls/mscorlib/System/Buffer.h"
+#include "icalls/mscorlib/System/Char.h"
+#include "icalls/mscorlib/System/CLRConfig.h"
+#include "icalls/mscorlib/System/Convert.h"
+#include "icalls/mscorlib/System/ConsoleDriver.h"
+#include "icalls/mscorlib/System/CurrentSystemTimeZone.h"
+#include "icalls/mscorlib/System/DateTime.h"
+#include "icalls/mscorlib/System/Decimal.h"
+#include "icalls/mscorlib/System/Delegate.h"
+
+#include "icalls/mscorlib/System.Diagnostics/Assert.h"
+#include "icalls/mscorlib/System.Diagnostics/Debugger.h"
+#include "icalls/mscorlib/System.Diagnostics/StackFrame.h"
+#include "icalls/mscorlib/System.Diagnostics/StackTrace.h"
+#include "icalls/mscorlib/System/Double.h"
+
+#include "icalls/mscorlib/System/Enum.h"
+#include "icalls/mscorlib/System/Environment.h"
+#include "icalls/mscorlib/System/Exception.h"
+#include "icalls/mscorlib/System/GC.h"
+
+#include "icalls/mscorlib/System.Globalization/CalendarData.h"
+#include "icalls/mscorlib/System.Globalization/CompareInfo.h"
+#include "icalls/mscorlib/System.Globalization/CultureData.h"
+#include "icalls/mscorlib/System.Globalization/CultureInfo.h"
+#include "icalls/mscorlib/System.Globalization/RegionInfo.h"
+#include "icalls/mscorlib/System.IO/DriveInfo.h"
+#include "icalls/mscorlib/System.IO/MonoIO.h"
+#include "icalls/mscorlib/System.IO/Path.h"
+#include "icalls/mscorlib/System/Math.h"
+#include "icalls/mscorlib/System/MissingMemberException.h"
+#include "icalls/mscorlib/System/MonoCustomAttrs.h"
+#include "icalls/mscorlib/System/MonoEnumInfo.h"
+#include "icalls/mscorlib/System/MonoType.h"
+#include "icalls/mscorlib/System/Number.h"
+#include "icalls/mscorlib/System/NumberFormatter.h"
+#include "icalls/mscorlib/System/Object.h"
+
+#include "icalls/mscorlib/System.Reflection/Assembly.h"
+#include "icalls/mscorlib/System.Reflection/AssemblyName.h"
+#include "icalls/mscorlib/System.Reflection/CustomAttributeData.h"
+
+#include "icalls/mscorlib/System.Reflection.Emit/AssemblyBuilder.h"
+#include "icalls/mscorlib/System.Reflection.Emit/CustomAttributeBuilder.h"
+#include "icalls/mscorlib/System.Reflection.Emit/DerivedType.h"
+#include "icalls/mscorlib/System.Reflection.Emit/DynamicMethod.h"
+#include "icalls/mscorlib/System.Reflection.Emit/EnumBuilder.h"
+#include "icalls/mscorlib/System.Reflection.Emit/GenericTypeParameterBuilder.h"
+#include "icalls/mscorlib/System.Reflection.Emit/MethodBuilder.h"
+#include "icalls/mscorlib/System.Reflection.Emit/ModuleBuilder.h"
+#include "icalls/mscorlib/System.Reflection.Emit/SignatureHelper.h"
+#include "icalls/mscorlib/System.Reflection.Emit/SymbolType.h"
+#include "icalls/mscorlib/System.Reflection.Emit/TypeBuilder.h"
+
+#include "icalls/mscorlib/System.Reflection/FieldInfo.h"
+#include "icalls/mscorlib/System.Reflection/MemberInfo.h"
+#include "icalls/mscorlib/System.Reflection/MethodBase.h"
+#include "icalls/mscorlib/System.Reflection/Module.h"
+#include "icalls/mscorlib/System.Reflection/MonoCMethod.h"
+#include "icalls/mscorlib/System.Reflection/MonoEventInfo.h"
+#include "icalls/mscorlib/System.Reflection/MonoField.h"
+#include "icalls/mscorlib/System.Reflection/MonoGenericClass.h"
+#include "icalls/mscorlib/System.Reflection/MonoGenericCMethod.h"
+#include "icalls/mscorlib/System.Reflection/MonoGenericMethod.h"
+#include "icalls/mscorlib/System.Reflection/MonoMethod.h"
+#include "icalls/mscorlib/System.Reflection/MonoMethodInfo.h"
+#include "icalls/mscorlib/System.Reflection/MonoPropertyInfo.h"
+#include "icalls/mscorlib/System.Reflection/ParameterInfo.h"
+#include "icalls/mscorlib/System.Reflection/RtFieldInfo.h"
+
+#include "icalls/mscorlib/System.Runtime.CompilerServices/RuntimeHelpers.h"
+
+#include "icalls/mscorlib/System.Runtime.InteropServices/GCHandle.h"
+#include "icalls/mscorlib/System.Runtime.InteropServices/Marshal.h"
+#include "icalls/mscorlib/System.Runtime.InteropServices.WindowsRuntime/UnsafeNativeMethods.h"
+
+#include "icalls/mscorlib/System.Runtime.Remoting.Activation/ActivationServices.h"
+#include "icalls/mscorlib/System.Runtime.Remoting.Contexts/Context.h"
+#include "icalls/mscorlib/System.Runtime.Remoting.Messaging/AsyncResult.h"
+#include "icalls/mscorlib/System.Runtime.Remoting.Messaging/MonoMethodMessage.h"
+#include "icalls/mscorlib/System.Runtime.Remoting.Proxies/RealProxy.h"
+#include "icalls/mscorlib/System.Runtime.Remoting/RemotingServices.h"
+#include "icalls/mscorlib/System.Runtime.Versioning/VersioningHelper.h"
+
+#include "icalls/mscorlib/System/RuntimeFieldHandle.h"
+#include "icalls/mscorlib/System/RuntimeMethodHandle.h"
+#include "icalls/mscorlib/System/RuntimeTypeHandle.h"
+#include "icalls/mscorlib/System/RuntimeType.h"
+
+#include "icalls/mscorlib/System.Security.Cryptography/RNGCryptoServiceProvider.h"
+
+#include "icalls/mscorlib/System.Security.Policy/Evidence.h"
+
+#include "icalls/mscorlib/System.Security.Principal/WindowsIdentity.h"
+
+#include "icalls/mscorlib/System.Security.Principal/WindowsImpersonationContext.h"
+#include "icalls/mscorlib/System.Security.Principal/WindowsPrincipal.h"
+#include "icalls/mscorlib/System.Security/SecurityFrame.h"
+
+#include "icalls/mscorlib/System.Security/SecurityManager.h"
+#include "icalls/mscorlib/System/SizedReference.h"
+#include "icalls/mscorlib/System/String.h"
+
+#include "icalls/mscorlib/System.Text/Encoding.h"
+#include "icalls/mscorlib/System.Text/EncodingHelper.h"
+#include "icalls/mscorlib/System.Text/Normalization.h"
+
+#include "icalls/mscorlib/System.Threading/Interlocked.h"
+#include "icalls/mscorlib/System.Threading/InternalThread.h"
+#include "icalls/mscorlib/System.Threading/Monitor.h"
+#include "icalls/mscorlib/System.Threading/Mutex.h"
+#include "icalls/mscorlib/System.Threading/NativeEventCalls.h"
+#include "icalls/mscorlib/System.Threading/Timer.h"
+#include "icalls/mscorlib/System.Threading/Thread.h"
+#include "icalls/mscorlib/System.Threading/ThreadPool.h"
+#include "icalls/mscorlib/System.Threading/WaitHandle.h"
+#include "icalls/mscorlib/System/TimeSpan.h"
+#include "icalls/mscorlib/System/TimeZoneInfo.h"
+#include "icalls/mscorlib/System/Type.h"
+#include "icalls/mscorlib/System/TypedReference.h"
+#include "icalls/mscorlib/System/ValueType.h"
+
+#include "icalls/System/Microsoft.Win32/NativeMethods.h"
+#include "icalls/System/Mono.Net.Security/MonoTlsProviderFactory.h"
+
+#include "icalls/System.Configuration/System.Configuration/InternalConfigurationHost.h"
+#include "icalls/System.Core/System.IO.MemoryMappedFiles/MemoryMapImpl.h"
+
+#include "icalls/System/System.ComponentModel/Win32Exception.h"
+#include "icalls/System/System.Configuration/DefaultConfig.h"
+#include "icalls/System/System.Configuration/InternalConfigurationHost.h"
+
+#include "icalls/System/System.IO/FAMWatcher.h"
+#include "icalls/System/System.IO/FileSystemWatcher.h"
+#include "icalls/System/System.IO/InotifyWatcher.h"
+#include "icalls/System/System.IO/KqueueMonitor.h"
+#include "icalls/System/System/IOSelector.h"
+
+#include "icalls/System/System.Diagnostics/DefaultTraceListener.h"
+#include "icalls/System/System.Diagnostics/FileVersionInfo.h"
+#include "icalls/System/System.Diagnostics/PerformanceCounter.h"
+#include "icalls/System/System.Diagnostics/PerformanceCounterCategory.h"
+#include "icalls/System/System.Diagnostics/Process.h"
+#include "icalls/System/System.Diagnostics/Stopwatch.h"
+
+#include "icalls/System/System.Net/Dns.h"
+
+#include "icalls/System/System.Net.NetworkInformation/LinuxNetworkInterface.h"
+#include "icalls/System/System.Net.NetworkInformation/MacOsIPInterfaceProperties.h"
+#include "icalls/System/System.Net.Sockets/Socket.h"
+#include "icalls/System/System.Net.Sockets/SocketException.h"
+
+#include "icalls/System/System.Threading/Semaphore.h"
+
+#include "mono/ThreadPool/threadpool-ms.h"
+#include "mono/ThreadPool/threadpool-ms-io.h"
+
+#include "icalls/mscorlib/Mono/SafeStringMarshal.h"
+#include "icalls/mscorlib/Mono/RuntimeMarshal.h"
+#include "icalls/mscorlib/Mono/RuntimeGPtrArrayHandle.h"
+#include "icalls/mscorlib/Mono/RuntimeClassHandle.h"
+
+#include "icalls/mscorlib/System.Reflection/EventInfo.h"
+#include "icalls/mscorlib/System.Reflection/PropertyInfo.h"

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System.Configuration/System.Configuration/InternalConfigurationHost.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#if NET_4_0
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace Configuration
+{
+namespace System
+{
+namespace Configuration
+{
+    class LIBIL2CPP_CODEGEN_API InternalConfigurationHost
+    {
+    public:
+        static Il2CppString* get_bundled_app_config();
+    };
+} // namespace Configuration
+} // namespace System
+} // namespace Configuration
+} // namespace System
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System.Core/System.IO.MemoryMappedFiles/MemoryMapImpl.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#if NET_4_0
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace Core
+{
+namespace System
+{
+namespace IO
+{
+namespace MemoryMappedFiles
+{
+    class LIBIL2CPP_CODEGEN_API MemoryMapImpl
+    {
+    public:
+        static bool Unmap(intptr_t mmap_handle);
+        static int32_t MapInternal(intptr_t handle, int64_t offset, int64_t* size, int32_t access, intptr_t* mmap_handle, intptr_t* base_address);
+        static intptr_t OpenFileInternal(Il2CppString* path, int32_t mode, Il2CppString* mapName, int64_t* capacity, int32_t access, int32_t options, int32_t* error);
+        static intptr_t OpenHandleInternal(intptr_t handle, Il2CppString* mapName, int64_t* capacity, int32_t access, int32_t options, int32_t* error);
+        static void CloseMapping(intptr_t handle);
+        static void ConfigureHandleInheritability(intptr_t handle, int32_t inheritability);
+        static void Flush(intptr_t mmap_handle);
+    };
+} // namespace MemoryMappedFiles
+} // namespace IO
+} // namespace System
+} // namespace Core
+} // namespace System
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/Microsoft.Win32/NativeMethods.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#if NET_4_0
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace Microsoft
+{
+namespace Win32
+{
+    class LIBIL2CPP_CODEGEN_API NativeMethods
+    {
+    public:
+        static bool CloseProcess(intptr_t handle);
+        static bool GetExitCodeProcess(intptr_t processHandle, int32_t* exitCode);
+        static bool GetProcessTimes(intptr_t handle, int64_t* creation, int64_t* exit, int64_t* kernel, int64_t* user);
+        static bool GetProcessWorkingSetSize(intptr_t handle, intptr_t* min, intptr_t* max);
+        static bool SetPriorityClass(intptr_t handle, int32_t priorityClass);
+        static bool SetProcessWorkingSetSize(intptr_t handle, intptr_t min, intptr_t max);
+        static bool TerminateProcess(intptr_t processHandle, int32_t exitCode);
+        static int32_t GetCurrentProcessId();
+        static int32_t GetPriorityClass(intptr_t handle);
+        static int32_t WaitForInputIdle(intptr_t handle, int32_t milliseconds);
+        static intptr_t GetCurrentProcess();
+    };
+} // namespace Win32
+} // namespace Microsoft
+} // namespace System
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/Mono.Net.Security/MonoTlsProviderFactory.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#if NET_4_0
+
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace Mono
+{
+namespace Net
+{
+namespace Security
+{
+    class LIBIL2CPP_CODEGEN_API MonoTlsProviderFactory
+    {
+    public:
+        static bool IsBtlsSupported();
+        static Il2CppString* GetDefaultProviderForPlatform();
+    };
+} // namespace Security
+} // namespace Net
+} // namespace Mono
+} // namespace System
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.ComponentModel/Win32Exception.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace ComponentModel
+{
+    class LIBIL2CPP_CODEGEN_API Win32Exception
+    {
+    public:
+        static Il2CppString *W32ErrorMessage(int32_t code);
+    };
+} /* namespace ComponentModel */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Configuration/DefaultConfig.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-object-internals.h"
+#include "il2cpp-config.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Configuration
+{
+    class LIBIL2CPP_CODEGEN_API DefaultConfig
+    {
+    public:
+        static Il2CppString* get_machine_config_path();
+        static Il2CppString* get_bundled_machine_config();
+    };
+} /* namespace Configuration */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Configuration/InternalConfigurationHost.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Configuration
+{
+    class LIBIL2CPP_CODEGEN_API InternalConfigurationHost
+    {
+    public:
+        static Il2CppString* get_bundled_machine_config();
+    };
+} /* namespace Configuration */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Diagnostics/DefaultTraceListener.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Diagnostics
+{
+    class LIBIL2CPP_CODEGEN_API DefaultTraceListener
+    {
+    public:
+        static void WriteWindowsDebugString(Il2CppString* message);
+    };
+} /* namespace Diagnostics */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Diagnostics/FileVersionInfo.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Diagnostics
+{
+    class LIBIL2CPP_CODEGEN_API FileVersionInfo
+    {
+    public:
+        static void GetVersionInfo_internal(void* /* System.Diagnostics.FileVersionInfo */ self, Il2CppString* fileName);
+    };
+} /* namespace Diagnostics */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Diagnostics/PerformanceCounter.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Diagnostics
+{
+    struct Il2CppCounterSample;
+
+    class LIBIL2CPP_CODEGEN_API PerformanceCounter
+    {
+    public:
+        static void FreeData(intptr_t impl);
+        static bool GetSample(intptr_t impl, bool only_value, Il2CppCounterSample* sample);
+        static int64_t UpdateValue(intptr_t impl, bool do_incr, int64_t value);
+        static intptr_t GetImpl(Il2CppString* category, Il2CppString* counter, Il2CppString* instance, Il2CppString* machine, int* type, bool* custom);
+    };
+} /* namespace Diagnostics */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Diagnostics/PerformanceCounterCategory.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Diagnostics
+{
+    typedef int32_t PerformanceCounterCategoryType;
+
+    class LIBIL2CPP_CODEGEN_API PerformanceCounterCategory
+    {
+    public:
+        static Il2CppString* CategoryHelpInternal(Il2CppString* category, Il2CppString* machine);
+        static bool CounterCategoryExists(Il2CppString* counter, Il2CppString* category, Il2CppString* machine);
+        static bool Create(Il2CppString* categoryName, Il2CppString* categoryHelp, PerformanceCounterCategoryType categoryType, Il2CppArray* items);
+        static Il2CppArray* GetCategoryNames(Il2CppString* machine);
+        static Il2CppArray* GetCounterNames(Il2CppString* category, Il2CppString* machine);
+        static Il2CppArray* GetInstanceNames(Il2CppString* category, Il2CppString* machine);
+        static int32_t InstanceExistsInternal(Il2CppString* instance, Il2CppString* category, Il2CppString* machine);
+        static bool CategoryDelete(Il2CppString* name);
+    };
+} /* namespace Diagnostics */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Diagnostics/PerformanceCounterUtils.h

@@ -0,0 +1,262 @@
+#pragma once
+
+#include "il2cpp-class-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Diagnostics
+{
+    struct CategoryDesc
+    {
+        const char *name;
+        const char *help;
+        unsigned char id;
+        signed int type : 2;
+        unsigned int instance_type : 6;
+        short first_counter;
+    };
+
+#define PERFCTR_CAT(id, name, help, type, inst, first_counter) CATEGORY_ ## id,
+#define PERFCTR_COUNTER(id, name, help, type, field)
+    enum
+    {
+#include "perfcounters-def.h"
+        NUM_CATEGORIES
+    };
+
+#undef PERFCTR_CAT
+#undef PERFCTR_COUNTER
+#define PERFCTR_CAT(id, name, help, type, inst, first_counter) CATEGORY_START_ ## id = -1,
+#define PERFCTR_COUNTER(id, name, help, type, field) COUNTER_ ## id,
+/* each counter is assigned an id starting from 0 inside the category */
+    enum
+    {
+#include "perfcounters-def.h"
+        END_COUNTERS
+    };
+
+#undef PERFCTR_CAT
+#undef PERFCTR_COUNTER
+#define PERFCTR_CAT(id, name, help, type, inst, first_counter)
+#define PERFCTR_COUNTER(id, name, help, type, field) CCOUNTER_ ## id,
+/* this is used just to count the number of counters */
+    enum
+    {
+#include "perfcounters-def.h"
+        NUM_COUNTERS
+    };
+
+    struct CounterDesc
+    {
+        const char *name;
+        const char *help;
+        short id;
+        unsigned short offset; // offset inside Il2CppPerfCounters
+        int type;
+    };
+
+    enum
+    {
+        FTYPE_CATEGORY = 'C',
+        FTYPE_DELETED = 'D',
+        FTYPE_PREDEF_INSTANCE = 'P', // an instance of a predef counter
+        FTYPE_INSTANCE = 'I',
+        FTYPE_DIRTY = 'd',
+        FTYPE_END = 0
+    };
+
+    struct SharedHeader
+    {
+        unsigned char ftype;
+        unsigned char extra;
+        unsigned short size;
+    };
+
+    struct SharedCategory
+    {
+        SharedHeader header;
+        unsigned short num_counters;
+        unsigned short counters_data_size;
+        int num_instances;
+        /* variable length data follows */
+        char name[1];
+        // string name
+        // string help
+        // SharedCounter counters_info [num_counters]
+    };
+
+    struct SharedInstance
+    {
+        SharedHeader header;
+        size_t category_offset;
+        /* variable length data follows */
+        char instance_name[1];
+        // string name
+    };
+
+    struct SharedCounter
+    {
+        unsigned char type;
+        uint8_t seq_num;
+        /* variable length data follows */
+        char name[1];
+        // string name
+        // string help
+    };
+
+    struct CatSearch
+    {
+        Il2CppString *name;
+        SharedCategory *cat;
+    };
+
+/* map of PerformanceCounterType.cs */
+    enum
+    {
+        NumberOfItemsHEX32 = 0x00000000,
+        NumberOfItemsHEX64 = 0x00000100,
+        NumberOfItems32 = 0x00010000,
+        NumberOfItems64 = 0x00010100,
+        CounterDelta32 = 0x00400400,
+        CounterDelta64 = 0x00400500,
+        SampleCounter = 0x00410400,
+        CountPerTimeInterval32 = 0x00450400,
+        CountPerTimeInterval64 = 0x00450500,
+        RateOfCountsPerSecond32 = 0x10410400,
+        RateOfCountsPerSecond64 = 0x10410500,
+        RawFraction = 0x20020400,
+        CounterTimer = 0x20410500,
+        Timer100Ns = 0x20510500,
+        SampleFraction = 0x20C20400,
+        CounterTimerInverse = 0x21410500,
+        Timer100NsInverse = 0x21510500,
+        CounterMultiTimer = 0x22410500,
+        CounterMultiTimer100Ns = 0x22510500,
+        CounterMultiTimerInverse = 0x23410500,
+        CounterMultiTimer100NsInverse = 0x23510500,
+        AverageTimer32 = 0x30020400,
+        ElapsedTime = 0x30240500,
+        AverageCount64 = 0x40020500,
+        SampleBase = 0x40030401,
+        AverageBase = 0x40030402,
+        RawBase = 0x40030403,
+        CounterMultiBase = 0x42030500
+    };
+
+/* maps a small integer type to the counter types above */
+    static const int simple_type_to_type[] =
+    {
+        NumberOfItemsHEX32, NumberOfItemsHEX64,
+        NumberOfItems32, NumberOfItems64,
+        CounterDelta32, CounterDelta64,
+        SampleCounter, CountPerTimeInterval32,
+        CountPerTimeInterval64, RateOfCountsPerSecond32,
+        RateOfCountsPerSecond64, RawFraction,
+        CounterTimer, Timer100Ns,
+        SampleFraction, CounterTimerInverse,
+        Timer100NsInverse, CounterMultiTimer,
+        CounterMultiTimer100Ns, CounterMultiTimerInverse,
+        CounterMultiTimer100NsInverse, AverageTimer32,
+        ElapsedTime, AverageCount64,
+        SampleBase, AverageBase,
+        RawBase, CounterMultiBase
+    };
+
+    enum
+    {
+        SingleInstance,
+        MultiInstance,
+        CatTypeUnknown = -1
+    };
+
+    enum
+    {
+        ProcessInstance,
+        ThreadInstance,
+        CPUInstance,
+        MonoInstance,
+        NetworkInterfaceInstance,
+        CustomInstance
+    };
+
+/* map of CounterSample.cs */
+    struct Il2CppCounterSample
+    {
+        int64_t rawValue;
+        int64_t baseValue;
+        int64_t counterFrequency;
+        int64_t systemFrequency;
+        int64_t timeStamp;
+        int64_t timeStamp100nSec;
+        int64_t counterTimeStamp;
+        int counterType;
+    };
+
+#undef PERFCTR_CAT
+#undef PERFCTR_COUNTER
+#define PERFCTR_CAT(id, name, help, type, inst, first_counter) {name, help, CATEGORY_ ## id, type, inst ## Instance, CCOUNTER_ ## first_counter},
+#define PERFCTR_COUNTER(id, name, help, type, field)
+    static const CategoryDesc
+        predef_categories[] =
+    {
+        /* sample runtime counter */
+#include "perfcounters-def.h"
+        { NULL, NULL, NUM_CATEGORIES, -1, 0, NUM_COUNTERS }
+    };
+
+#undef PERFCTR_CAT
+#undef PERFCTR_COUNTER
+#define PERFCTR_CAT(id, name, help, type, inst, first_counter)
+#define PERFCTR_COUNTER(id, name, help, type, field) {name, help, COUNTER_ ## id, offsetof (Il2CppPerfCounters, field), type},
+    static const CounterDesc
+        predef_counters[] =
+    {
+#include "perfcounters-def.h"
+        { NULL, NULL, -1, 0, 0 }
+    };
+/*
+* We have several different classes of counters:
+* *) system counters
+* *) runtime counters
+* *) remote counters
+* *) user-defined counters
+* *) windows counters (the implementation on windows will use this)
+*
+* To easily handle the differences we create a vtable for each class that contains the
+* function pointers with the actual implementation to access the counters.
+*/
+    typedef struct _ImplVtable ImplVtable;
+
+    typedef bool(*SampleFunc) (ImplVtable *vtable, bool only_value, Il2CppCounterSample* sample);
+    typedef uint64_t(*UpdateFunc) (ImplVtable *vtable, bool do_incr, int64_t value);
+    typedef void(*CleanupFunc) (ImplVtable *vtable);
+
+    struct _ImplVtable
+    {
+        void *arg;
+        SampleFunc sample;
+        UpdateFunc update;
+        CleanupFunc cleanup;
+    };
+
+    struct CustomVTable
+    {
+        ImplVtable vtable;
+        SharedInstance *instance_desc;
+        SharedCounter *counter_desc;
+    };
+
+    const CategoryDesc* find_category(Il2CppString *category);
+    const CounterDesc* get_counter_in_category(const CategoryDesc *desc, Il2CppString *counter);
+    ImplVtable* create_vtable(void *arg, SampleFunc sample, UpdateFunc update);
+} /* namespace Diagnostics */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Diagnostics/Process.h

@@ -0,0 +1,59 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Diagnostics
+{
+    struct ProcInfo;
+
+    class LIBIL2CPP_CODEGEN_API Process
+    {
+    public:
+        static Il2CppArray* GetProcesses_internal();
+        static int32_t GetPid_internal();
+        static bool CreateProcess_internal(void* /* System.Diagnostics.ProcessStartInfo */ startInfo, intptr_t _stdin, intptr_t _stdout, intptr_t _stderr, ProcInfo* proc_info);
+        static int64_t ExitTime_internal(intptr_t handle);
+        static Il2CppArray* GetModules_internal(void* /* System.Diagnostics.Process */ self, intptr_t handle);
+        static int32_t GetPriorityClass(intptr_t handle, int32_t* error);
+        static int64_t GetProcessData(int32_t pid, int32_t data_type, int32_t* error);
+        static intptr_t GetProcess_internal(int32_t pid);
+        static bool GetWorkingSet_internal(intptr_t handle, int32_t* min, int32_t* max);
+        static bool Kill_internal(intptr_t handle, int32_t signo);
+        static Il2CppString* ProcessName_internal(intptr_t handle);
+        static void Process_free_internal(void* /* System.Diagnostics.Process */ self, intptr_t handle);
+        static bool SetPriorityClass(intptr_t handle, int32_t priority, int32_t* error);
+        static bool SetWorkingSet_internal(intptr_t handle, int32_t min, int32_t max, bool use_min);
+        static bool ShellExecuteEx_internal(void* /* System.Diagnostics.ProcessStartInfo */ startInfo, ProcInfo* proc_info);
+        static int64_t StartTime_internal(intptr_t handle);
+        static int64_t Times(intptr_t handle, int32_t type);
+        static bool WaitForExit_internal(void* /* System.Diagnostics.Process */ self, intptr_t handle, int32_t ms);
+        static bool WaitForInputIdle_internal(void* /* System.Diagnostics.Process */ self, intptr_t handle, int32_t ms);
+        static int32_t ExitCode_internal(intptr_t handle);
+    };
+} /* namespace Diagnostics */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Diagnostics/Stopwatch.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Diagnostics
+{
+    class LIBIL2CPP_CODEGEN_API Stopwatch
+    {
+    public:
+        static int64_t GetTimestamp();
+    };
+} /* namespace Diagnostics */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Diagnostics/perfcounters-def.h

@@ -0,0 +1,135 @@
+/*
+* Define the system and runtime performance counters.
+* Each category is defined with the macro:
+*       PERFCTR_CAT(catid, name, help, type, instances, first_counter_id)
+* and after that follows the counters inside the category, defined by the macro:
+*       PERFCTR_COUNTER(counter_id, name, help, type, field)
+* field is the field inside MonoPerfCounters per predefined counters.
+* Note we set it to unused for unrelated counters: it is unused
+* in those cases.
+*/
+//PERFCTR_CAT(CPU, "Processor", "", MultiInstance, CPU, CPU_USER_TIME)
+//PERFCTR_COUNTER(CPU_USER_TIME, "% User Time", "", Timer100Ns, unused)
+//PERFCTR_COUNTER(CPU_PRIV_TIME, "% Privileged Time", "", Timer100Ns, unused)
+//PERFCTR_COUNTER(CPU_INTR_TIME, "% Interrupt Time", "", Timer100Ns, unused)
+//PERFCTR_COUNTER(CPU_DCP_TIME, "% DCP Time", "", Timer100Ns, unused)
+//PERFCTR_COUNTER(CPU_PROC_TIME, "% Processor Time", "", Timer100NsInverse, unused)
+//
+//PERFCTR_CAT(PROC, "Process", "", MultiInstance, Process, PROC_USER_TIME)
+//PERFCTR_COUNTER(PROC_USER_TIME, "% User Time", "", Timer100Ns, unused)
+//PERFCTR_COUNTER(PROC_PRIV_TIME, "% Privileged Time", "", Timer100Ns, unused)
+//PERFCTR_COUNTER(PROC_PROC_TIME, "% Processor Time", "", Timer100Ns, unused)
+//PERFCTR_COUNTER(PROC_THREADS, "Thread Count", "", NumberOfItems64, unused)
+//PERFCTR_COUNTER(PROC_VBYTES, "Virtual Bytes", "", NumberOfItems64, unused)
+//PERFCTR_COUNTER(PROC_WSET, "Working Set", "", NumberOfItems64, unused)
+//PERFCTR_COUNTER(PROC_PBYTES, "Private Bytes", "", NumberOfItems64, unused)
+
+/* sample runtime counter */
+PERFCTR_CAT(MONO_MEM, "Mono Memory", "", SingleInstance, Mono, MEM_NUM_OBJECTS)
+PERFCTR_COUNTER(MEM_NUM_OBJECTS, "Allocated Objects", "", NumberOfItems64, unused)
+//PERFCTR_COUNTER(MEM_PHYS_TOTAL, "Total Physical Memory", "Physical memory installed in the machine, in bytes", NumberOfItems64, unused)
+//PERFCTR_COUNTER(MEM_PHYS_AVAILABLE, "Available Physical Memory", "Physical memory available in the machine, in bytes", NumberOfItems64, unused)
+//
+//PERFCTR_CAT(ASPNET, "ASP.NET", "", MultiInstance, Mono, ASPNET_REQ_Q)
+//PERFCTR_COUNTER(ASPNET_REQ_Q, "Requests Queued", "", NumberOfItems64, aspnet_requests_queued)
+//PERFCTR_COUNTER(ASPNET_REQ_TOTAL, "Requests Total", "", NumberOfItems32, aspnet_requests)
+//PERFCTR_COUNTER(ASPNET_REQ_PSEC, "Requests/Sec", "", RateOfCountsPerSecond32, aspnet_requests)
+//
+//PERFCTR_CAT(JIT, ".NET CLR JIT", "", MultiInstance, Mono, JIT_BYTES)
+//PERFCTR_COUNTER(JIT_BYTES, "# of IL Bytes JITted", "", NumberOfItems32, jit_bytes)
+//PERFCTR_COUNTER(JIT_METHODS, "# of IL Methods JITted", "", NumberOfItems32, jit_methods)
+//PERFCTR_COUNTER(JIT_TIME, "% Time in JIT", "", RawFraction, jit_time)
+//PERFCTR_COUNTER(JIT_BYTES_PSEC, "IL Bytes Jitted/Sec", "", RateOfCountsPerSecond32, jit_bytes)
+//PERFCTR_COUNTER(JIT_FAILURES, "Standard Jit Failures", "", NumberOfItems32, jit_failures)
+//
+//PERFCTR_CAT(EXC, ".NET CLR Exceptions", "", MultiInstance, Mono, EXC_THROWN)
+//PERFCTR_COUNTER(EXC_THROWN, "# of Exceps Thrown", "", NumberOfItems32, exceptions_thrown)
+//PERFCTR_COUNTER(EXC_THROWN_PSEC, "# of Exceps Thrown/Sec", "", RateOfCountsPerSecond32, exceptions_thrown)
+//PERFCTR_COUNTER(EXC_FILTERS_PSEC, "# of Filters/Sec", "", RateOfCountsPerSecond32, exceptions_filters)
+//PERFCTR_COUNTER(EXC_FINALLYS_PSEC, "# of Finallys/Sec", "", RateOfCountsPerSecond32, exceptions_finallys)
+//PERFCTR_COUNTER(EXC_CATCH_DEPTH, "Throw to Catch Depth/Sec", "", NumberOfItems32, exceptions_depth)
+//
+//PERFCTR_CAT(GC, ".NET CLR Memory", "", MultiInstance, Mono, GC_GEN0)
+//PERFCTR_COUNTER(GC_GEN0, "# Gen 0 Collections", "", NumberOfItems32, gc_collections0)
+//PERFCTR_COUNTER(GC_GEN1, "# Gen 1 Collections", "", NumberOfItems32, gc_collections1)
+//PERFCTR_COUNTER(GC_GEN2, "# Gen 2 Collections", "", NumberOfItems32, gc_collections2)
+//PERFCTR_COUNTER(GC_PROM0, "Promoted Memory from Gen 0", "", NumberOfItems32, gc_promotions0)
+//PERFCTR_COUNTER(GC_PROM1, "Promoted Memory from Gen 1", "", NumberOfItems32, gc_promotions1)
+//PERFCTR_COUNTER(GC_PROM0SEC, "Gen 0 Promoted Bytes/Sec", "", RateOfCountsPerSecond32, gc_promotions0)
+//PERFCTR_COUNTER(GC_PROM1SEC, "Gen 1 Promoted Bytes/Sec", "", RateOfCountsPerSecond32, gc_promotions1)
+//PERFCTR_COUNTER(GC_PROMFIN, "Promoted Finalization-Memory from Gen 0", "", NumberOfItems32, gc_promotion_finalizers)
+//PERFCTR_COUNTER(GC_GEN0SIZE, "Gen 0 heap size", "", NumberOfItems32, gc_gen0size)
+//PERFCTR_COUNTER(GC_GEN1SIZE, "Gen 1 heap size", "", NumberOfItems32, gc_gen1size)
+//PERFCTR_COUNTER(GC_GEN2SIZE, "Gen 2 heap size", "", NumberOfItems32, gc_gen2size)
+//PERFCTR_COUNTER(GC_LOSIZE, "Large Object Heap size", "", NumberOfItems32, gc_lossize)
+//PERFCTR_COUNTER(GC_FINSURV, "Finalization Survivors", "", NumberOfItems32, gc_fin_survivors)
+//PERFCTR_COUNTER(GC_NHANDLES, "# GC Handles", "", NumberOfItems32, gc_num_handles)
+//PERFCTR_COUNTER(GC_BYTESSEC, "Allocated Bytes/sec", "", RateOfCountsPerSecond32, gc_allocated)
+//PERFCTR_COUNTER(GC_INDGC, "# Induced GC", "", NumberOfItems32, gc_induced)
+//PERFCTR_COUNTER(GC_PERCTIME, "% Time in GC", "", RawFraction, gc_time)
+//PERFCTR_COUNTER(GC_BYTES, "# Bytes in all Heaps", "", NumberOfItems32, gc_total_bytes)
+//PERFCTR_COUNTER(GC_COMMBYTES, "# Total committed Bytes", "", NumberOfItems32, gc_committed_bytes)
+//PERFCTR_COUNTER(GC_RESBYTES, "# Total reserved Bytes", "", NumberOfItems32, gc_reserved_bytes)
+//PERFCTR_COUNTER(GC_PINNED, "# of Pinned Objects", "", NumberOfItems32, gc_num_pinned)
+//PERFCTR_COUNTER(GC_SYNKB, "# of Sink Blocks in use", "", NumberOfItems32, gc_sync_blocks)
+//
+//PERFCTR_CAT(REMOTING, ".NET CLR Remoting", "", MultiInstance, Mono, REMOTING_CALLSEC)
+//PERFCTR_COUNTER(REMOTING_CALLSEC, "Remote Calls/sec", "", RateOfCountsPerSecond32, remoting_calls)
+//PERFCTR_COUNTER(REMOTING_CALLS, "Total Remote Calls", "", NumberOfItems32, remoting_calls)
+//PERFCTR_COUNTER(REMOTING_CHANNELS, "Channels", "", NumberOfItems32, remoting_channels)
+//PERFCTR_COUNTER(REMOTING_CPROXIES, "Context Proxies", "", NumberOfItems32, remoting_proxies)
+//PERFCTR_COUNTER(REMOTING_CBLOADED, "Context-Bound Classes Loaded", "", NumberOfItems32, remoting_classes)
+//PERFCTR_COUNTER(REMOTING_CBALLOCSEC, "Context-Bound Objects Alloc / sec", "", RateOfCountsPerSecond32, remoting_objects)
+//PERFCTR_COUNTER(REMOTING_CONTEXTS, "Contexts", "", NumberOfItems32, remoting_contexts)
+//
+//PERFCTR_CAT(LOADING, ".NET CLR Loading", "", MultiInstance, Mono, LOADING_CLASSES)
+//PERFCTR_COUNTER(LOADING_CLASSES, "Current Classes Loaded", "", NumberOfItems32, loader_classes)
+//PERFCTR_COUNTER(LOADING_TOTCLASSES, "Total Classes Loaded", "", NumberOfItems32, loader_total_classes)
+//PERFCTR_COUNTER(LOADING_CLASSESSEC, "Rate of Classes Loaded", "", RateOfCountsPerSecond32, loader_total_classes)
+//PERFCTR_COUNTER(LOADING_APPDOMAINS, "Current appdomains", "", NumberOfItems32, loader_appdomains)
+//PERFCTR_COUNTER(LOADING_TOTAPPDOMAINS, "Total Appdomains", "", NumberOfItems32, loader_total_appdomains)
+//PERFCTR_COUNTER(LOADING_APPDOMAINSEC, "Rate of appdomains", "", RateOfCountsPerSecond32, loader_total_appdomains)
+//PERFCTR_COUNTER(LOADING_ASSEMBLIES, "Current Assemblies", "", NumberOfItems32, loader_assemblies)
+//PERFCTR_COUNTER(LOADING_TOTASSEMBLIES, "Total Assemblies", "", NumberOfItems32, loader_total_assemblies)
+//PERFCTR_COUNTER(LOADING_ASSEMBLIESEC, "Rate of Assemblies", "", RateOfCountsPerSecond32, loader_total_assemblies)
+//PERFCTR_COUNTER(LOADING_FAILURES, "Total # of Load Failures", "", NumberOfItems32, loader_failures)
+//PERFCTR_COUNTER(LOADING_FAILURESSEC, "Rate of Load Failures", "", RateOfCountsPerSecond32, loader_failures)
+//PERFCTR_COUNTER(LOADING_BYTES, "Bytes in Loader Heap", "", NumberOfItems32, loader_bytes)
+//PERFCTR_COUNTER(LOADING_APPUNLOADED, "Total appdomains unloaded", "", NumberOfItems32, loader_appdomains_uloaded)
+//PERFCTR_COUNTER(LOADING_APPUNLOADEDSEC, "Rate of appdomains unloaded", "", RateOfCountsPerSecond32, loader_appdomains_uloaded)
+//
+//PERFCTR_CAT(THREAD, ".NET CLR LocksAndThreads", "", MultiInstance, Mono, THREAD_CONTENTIONS)
+//PERFCTR_COUNTER(THREAD_CONTENTIONS, "Total # of Contentions", "", NumberOfItems32, thread_contentions)
+//PERFCTR_COUNTER(THREAD_CONTENTIONSSEC, "Contention Rate / sec", "", RateOfCountsPerSecond32, thread_contentions)
+//PERFCTR_COUNTER(THREAD_QUEUELEN, "Current Queue Length", "", NumberOfItems32, thread_queue_len)
+//PERFCTR_COUNTER(THREAD_QUEUELENP, "Queue Length Peak", "", NumberOfItems32, thread_queue_max)
+//PERFCTR_COUNTER(THREAD_QUEUELENSEC, "Queue Length / sec", "", RateOfCountsPerSecond32, thread_queue_max)
+//PERFCTR_COUNTER(THREAD_NUMLOG, "# of current logical Threads", "", NumberOfItems32, thread_num_logical)
+//PERFCTR_COUNTER(THREAD_NUMPHYS, "# of current physical Threads", "", NumberOfItems32, thread_num_physical)
+//PERFCTR_COUNTER(THREAD_NUMREC, "# of current recognized threads", "", NumberOfItems32, thread_cur_recognized)
+//PERFCTR_COUNTER(THREAD_TOTREC, "# of total recognized threads", "", NumberOfItems32, thread_num_recognized)
+//PERFCTR_COUNTER(THREAD_TOTRECSEC, "rate of recognized threads / sec", "", RateOfCountsPerSecond32, thread_num_recognized)
+//
+//PERFCTR_CAT(INTEROP, ".NET CLR Interop", "", MultiInstance, Mono, INTEROP_NUMCCW)
+//PERFCTR_COUNTER(INTEROP_NUMCCW, "# of CCWs", "", NumberOfItems32, interop_num_ccw)
+//PERFCTR_COUNTER(INTEROP_STUBS, "# of Stubs", "", NumberOfItems32, interop_num_stubs)
+//PERFCTR_COUNTER(INTEROP_MARSH, "# of marshalling", "", NumberOfItems32, interop_num_marshals)
+//
+//PERFCTR_CAT(SECURITY, ".NET CLR Security", "", MultiInstance, Mono, SECURITY_CHECKS)
+//PERFCTR_COUNTER(SECURITY_CHECKS, "Total Runtime Checks", "", NumberOfItems32, security_num_checks)
+//PERFCTR_COUNTER(SECURITY_LCHECKS, "# Link Time Checks", "", NumberOfItems32, security_num_link_checks)
+//PERFCTR_COUNTER(SECURITY_PERCTIME, "% Time in RT checks", "", RawFraction, security_time)
+//PERFCTR_COUNTER(SECURITY_SWDEPTH, "Stack Walk Depth", "", NumberOfItems32, security_depth)
+//
+//PERFCTR_CAT(THREADPOOL, "Mono Threadpool", "", MultiInstance, Mono, THREADPOOL_WORKITEMS)
+//PERFCTR_COUNTER(THREADPOOL_WORKITEMS, "Work Items Added", "", NumberOfItems64, threadpool_workitems)
+//PERFCTR_COUNTER(THREADPOOL_WORKITEMS_PSEC, "Work Items Added/Sec", "", RateOfCountsPerSecond32, threadpool_workitems)
+//PERFCTR_COUNTER(THREADPOOL_IOWORKITEMS, "IO Work Items Added", "", NumberOfItems64, threadpool_ioworkitems)
+//PERFCTR_COUNTER(THREADPOOL_IOWORKITEMS_PSEC, "IO Work Items Added/Sec", "", RateOfCountsPerSecond32, threadpool_ioworkitems)
+//PERFCTR_COUNTER(THREADPOOL_THREADS, "# of Threads", "", NumberOfItems32, threadpool_threads)
+//PERFCTR_COUNTER(THREADPOOL_IOTHREADS, "# of IO Threads", "", NumberOfItems32, threadpool_iothreads)
+//
+//PERFCTR_CAT(NETWORK, "Network Interface", "", MultiInstance, NetworkInterface, NETWORK_BYTESRECSEC)
+//PERFCTR_COUNTER(NETWORK_BYTESRECSEC, "Bytes Received/sec", "", RateOfCountsPerSecond64, unused)
+//PERFCTR_COUNTER(NETWORK_BYTESSENTSEC, "Bytes Sent/sec", "", RateOfCountsPerSecond64, unused)
+//PERFCTR_COUNTER(NETWORK_BYTESTOTALSEC, "Bytes Total/sec", "", RateOfCountsPerSecond64, unused)

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.IO/FAMWatcher.h

@@ -0,0 +1,40 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-object-internals.h"
+#include "il2cpp-config.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace IO
+{
+    struct FAMConnection;
+
+    class LIBIL2CPP_CODEGEN_API FAMWatcher
+    {
+    public:
+        static int32_t InternalFAMNextEvent(FAMConnection* fc, Il2CppString** filename, int32_t* code, int32_t* reqnum);
+    };
+} /* namespace IO */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.IO/FileSystemWatcher.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-object-internals.h"
+#include "il2cpp-config.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace IO
+{
+    class LIBIL2CPP_CODEGEN_API FileSystemWatcher
+    {
+    public:
+        static int32_t InternalSupportsFSW();
+    };
+} /* namespace IO */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.IO/InotifyWatcher.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-object-internals.h"
+#include "il2cpp-config.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace IO
+{
+    typedef int32_t InotifyMask;
+
+    class LIBIL2CPP_CODEGEN_API InotifyWatcher
+    {
+    public:
+        static intptr_t RemoveWatch(intptr_t fd, int32_t wd);
+        static int32_t AddWatch(intptr_t fd, Il2CppString* name, InotifyMask mask);
+        static intptr_t GetInotifyInstance();
+    };
+} /* namespace IO */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.IO/KqueueMonitor.h

@@ -0,0 +1,25 @@
+#pragma once
+#if NET_4_0
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace IO
+{
+    class LIBIL2CPP_CODEGEN_API KqueueMonitor
+    {
+    public:
+        static int32_t kevent_notimeout(int32_t* kq, intptr_t ev, int32_t nchanges, intptr_t evtlist, int32_t nevents);
+    };
+} // namespace IO
+} // namespace System
+} // namespace System
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Net.NetworkInformation/LinuxNetworkInterface.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#if !NET_4_0
+
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Net
+{
+namespace NetworkInformation
+{
+    class LIBIL2CPP_CODEGEN_API LinuxNetworkInterface
+    {
+    public:
+        static int32_t GetInterfaceAddresses(intptr_t* ifap);
+        static void FreeInterfaceAddresses(intptr_t ifap);
+        static void InitializeInterfaceAddresses();
+    };
+} // namespace NetworkInformation
+} // namespace Net
+} // namespace System
+} // namespace System
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Net.NetworkInformation/MacOsIPInterfaceProperties.h

@@ -0,0 +1,26 @@
+#pragma once
+#if NET_4_0
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Net
+{
+namespace NetworkInformation
+{
+    class LIBIL2CPP_CODEGEN_API MacOsIPInterfaceProperties
+    {
+    public:
+        static bool ParseRouteInfo_internal(Il2CppString* iface, Il2CppArray** gw_addr_list);
+    };
+} // namespace NetworkInformation
+} // namespace Net
+} // namespace System
+} // namespace System
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Net.Sockets/Socket.h

@@ -0,0 +1,257 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppArray;
+struct Il2CppObject;
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Net
+{
+namespace Sockets
+{
+    enum AddressFamily
+    {
+        kAddressFamilyUnknown           = -1,
+        kAddressFamilyUnspecified       = 0,
+        kAddressFamilyUnix              = 1,
+        kAddressFamilyInterNetwork      = 2,
+        kAddressFamilyImpLink           = 3,
+        kAddressFamilyPup               = 4,
+        kAddressFamilyChaos             = 5,
+        kAddressFamilyNS                = 6,
+        kAddressFamilyIpx               = 6,
+        kAddressFamilyIso               = 7,
+        kAddressFamilyOsi               = 7,
+        kAddressFamilyEcma              = 8,
+        kAddressFamilyDataKit           = 9,
+        kAddressFamilyCcitt             = 10,
+        kAddressFamilySna               = 11,
+        kAddressFamilyDecNet            = 12,
+        kAddressFamilyDataLink          = 13,
+        kAddressFamilyLat               = 14,
+        kAddressFamilyHyperChannel      = 15,
+        kAddressFamilyAppleTalk         = 16,
+        kAddressFamilyNetBios           = 17,
+        kAddressFamilyVoiceView         = 18,
+        kAddressFamilyFireFox           = 19,
+        kAddressFamilyBanyan            = 21,
+        kAddressFamilyAtm               = 22,
+        kAddressFamilyInterNetworkV6    = 23,
+        kAddressFamilyCluster           = 24,
+        kAddressFamilyIeee12844         = 25,
+        kAddressFamilyIrda              = 26,
+        kAddressFamilyNetworkDesigners  = 28,
+        kAddressFamilyMax               = 29,
+    };
+
+    enum SocketType
+    {
+        kSocketTypeUnknown  = -1,
+        kSocketTypeStream   = 1,
+        kSocketTypeDgram    = 2,
+        kSocketTypeRaw      = 3,
+        kSocketTypeRdm      = 4,
+        kSocketTypeSeqpacket = 5,
+    };
+
+    enum ProtocolType
+    {
+        kProtocolTypeUnknown                            = -1,
+        kProtocolTypeIP                                 = 0,
+        kProtocolTypeIcmp                               = 1,
+        kProtocolTypeIgmp                               = 2,
+        kProtocolTypeGgp                                = 3,
+        kProtocolTypeTcp                                = 6,
+        kProtocolTypePup                                = 12,
+        kProtocolTypeUdp                                = 17,
+        kProtocolTypeIdp                                = 22,
+        kProtocolTypeND                                 = 77,
+        kProtocolTypeRaw                                = 255,
+        kProtocolTypeUnspecified                        = 0,
+        kProtocolTypeIpx                                = 1000,
+        kProtocolTypeSpx                                = 1256,
+        kProtocolTypeSpxII                              = 1257,
+
+// #if NET_1_1
+        kProtocolTypeIPv6                               = 41,
+// #endif
+
+// #if NET_2_0
+        kProtocolTypeIPv4                               = 4,
+        kProtocolTypeIPv6RoutingHeader                  = 43,
+        kProtocolTypeIPv6FragmentHeader                 = 44,
+        kProtocolTypeIPSecEncapsulatingSecurityPayload  = 50,
+        kProtocolTypeIPSecAuthenticationHeader          = 51,
+        kProtocolTypeIcmpV6                             = 58,
+        kProtocolTypeIPv6NoNextHeader                   = 59,
+        kProtocolTypeIPv6DestinationOptions             = 60,
+        kProtocolTypeIPv6HopByHopOptions                = 0,
+// #endif
+    };
+
+    enum SocketOptionLevel
+    {
+        kSocketOptionLevelSocket    = 65535,
+        kSocketOptionLevelIP        = 0,
+        kSocketOptionLevelTcp       = 6,
+        kSocketOptionLevelUdp       = 17,
+
+//#if NET_1_1
+        kSocketOptionLevelIPv6      = 41,
+//#endif
+    };
+
+    enum SocketOptionName
+    {
+        kSocketOptionNameDebug                  = 1,
+        kSocketOptionNameAcceptConnection       = 2,
+        kSocketOptionNameReuseAddress           = 4,
+        kSocketOptionNameKeepAlive              = 8,
+        kSocketOptionNameDontRoute              = 16,
+        kSocketOptionNameBroadcast              = 32,
+        kSocketOptionNameUseLoopback            = 64,
+        kSocketOptionNameLinger                 = 128,
+        kSocketOptionNameOutOfBandInline        = 256,
+        kSocketOptionNameDontLinger             = -129,
+        kSocketOptionNameExclusiveAddressUse    = -5,
+        kSocketOptionNameSendBuffer             = 4097,
+        kSocketOptionNameReceiveBuffer          = 4098,
+        kSocketOptionNameSendLowWater           = 4099,
+        kSocketOptionNameReceiveLowWater        = 4100,
+        kSocketOptionNameSendTimeout            = 4101,
+        kSocketOptionNameReceiveTimeout         = 4102,
+        kSocketOptionNameError                  = 4103,
+        kSocketOptionNameType                   = 4104,
+        kSocketOptionNameMaxConnections         = 2147483647,
+        kSocketOptionNameIPOptions              = 1,
+        kSocketOptionNameHeaderIncluded         = 2,
+        kSocketOptionNameTypeOfService          = 3,
+        kSocketOptionNameIpTimeToLive           = 4,
+        kSocketOptionNameMulticastInterface     = 9,
+        kSocketOptionNameMulticastTimeToLive    = 10,
+        kSocketOptionNameMulticastLoopback      = 11,
+        kSocketOptionNameAddMembership          = 12,
+        kSocketOptionNameDropMembership         = 13,
+        kSocketOptionNameDontFragment           = 14,
+        kSocketOptionNameAddSourceMembership    = 15,
+        kSocketOptionNameDropSourceMembership   = 16,
+        kSocketOptionNameBlockSource            = 17,
+        kSocketOptionNameUnblockSource          = 18,
+        kSocketOptionNamePacketInformation      = 19,
+        kSocketOptionNameNoDelay                = 1,
+        kSocketOptionNameBsdUrgent              = 2,
+        kSocketOptionNameExpedited              = 2,
+        kSocketOptionNameNoChecksum             = 1,
+        kSocketOptionNameChecksumCoverage       = 20,
+
+// #if NET_2_0
+        kSocketOptionNameHopLimit               = 21,
+        kSocketOptionNameUpdateAcceptContext    = 28683,
+        kSocketOptionNameUpdateConnectContext   = 28688,
+// #endif
+    };
+
+    enum SelectMode
+    {
+        kSelectModeSelectRead   = 0,
+        kSelectModeSelectWrite  = 1,
+        kSelectModeSelectError  = 2,
+    };
+
+    enum SocketFlags
+    {
+        kSocketFlagsNone                    = 0x00000000,
+        kSocketFlagsOutOfBand               = 0x00000001,
+        kSocketFlagsPeek                    = 0x00000002,
+        kSocketFlagsDontRoute               = 0x00000004,
+        kSocketFlagsMaxIOVectorLength       = 0x00000010,
+// #if NET_2_0
+        kSocketFlagsTruncated               = 0x00000100,
+        kSocketFlagsControlDataTruncated    = 0x00000200,
+        kSocketFlagsBroadcast               = 0x00000400,
+        kSocketFlagsMulticast               = 0x00000800,
+// #endif
+        kSocketFlagsPartial                 = 0x00008000,
+    };
+
+    enum TransmitFileOptions
+    {
+        kTransmitFileOptionsUseDefaultWorkerThread  = 0x00000000,
+        kTransmitFileOptionsDisconnect              = 0x00000001,
+        kTransmitFileOptionsReuseSocket             = 0x00000002,
+        kTransmitFileOptionsWriteBehind             = 0x00000004,
+        kTransmitFileOptionsUseSystemThread         = 0x00000010,
+        kTransmitFileOptionsUseKernelApc            = 0x00000020,
+    };
+
+    enum SocketShutdown
+    {
+        kSocketShutdownReceive  = 0,
+        kSocketShutdownSend     = 1,
+        kSocketShutdownBoth     = 2,
+    };
+
+    class LIBIL2CPP_CODEGEN_API Socket
+    {
+    public:
+        static intptr_t Accept(intptr_t, int32_t*, bool);
+        static int32_t Available(intptr_t, int32_t*);
+        static void Bind(intptr_t, Il2CppSocketAddress*, int32_t*);
+        static void Blocking(intptr_t, bool, int32_t*);
+        static void Close(intptr_t, int32_t*);
+        static void Connect(intptr_t, Il2CppSocketAddress*, int32_t*);
+        static void Disconnect(intptr_t, bool, int32_t*);
+        static void GetSocketOptionArray(intptr_t, SocketOptionLevel, SocketOptionName, Il2CppArray**, int32_t*);
+        static void GetSocketOptionObj(intptr_t, SocketOptionLevel, SocketOptionName, Il2CppObject**, int32_t*);
+        static void Listen(intptr_t, int32_t, int32_t*);
+        static Il2CppSocketAddress* LocalEndPoint(intptr_t, int32_t*);
+        static bool Poll(intptr_t, SelectMode, int32_t, int32_t*);
+        static int32_t ReceiveArray(intptr_t, Il2CppArray*, SocketFlags, int32_t*);
+        static int32_t Receive(intptr_t, Il2CppArray*, int32_t, int32_t, SocketFlags, int32_t*);
+        static int32_t RecvFrom(intptr_t, Il2CppArray*, int32_t, int32_t, SocketFlags, Il2CppSocketAddress**, int32_t*);
+        static Il2CppSocketAddress* RemoteEndPoint(intptr_t, int32_t*);
+        static void Select(Il2CppArray**, int32_t, int32_t*);
+        static bool SendFile(intptr_t, Il2CppString*, Il2CppArray*, Il2CppArray*, TransmitFileOptions);
+        static int32_t SendTo(intptr_t, Il2CppArray*, int32_t, int32_t, SocketFlags, Il2CppSocketAddress*, int32_t*);
+        static int32_t SendArray(intptr_t, Il2CppArray*, SocketFlags, int32_t*);
+        static int32_t Send(intptr_t, Il2CppArray*, int32_t, int32_t, SocketFlags, int32_t*);
+        static void SetSocketOption(intptr_t, SocketOptionLevel, SocketOptionName, Il2CppObject*, Il2CppArray*, int32_t, int32_t*);
+        static void Shutdown(intptr_t, SocketShutdown, int32_t*);
+        static intptr_t Socket_internal(Il2CppObject * self, AddressFamily, SocketType, ProtocolType, int32_t*);
+        static int32_t WSAIoctl(intptr_t, int32_t, Il2CppArray*, Il2CppArray*, int32_t*);
+#if NET_4_0
+        static bool SendFile_internal(intptr_t sock, Il2CppString* filename, Il2CppArray* pre_buffer, Il2CppArray* post_buffer, int32_t flags, int32_t* error, bool blocking);
+        static bool SupportsPortReuse(ProtocolType proto);
+        static int32_t IOControl_internal(intptr_t sock, int32_t ioctl_code, Il2CppArray* input, Il2CppArray* output, int32_t* error);
+        static int32_t ReceiveFrom_internal(intptr_t sock, uint8_t* buffer, int32_t count, SocketFlags flags, Il2CppSocketAddress** sockaddr, int32_t* error, bool blocking);
+        static int32_t SendTo_internal(intptr_t sock, uint8_t* buffer, int32_t count, SocketFlags flags, Il2CppSocketAddress* sa, int32_t* error, bool blocking);
+        static Il2CppSocketAddress* LocalEndPoint_internal(intptr_t socket, int32_t family, int32_t* error);
+        static Il2CppSocketAddress* RemoteEndPoint_internal(intptr_t socket, int32_t family, int32_t* error);
+        static void cancel_blocking_socket_operation(Il2CppObject* thread);
+        static void Connect_internal(intptr_t sock, Il2CppSocketAddress* sa, int32_t* error, bool blocking);
+        static bool Duplicate_internal(intptr_t handle, int32_t targetProcessId, intptr_t *duplicate_handle, int32_t *werror);
+
+        static int32_t ReceiveArray40(intptr_t, void*, int32_t, SocketFlags, int32_t*, bool);
+        static int32_t Receive40(intptr_t, uint8_t*, int32_t, SocketFlags, int32_t*, bool);
+        static int32_t SendArray40(intptr_t, void*, int32_t, SocketFlags, int32_t*, bool);
+        static int32_t Send40(intptr_t, uint8_t*, int32_t, SocketFlags, int32_t*, bool);
+        static bool IsProtocolSupported_internal(int32_t networkInterface);
+#endif
+    };
+} /* namespace Sockets */
+} /* namespace Net */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Net.Sockets/SocketException.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppArray;
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Net
+{
+namespace Sockets
+{
+    class LIBIL2CPP_CODEGEN_API SocketException
+    {
+    public:
+        static int32_t WSAGetLastError();
+    };
+} /* namespace Sockets */
+} /* namespace Net */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Net/Dns.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppArray;
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Net
+{
+    class LIBIL2CPP_CODEGEN_API Dns
+    {
+    public:
+        static bool GetHostByAddr(Il2CppString*, Il2CppString**, Il2CppArray**, Il2CppArray**);
+        static bool GetHostByName(Il2CppString*, Il2CppString**, Il2CppArray**, Il2CppArray**);
+#if NET_4_0
+        static bool GetHostByAddr40(Il2CppString*, Il2CppString**, Il2CppArray**, Il2CppArray**, int32_t hint);
+        static bool GetHostByName40(Il2CppString*, Il2CppString**, Il2CppArray**, Il2CppArray**, int32_t hint);
+#endif
+        static bool GetHostName(Il2CppString**);
+    };
+} /* namespace Net */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System.Threading/Semaphore.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+namespace Threading
+{
+    class LIBIL2CPP_CODEGEN_API Semaphore
+    {
+    public:
+#if !NET_4_0
+        static intptr_t CreateSemaphore_internal(int32_t initialCount, int32_t maximumCount, Il2CppString* name, bool* created);
+        static int32_t ReleaseSemaphore_internal(intptr_t handlePtr, int32_t releaseCount, bool* fail);
+#else
+        static intptr_t CreateSemaphore_internal40(int32_t initialCount, int32_t maximumCount, Il2CppString* name, int32_t* errorCode);
+        static bool ReleaseSemaphore_internal40(intptr_t handlePtr, int32_t releaseCount, int32_t* previousCount);
+#endif
+        static intptr_t OpenSemaphore_internal(Il2CppString* name, int32_t rights, int32_t* error);
+    };
+} /* namespace Threading */
+} /* namespace System */
+} /* namespace System */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/System/System/IOSelector.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#if NET_4_0
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace System
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API IOSelector
+    {
+    public:
+        static void Add(intptr_t handle, Il2CppObject* job);
+        static void Remove(intptr_t handle);
+    };
+} // namespace System
+} // namespace System
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/Mono.Globalization.Unicode/Normalization.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace Mono
+{
+namespace Globalization
+{
+namespace Unicode
+{
+    class LIBIL2CPP_CODEGEN_API Normalization
+    {
+    public:
+        static void load_normalization_resource(intptr_t* argProps, intptr_t* argMappedChars, intptr_t* argCharMapIndex, intptr_t* argHelperIndex, intptr_t* argMapIdxToComposite, intptr_t* argCombiningClass);
+    };
+} /* namespace Unicode */
+} /* namespace Globalization */
+} /* namespace Mono */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/Mono.Interop/ComInteropProxy.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct mscorlib_Mono_Interop_ComInteropProxy;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace Mono
+{
+namespace Interop
+{
+    class LIBIL2CPP_CODEGEN_API ComInteropProxy
+    {
+    public:
+        static void AddProxy(intptr_t pItf, mscorlib_Mono_Interop_ComInteropProxy * proxy);
+        static mscorlib_Mono_Interop_ComInteropProxy* FindProxy(intptr_t pItf);
+    };
+} /* namespace Interop */
+} /* namespace Mono */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/Mono.Security.Cryptography/KeyPairPersistence.h

@@ -0,0 +1,32 @@
+#pragma once
+#include "il2cpp-config.h"
+
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace Mono
+{
+namespace Security
+{
+namespace Cryptography
+{
+    class LIBIL2CPP_CODEGEN_API KeyPairPersistence
+    {
+    public:
+        static bool _CanSecure(Il2CppString* root);
+        static bool _IsUserProtected(Il2CppString* path);
+        static bool _ProtectMachine(Il2CppString* path);
+        static bool _ProtectUser(Il2CppString* path);
+        static bool _IsMachineProtected(Il2CppString* path);
+    };
+} /* namespace Cryptography */
+} /* namespace Security */
+} /* namespace Mono */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/Mono.Unity/UnityTls.h

@@ -0,0 +1,23 @@
+#pragma once
+#include "il2cpp-config.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace Mono
+{
+namespace Unity
+{
+    class LIBIL2CPP_CODEGEN_API UnityTls
+    {
+    public:
+        static const void* GetUnityTlsInterface();
+    };
+} /* namespace Unity */
+} /* namespace Mono */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/Mono/Runtime.h

@@ -0,0 +1,26 @@
+#pragma once
+#include "il2cpp-config.h"
+
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace Mono
+{
+    class LIBIL2CPP_CODEGEN_API Runtime
+    {
+    public:
+        static void mono_runtime_install_handlers();
+        static Il2CppString* GetDisplayName();
+#if NET_4_0
+        static Il2CppString* GetNativeStackTrace(Il2CppException* exception);
+#endif
+    };
+} /* namespace Mono */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/Mono/RuntimeClassHandle.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#if NET_4_0
+
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace Mono
+{
+    class LIBIL2CPP_CODEGEN_API RuntimeClassHandle
+    {
+    public:
+        static intptr_t GetTypeFromClass(Il2CppClass* klass);
+    };
+} // namespace Mono
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/Mono/RuntimeGPtrArrayHandle.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#if NET_4_0
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace Mono
+{
+    class LIBIL2CPP_CODEGEN_API RuntimeGPtrArrayHandle
+    {
+    public:
+        static void GPtrArrayFree(void* value);
+    };
+} // namespace Mono
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/Mono/RuntimeMarshal.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#if NET_4_0
+
+struct Il2CppMonoAssemblyName;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace Mono
+{
+    class LIBIL2CPP_CODEGEN_API RuntimeMarshal
+    {
+    public:
+        static void FreeAssemblyName(Il2CppMonoAssemblyName* name, bool freeStruct);
+    };
+} // namespace Mono
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/Mono/SafeStringMarshal.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#if NET_4_0
+
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace Mono
+{
+    class LIBIL2CPP_CODEGEN_API SafeStringMarshal
+    {
+    public:
+        static intptr_t StringToUtf8(Il2CppString* str);
+        static void GFree(intptr_t ptr);
+    };
+} // namespace Mono
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Diagnostics/Assert.h

@@ -0,0 +1,23 @@
+#pragma once
+#if NET_4_0
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Diagnostics
+{
+    class LIBIL2CPP_CODEGEN_API Assert
+    {
+    public:
+        static int32_t ShowDefaultAssertDialog(Il2CppString* conditionString, Il2CppString* message, Il2CppString* stackTrace, Il2CppString* windowTitle);
+    };
+} // namespace Diagnostics
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Diagnostics/Debugger.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Diagnostics
+{
+    class LIBIL2CPP_CODEGEN_API Debugger
+    {
+    public:
+        static bool IsAttached_internal();
+
+#if NET_4_0
+        static bool IsLogging();
+        static void Log(int32_t level, Il2CppString* category, Il2CppString* message);
+#endif
+    };
+} /* namespace Diagnostics */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Diagnostics/StackFrame.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppString;
+struct Il2CppReflectionMethod;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Diagnostics
+{
+    class LIBIL2CPP_CODEGEN_API StackFrame
+    {
+    public:
+        static bool get_frame_info(
+            int32_t skip,
+            bool needFileInfo,
+            Il2CppReflectionMethod ** method,
+            int32_t* iloffset,
+            int32_t* native_offset,
+            Il2CppString** file,
+            int32_t* line,
+            int32_t* column);
+    };
+} /* namespace Diagnostics */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Diagnostics/StackTrace.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppArray;
+struct Il2CppException;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Diagnostics
+{
+    class LIBIL2CPP_CODEGEN_API StackTrace
+    {
+    public:
+        static Il2CppArray* get_trace(Il2CppException *exc, int32_t skip, bool need_file_info);
+    };
+} /* namespace Diagnostics */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/CalendarData.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#if NET_4_0
+struct Il2CppCalendarData;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Globalization
+{
+    class LIBIL2CPP_CODEGEN_API CalendarData
+    {
+    public:
+        static bool fill_calendar_data(Il2CppCalendarData* _this, Il2CppString* localeName, int32_t datetimeIndex);
+    };
+} // namespace Globalization
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/CompareInfo.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "CompareOptions.h"
+
+struct Il2CppString;
+struct Il2CppObject;
+struct Il2CppSortKey;
+struct mscorlib_System_Globalization_CompareInfo;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Globalization
+{
+    class LIBIL2CPP_CODEGEN_API CompareInfo
+    {
+    public:
+        static void assign_sortkey(void* /* System.Globalization.CompareInfo */ self, Il2CppSortKey* key, Il2CppString* source, CompareOptions options);
+        static void free_internal_collator(mscorlib_System_Globalization_CompareInfo * thisPtr);
+        static int internal_compare(mscorlib_System_Globalization_CompareInfo *, Il2CppString *, int, int, Il2CppString *, int, int, int);
+        static int internal_index(mscorlib_System_Globalization_CompareInfo *thisPtr, Il2CppString *source, int sindex, int count, Il2CppString *value, int options, bool first);
+        static void construct_compareinfo(mscorlib_System_Globalization_CompareInfo *, Il2CppString *);
+    };
+} /* namespace Globalization */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/CompareOptions.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <stdint.h>
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Globalization
+{
+// System.Globalization.CompareOptions
+    typedef enum
+    {
+        CompareOptions_None              = 0x00,
+        CompareOptions_IgnoreCase        = 0x01,
+        CompareOptions_IgnoreNonSpace    = 0x02,
+        CompareOptions_IgnoreSymbols     = 0x04,
+        CompareOptions_IgnoreKanaType    = 0x08,
+        CompareOptions_IgnoreWidth       = 0x10,
+        CompareOptions_StringSort        = 0x20000000,
+        CompareOptions_Ordinal           = 0x40000000,
+        CompareOptions_OrdinalIgnoreCase = 0x10000000
+    } CompareOptions;
+} /* namespace Globalization */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/CultureData.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#if NET_4_0
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Globalization
+{
+    class LIBIL2CPP_CODEGEN_API CultureData
+    {
+    public:
+        static void fill_culture_data(Il2CppCultureData* _this, int32_t datetimeIndex);
+        static void fill_number_data(Il2CppNumberFormatInfo* number, int32_t numberIndex);
+    };
+} // namespace Globalization
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/CultureInfo.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppString;
+struct Il2CppCultureInfo;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Globalization
+{
+    class LIBIL2CPP_CODEGEN_API CultureInfo
+    {
+    public:
+#if !NET_4_0
+        static void construct_datetime_format(Il2CppCultureInfo* cultureInfo);
+        static bool construct_internal_locale_from_current_locale(Il2CppCultureInfo* cultureInfo);
+#endif
+        static bool construct_internal_locale_from_lcid(Il2CppCultureInfo* cultureInfo, int lcid);
+        static bool construct_internal_locale_from_name(Il2CppCultureInfo* cultureInfo, Il2CppString* name);
+#if !NET_4_0
+        static bool construct_internal_locale_from_specific_name(Il2CppCultureInfo* cultureInfo, Il2CppString* name);
+#endif
+        static Il2CppArray* internal_get_cultures(bool neutral, bool specific, bool installed);
+        static bool internal_is_lcid_neutral(int32_t lcid, bool* is_neutral);
+#if !NET_4_0
+        static void construct_number_format(Il2CppCultureInfo* cultureInfo);
+#endif
+        static Il2CppString* get_current_locale_name();
+    };
+} /* namespace Diagnostics */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/CultureInfoInternals.h

@@ -0,0 +1,143 @@
+#pragma once
+
+#include <stdint.h>
+
+#if NET_4_0
+#include "Generated/CultureInfoInternalsNet_4_0.h"
+#else
+
+#define NUM_DAYS 7
+#define NUM_MONTHS 13
+#define GROUP_SIZE 5
+#define NUM_OPT_CALS 5
+
+#define NUM_SHORT_DATE_PATTERNS 14
+#define NUM_LONG_DATE_PATTERNS 8
+#define NUM_SHORT_TIME_PATTERNS 11
+#define NUM_LONG_TIME_PATTERNS 10
+
+#define idx2string(idx) (locale_strings + (idx))
+
+struct DateTimeFormatEntry
+{
+    const uint16_t full_date_time_pattern;
+    const uint16_t long_date_pattern;
+    const uint16_t short_date_pattern;
+    const uint16_t long_time_pattern;
+    const uint16_t short_time_pattern;
+    const uint16_t year_month_pattern;
+    const uint16_t month_day_pattern;
+
+    const uint16_t am_designator;
+    const uint16_t pm_designator;
+
+    const uint16_t day_names[NUM_DAYS];
+    const uint16_t abbreviated_day_names[NUM_DAYS];
+    const uint16_t month_names[NUM_MONTHS];
+    const uint16_t abbreviated_month_names[NUM_MONTHS];
+
+    int8_t calendar_week_rule;
+    int8_t first_day_of_week;
+
+    const uint16_t date_separator;
+    const uint16_t time_separator;
+
+    const uint16_t short_date_patterns[NUM_SHORT_DATE_PATTERNS];
+    const uint16_t long_date_patterns[NUM_LONG_DATE_PATTERNS];
+    const uint16_t short_time_patterns[NUM_SHORT_TIME_PATTERNS];
+    const uint16_t long_time_patterns[NUM_LONG_TIME_PATTERNS];
+};
+
+struct NumberFormatEntry
+{
+    const uint16_t currency_decimal_separator;
+    const uint16_t currency_group_separator;
+    const uint16_t percent_decimal_separator;
+    const uint16_t percent_group_separator;
+    const uint16_t number_decimal_separator;
+    const uint16_t number_group_separator;
+
+    const uint16_t currency_symbol;
+    const uint16_t percent_symbol;
+    const uint16_t nan_symbol;
+    const uint16_t per_mille_symbol;
+    const uint16_t negative_infinity_symbol;
+    const uint16_t positive_infinity_symbol;
+
+    const uint16_t negative_sign;
+    const uint16_t positive_sign;
+
+    int8_t currency_negative_pattern;
+    int8_t currency_positive_pattern;
+    int8_t percent_negative_pattern;
+    int8_t percent_positive_pattern;
+    int8_t number_negative_pattern;
+
+    int8_t currency_decimal_digits;
+    int8_t percent_decimal_digits;
+    int8_t number_decimal_digits;
+
+    const int currency_group_sizes[GROUP_SIZE];
+    const int percent_group_sizes[GROUP_SIZE];
+    const int number_group_sizes[GROUP_SIZE];
+};
+
+struct TextInfoEntry
+{
+    /*const*/ int ansi;
+    /*const*/ int ebcdic;
+    /*const*/ int mac;
+    /*const*/ int oem;
+    /*const*/ char list_sep;
+};
+
+struct CultureInfoEntry
+{
+    int16_t lcid;
+    int16_t parent_lcid;
+    int16_t specific_lcid;
+    int16_t region_entry_index;
+    /*const*/ uint16_t name;
+    /*const*/ uint16_t icu_name;
+    /*const*/ uint16_t englishname;
+    /*const*/ uint16_t displayname;
+    /*const*/ uint16_t nativename;
+    /*const*/ uint16_t win3lang;
+    /*const*/ uint16_t iso3lang;
+    /*const*/ uint16_t iso2lang;
+    /*const*/ uint16_t territory;
+
+    int calendar_data[NUM_OPT_CALS];
+
+    int16_t datetime_format_index;
+    int16_t number_format_index;
+
+    TextInfoEntry text_info;
+};
+
+struct CultureInfoNameEntry
+{
+    const uint16_t name;
+    int16_t culture_entry_index;
+};
+
+struct RegionInfoEntry
+{
+    int16_t lcid;
+    int16_t region_id;
+    const uint16_t iso2name;
+    const uint16_t iso3name;
+    const uint16_t win3name;
+    const uint16_t english_name;
+    const uint16_t currency_symbol;
+    const uint16_t iso_currency_symbol;
+    const uint16_t currency_english_name;
+};
+
+struct RegionInfoNameEntry
+{
+    const uint16_t name;
+    int16_t region_entry_index;
+};
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/Generated/CultureInfoInternalsNet_4_0.h

@@ -0,0 +1,138 @@
+//This is a Generated File.... Run CultureInfoUpdater tool to update
+/**
+ * \file
+ */
+
+#ifndef _MONO_METADATA_CULTURE_INFO_H_
+#define _MONO_METADATA_CULTURE_INFO_H_ 1
+
+
+
+
+#define NUM_DAYS 7
+#define NUM_MONTHS 13
+#define GROUP_SIZE 2
+#define NUM_CALENDARS 4
+
+#define NUM_SHORT_DATE_PATTERNS 14
+#define NUM_LONG_DATE_PATTERNS 10
+#define NUM_SHORT_TIME_PATTERNS 12
+#define NUM_LONG_TIME_PATTERNS 9
+#define NUM_YEAR_MONTH_PATTERNS 8
+
+#define idx2string(idx) (locale_strings + (idx))
+#define pattern2string(idx) (patterns + (idx))
+#define dtidx2string(idx) (datetime_strings + (idx))
+
+/* need to change this if the string data ends up to not fit in a 64KB array. */
+
+
+typedef struct {
+	const uint16_t month_day_pattern;
+	const uint16_t am_designator;
+	const uint16_t pm_designator;
+
+	const uint16_t day_names [NUM_DAYS]; 
+	const uint16_t abbreviated_day_names [NUM_DAYS];
+	const uint16_t shortest_day_names [NUM_DAYS];
+	const uint16_t month_names [NUM_MONTHS];
+	const uint16_t month_genitive_names [NUM_MONTHS];
+	const uint16_t abbreviated_month_names [NUM_MONTHS];
+	const uint16_t abbreviated_month_genitive_names [NUM_MONTHS];
+
+	const int8_t calendar_week_rule;
+	const int8_t first_day_of_week;
+
+	const uint16_t date_separator;
+	const uint16_t time_separator;	
+
+	const uint16_t short_date_patterns [NUM_SHORT_DATE_PATTERNS];
+	const uint16_t long_date_patterns [NUM_LONG_DATE_PATTERNS];
+	const uint16_t short_time_patterns [NUM_SHORT_TIME_PATTERNS];
+	const uint16_t long_time_patterns [NUM_LONG_TIME_PATTERNS];
+	const uint16_t year_month_patterns [NUM_YEAR_MONTH_PATTERNS];
+} DateTimeFormatEntry;
+
+typedef struct {
+	const uint16_t currency_decimal_separator;
+	const uint16_t currency_group_separator;
+	const uint16_t number_decimal_separator;
+	const uint16_t number_group_separator;
+
+	const uint16_t currency_symbol;
+	const uint16_t percent_symbol;
+	const uint16_t nan_symbol;
+	const uint16_t per_mille_symbol;
+	const uint16_t negative_infinity_symbol;
+	const uint16_t positive_infinity_symbol;
+
+	const uint16_t negative_sign;
+	const uint16_t positive_sign;
+
+	const int8_t currency_negative_pattern;
+	const int8_t currency_positive_pattern;
+	const int8_t percent_negative_pattern;
+	const int8_t percent_positive_pattern;
+	const int8_t number_negative_pattern;
+
+	const int8_t currency_decimal_digits;
+	const int8_t number_decimal_digits;
+
+	const int currency_group_sizes [GROUP_SIZE];
+	const int number_group_sizes [GROUP_SIZE];	
+} NumberFormatEntry;
+
+typedef struct {
+	int ansi;
+	int ebcdic;
+	int mac;
+	int oem;
+	bool is_right_to_left;
+	char list_sep;
+} TextInfoEntry;
+
+typedef struct {
+	int16_t lcid;
+	int16_t parent_lcid;
+	int16_t calendar_type;
+	int16_t region_entry_index;
+	uint16_t name;
+	uint16_t englishname;
+	uint16_t nativename;
+	uint16_t win3lang;
+	uint16_t iso3lang;
+	uint16_t iso2lang;
+	uint16_t territory;
+	uint16_t native_calendar_names [NUM_CALENDARS];
+
+	int16_t datetime_format_index;
+	int16_t number_format_index;
+	
+	TextInfoEntry text_info;
+} CultureInfoEntry;
+
+typedef struct {
+	const uint16_t name;
+	const int16_t culture_entry_index;
+} CultureInfoNameEntry;
+
+typedef struct {
+	const int16_t geo_id;
+	const uint16_t iso2name;
+	const uint16_t iso3name;
+	const uint16_t win3name;
+	const uint16_t english_name;
+	const uint16_t native_name;
+	const uint16_t currency_symbol;
+	const uint16_t iso_currency_symbol;
+	const uint16_t currency_english_name;
+	const uint16_t currency_native_name;
+} RegionInfoEntry;
+
+typedef struct {
+	const uint16_t name;
+	const int16_t region_entry_index;
+} RegionInfoNameEntry;
+
+#endif
+

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Globalization/RegionInfo.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Globalization
+{
+    class LIBIL2CPP_CODEGEN_API RegionInfo
+    {
+    public:
+        static bool construct_internal_region_from_name(Il2CppRegionInfo* regionInfo, Il2CppString* name);
+    };
+} /* namespace Globalization */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.IO/DriveInfo.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+typedef int32_t MonoIOError;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace IO
+{
+    class LIBIL2CPP_CODEGEN_API DriveInfo
+    {
+    public:
+        static uint32_t GetDriveTypeInternal(Il2CppString* rootPathName);
+        static bool GetDiskFreeSpaceInternal(Il2CppString* pathName, uint64_t* freeBytesAvail, uint64_t* totalNumberOfBytes, uint64_t* totalNumberOfFreeBytes, MonoIOError* error);
+#if NET_4_0
+        static Il2CppString* GetDriveFormat(Il2CppString* rootPathName);
+#endif
+    };
+} /* namespace IO */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.IO/MonoIO.h

@@ -0,0 +1,104 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppArray;
+struct Il2CppString;
+
+typedef int32_t MonoIOError;
+typedef int32_t FileAttributes;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace IO
+{
+    struct FileStat
+    {
+#if !NET_4_0
+        Il2CppString *name;
+#endif
+        int32_t attributes;
+        int64_t length;
+        int64_t creation_time;
+        int64_t last_access_time;
+        int64_t last_write_time;
+    };
+
+    class LIBIL2CPP_CODEGEN_API MonoIO
+    {
+    public:
+        static bool Close(intptr_t handle, int *error);
+        static bool CopyFile(Il2CppString* src, Il2CppString* dest, bool overwrite, MonoIOError* error);
+        static bool CopyFile40(Il2CppChar* src, Il2CppChar* dest, bool overwrite, MonoIOError* error);
+        static bool CreateDirectory(Il2CppString* path, MonoIOError* error);
+        static bool CreateDirectory40(Il2CppChar* path, MonoIOError* error);
+        static bool CreatePipe(intptr_t* read_handle, intptr_t* write_handle);
+        static bool DeleteFile(Il2CppString* path, MonoIOError* error);
+        static bool DeleteFile40(Il2CppChar* path, MonoIOError* error);
+        static bool DuplicateHandle(intptr_t source_process_handle, intptr_t source_handle, intptr_t target_process_handle, intptr_t* target_handle, int32_t access, int32_t inherit, int32_t options);
+        static bool Flush(intptr_t handle, MonoIOError* error);
+        static Il2CppString* GetCurrentDirectory(MonoIOError* error);
+        static FileAttributes GetFileAttributes(Il2CppString* path, MonoIOError* error);
+        static FileAttributes GetFileAttributes40(Il2CppChar* path, MonoIOError* error);
+        static bool GetFileStat(Il2CppString* path, FileStat * stat, int32_t* error);
+        static bool GetFileStat40(Il2CppChar* path, FileStat * stat, int32_t* error);
+        static Il2CppArray* GetFileSystemEntries(Il2CppString* path, Il2CppString* path_with_pattern, int32_t attrs, int32_t mask, MonoIOError* error);
+        static int GetFileType(intptr_t handle, int *error);
+        static int64_t GetLength(intptr_t handle, int *error);
+        static int32_t GetTempPath(Il2CppString** path);
+        static void Lock(intptr_t handle, int64_t position, int64_t length, MonoIOError* error);
+        static bool MoveFile(Il2CppString* src, Il2CppString* dest, MonoIOError* error);
+        static bool MoveFile40(Il2CppChar* src, Il2CppChar* dest, MonoIOError* error);
+        static intptr_t Open(Il2CppString *filename, int mode, int access_mode, int share, int options, int *error);
+        static intptr_t Open40(Il2CppChar *filename, int mode, int access_mode, int share, int options, int *error);
+        static int Read(intptr_t handle, Il2CppArray *dest, int dest_offset, int count, int *error);
+        static bool RemoveDirectory(Il2CppString* path, MonoIOError* error);
+        static bool RemoveDirectory40(Il2CppChar* path, MonoIOError* error);
+        static bool ReplaceFile(Il2CppString* sourceFileName, Il2CppString* destinationFileName, Il2CppString* destinationBackupFileName, bool ignoreMetadataErrors, MonoIOError* error);
+        static bool ReplaceFile40(Il2CppChar* sourceFileName, Il2CppChar* destinationFileName, Il2CppChar* destinationBackupFileName, bool ignoreMetadataErrors, MonoIOError* error);
+        static int64_t Seek(intptr_t handle, int64_t offset, int origin, int *error);
+        static bool SetCurrentDirectory(Il2CppString* path, int* error);
+        static bool SetCurrentDirectory40(Il2CppChar* path, int* error);
+        static bool SetFileAttributes(Il2CppString* path, FileAttributes attrs, MonoIOError* error);
+        static bool SetFileAttributes40(Il2CppChar* path, FileAttributes attrs, MonoIOError* error);
+        static bool SetFileTime(intptr_t handle, int64_t creation_time, int64_t last_access_time, int64_t last_write_time, MonoIOError* error);
+        static bool SetLength(intptr_t handle, int64_t length, int *error);
+        static void Unlock(intptr_t handle, int64_t position, int64_t length, MonoIOError* error);
+        static int Write(intptr_t handle, Il2CppArray * src, int src_offset, int count, int * error);
+        static Il2CppChar get_AltDirectorySeparatorChar(void);
+        static intptr_t get_ConsoleError(void);
+        static intptr_t get_ConsoleInput(void);
+        static intptr_t get_ConsoleOutput(void);
+        static Il2CppChar get_DirectorySeparatorChar(void);
+        static Il2CppChar get_PathSeparator(void);
+        static Il2CppChar get_VolumeSeparatorChar(void);
+        static bool CreatePipe40(intptr_t* read_handle, intptr_t* write_handle, MonoIOError* error);
+        static bool DuplicateHandle40(intptr_t source_process_handle, intptr_t source_handle, intptr_t target_process_handle, intptr_t* target_handle, int32_t access, int32_t inherit, int32_t options, MonoIOError* error);
+        static bool RemapPath(Il2CppString* path, Il2CppString** newPath);
+
+#if NET_4_0
+        static int32_t FindClose(intptr_t handle);
+        static Il2CppString* FindFirst(Il2CppString* path, Il2CppString* pathWithPattern, int32_t* resultAttributes, MonoIOError* error, intptr_t* handle);
+        static Il2CppString* FindNext(intptr_t handle, int32_t* result_attr, MonoIOError* error);
+        static void DumpHandles();
+#endif
+
+#if NET_4_0
+        static bool FindCloseFile(intptr_t hnd);
+        static bool FindNextFile(intptr_t hnd, Il2CppString** fileName, int32_t* fileAttr, int32_t* error);
+        static intptr_t FindFirstFile(Il2CppChar* path_with_pattern, Il2CppString** fileName, int32_t* fileAttr, int32_t* error);
+#endif
+    };
+} /* namespace IO */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.IO/Path.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace IO
+{
+    class LIBIL2CPP_CODEGEN_API Path
+    {
+    public:
+        static Il2CppString* get_temp_path();
+    };
+} /* namespace IO */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection.Emit/AssemblyBuilder.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppString;
+struct mscorlib_System_Reflection_Emit_AssemblyBuilder;
+struct mscorlib_System_Reflection_Module;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+namespace Emit
+{
+    class LIBIL2CPP_CODEGEN_API AssemblyBuilder
+    {
+    public:
+        static void basic_init(mscorlib_System_Reflection_Emit_AssemblyBuilder*);
+        static mscorlib_System_Reflection_Module* InternalAddModule(mscorlib_System_Reflection_Emit_AssemblyBuilder * thisPtr, Il2CppString* fileName);
+        static void UpdateNativeCustomAttributes40(mscorlib_System_Reflection_Emit_AssemblyBuilder * thisPtr);
+    };
+} /* namespace Emit */
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection.Emit/CustomAttributeBuilder.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+namespace Emit
+{
+    class LIBIL2CPP_CODEGEN_API CustomAttributeBuilder
+    {
+    public:
+        static Il2CppArray* GetBlob(Il2CppAssembly* asmb, void* /* System.Reflection.ConstructorInfo */ con, Il2CppArray* constructorArgs, Il2CppArray* namedProperties, Il2CppArray* propertyValues, Il2CppArray* namedFields, Il2CppArray* fieldValues);
+    };
+} /* namespace Emit */
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection.Emit/DerivedType.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppReflectionType;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+namespace Emit
+{
+    class LIBIL2CPP_CODEGEN_API DerivedType
+    {
+    public:
+        static void create_unmanaged_type(Il2CppReflectionType* type);
+    };
+} /* namespace Emit */
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection.Emit/DynamicMethod.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppReflectionDynamicMethod;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+namespace Emit
+{
+    class LIBIL2CPP_CODEGEN_API DynamicMethod
+    {
+    public:
+        static void create_dynamic_method(Il2CppReflectionDynamicMethod*, Il2CppReflectionDynamicMethod*);
+        static void destroy_dynamic_method(Il2CppReflectionDynamicMethod*, Il2CppReflectionDynamicMethod*);
+    };
+} /* namespace Emit */
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection.Emit/EnumBuilder.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppReflectionType;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+namespace Emit
+{
+    class LIBIL2CPP_CODEGEN_API EnumBuilder
+    {
+    public:
+        static void setup_enum_type(Il2CppReflectionType *enumtype, Il2CppReflectionType* t);
+    };
+} /* namespace Emit */
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection.Emit/GenericTypeParameterBuilder.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppReflectionGenericParam;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+namespace Emit
+{
+    class LIBIL2CPP_CODEGEN_API GenericTypeParameterBuilder
+    {
+    public:
+        static void initialize(Il2CppReflectionGenericParam* genericParameter);
+    };
+} /* namespace Emit */
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection.Emit/MethodBuilder.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppArray;
+struct Il2CppReflectionMethod;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+namespace Emit
+{
+    class LIBIL2CPP_CODEGEN_API MethodBuilder
+    {
+    public:
+        static Il2CppReflectionMethod* MakeGenericMethod(Il2CppReflectionMethod*, Il2CppArray*);
+    };
+} /* namespace Emit */
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection.Emit/ModuleBuilder.h

@@ -0,0 +1,50 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppArray;
+struct Il2CppString;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionModuleBuilder;
+struct Il2CppReflectionTypeBuilder;
+struct Il2CppReflectionType;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+namespace Emit
+{
+    class LIBIL2CPP_CODEGEN_API ModuleBuilder
+    {
+    public:
+        static void RegisterToken(Il2CppReflectionModuleBuilder*, Il2CppObject*, int);
+        static void WriteToFile(Il2CppReflectionModuleBuilder*, intptr_t);
+        static void basic_init(Il2CppReflectionModuleBuilder*);
+        static void build_metadata(Il2CppReflectionModuleBuilder*);
+        static Il2CppReflectionType * create_modified_type(Il2CppReflectionTypeBuilder*, Il2CppString*);
+        static int32_t getToken(Il2CppReflectionModuleBuilder*, Il2CppObject*);
+        static int32_t getUSIndex(Il2CppReflectionModuleBuilder*, Il2CppString*);
+        static void set_wrappers_type(Il2CppReflectionModuleBuilder*, Il2CppReflectionType*);
+        static int32_t getMethodToken(Il2CppReflectionModuleBuilder*, Il2CppReflectionMethod*, Il2CppArray*);
+#if NET_4_0
+        static int32_t getMethodToken40(Il2CppObject* mb, Il2CppObject* method, Il2CppArray* opt_param_types);
+        static int32_t getToken40(Il2CppObject* mb, Il2CppObject* obj, bool create_open_instance);
+        static Il2CppObject* GetRegisteredToken(Il2CppObject* _this, int32_t token);
+#endif
+    };
+} /* namespace Emit */
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection.Emit/SignatureHelper.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppArray;
+struct Il2CppReflectionSigHelper;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+namespace Emit
+{
+    class LIBIL2CPP_CODEGEN_API SignatureHelper
+    {
+    public:
+        static Il2CppArray* get_signature_field(Il2CppReflectionSigHelper*);
+        static Il2CppArray* get_signature_local(Il2CppReflectionSigHelper*);
+    };
+} /* namespace Emit */
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection.Emit/SymbolType.h

@@ -0,0 +1,27 @@
+#if NET_4_0
+#pragma once
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+namespace Emit
+{
+    class LIBIL2CPP_CODEGEN_API SymbolType
+    {
+    public:
+        static void create_unmanaged_type(Il2CppObject* type);
+    };
+} // namespace Emit
+} // namespace Reflection
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection.Emit/TypeBuilder.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppReflectionEvent;
+struct Il2CppReflectionEventBuilder;
+struct Il2CppReflectionType;
+struct Il2CppReflectionTypeBuilder;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+namespace Emit
+{
+    class LIBIL2CPP_CODEGEN_API TypeBuilder
+    {
+    public:
+        static void create_generic_class(Il2CppReflectionTypeBuilder*);
+        static void create_internal_class(Il2CppReflectionTypeBuilder*);
+        static Il2CppReflectionType* create_runtime_class(Il2CppReflectionTypeBuilder*, Il2CppReflectionTypeBuilder*);
+        static bool get_IsGenericParameter(Il2CppReflectionTypeBuilder*);
+        static Il2CppReflectionEvent* get_event_info(Il2CppReflectionTypeBuilder*, Il2CppReflectionEventBuilder*);
+        static void setup_generic_class(Il2CppReflectionTypeBuilder*);
+        static void setup_internal_class(Il2CppReflectionTypeBuilder*, Il2CppReflectionTypeBuilder*);
+        static Il2CppReflectionType* create_runtime_class40(Il2CppReflectionTypeBuilder*);
+    };
+} /* namespace Emit */
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/Assembly.h

@@ -0,0 +1,70 @@
+#pragma once
+
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppString;
+struct Il2CppAssemblyName;
+struct Il2CppReflectionAssembly;
+struct mscorlib_System_Reflection_Assembly;
+struct mscorlib_System_Reflection_Module;
+struct mscorlib_System_Security_Policy_Evidence;
+struct mscorlib_System_Reflection_AssemblyName;
+struct Il2CppMonoAssemblyName;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API Assembly
+    {
+    public:
+        static Il2CppReflectionAssembly* GetExecutingAssembly();
+        static Il2CppReflectionAssembly* GetEntryAssembly();
+        static Il2CppReflectionAssembly* GetCallingAssembly();
+        static void FillName(Il2CppReflectionAssembly* ass, mscorlib_System_Reflection_AssemblyName* aname);
+        static Il2CppObject* GetFilesInternal(Il2CppAssembly* self, Il2CppString* name, bool getResourceModules);
+        static Il2CppReflectionModule* GetManifestModuleInternal(Il2CppAssembly* self);
+        static bool GetManifestResourceInfoInternal(Il2CppReflectionAssembly* assembly, Il2CppString* name, Il2CppManifestResourceInfo* info);
+        static intptr_t GetManifestResourceInternal(Il2CppReflectionAssembly* assembly, Il2CppString* name, int* size, Il2CppReflectionModule** module);
+        static Il2CppArray* GetManifestResourceNames(Il2CppReflectionAssembly* assembly);
+        static Il2CppArray* GetModulesInternal(Il2CppReflectionAssembly* thisPtr);
+        static Il2CppArray* GetNamespaces(Il2CppAssembly* self);
+        static Il2CppArray* GetReferencedAssemblies(Il2CppReflectionAssembly* self);
+        static void InternalGetAssemblyName(Il2CppString* assemblyFile, Il2CppAssemblyName* aname);
+#if NET_4_0
+        static void InternalGetAssemblyName40(Il2CppString* assemblyFile, Il2CppMonoAssemblyName* aname, Il2CppString** codebase);
+#endif
+        static Il2CppReflectionType* InternalGetType(Il2CppReflectionAssembly* , mscorlib_System_Reflection_Module* , Il2CppString* , bool, bool);
+        static Il2CppString* InternalImageRuntimeVersion(Il2CppAssembly* self);
+        static Il2CppReflectionAssembly* LoadFrom(Il2CppString* assemblyFile, bool refonly);
+        static bool LoadPermissions(mscorlib_System_Reflection_Assembly* a, intptr_t* minimum, int32_t* minLength, intptr_t* optional, int32_t* optLength, intptr_t* refused, int32_t* refLength);
+        static int32_t MonoDebugger_GetMethodToken(void* /* System.Reflection.MethodBase */ method);
+        static Il2CppReflectionMethod* get_EntryPoint(Il2CppReflectionAssembly* self);
+        static bool get_ReflectionOnly(Il2CppAssembly* self);
+        static Il2CppString* get_code_base(Il2CppReflectionAssembly* assembly, bool escaped);
+        static Il2CppString* get_fullname(Il2CppReflectionAssembly *ass);
+        static bool get_global_assembly_cache(Il2CppAssembly* self);
+        static Il2CppString* get_location(Il2CppReflectionAssembly *assembly);
+        static Il2CppReflectionAssembly* load_with_partial_name(Il2CppString* name, mscorlib_System_Security_Policy_Evidence* evidence);
+        static Il2CppArray* GetTypes(Il2CppReflectionAssembly* thisPtr, bool exportedOnly);
+
+#if NET_4_0
+        static Il2CppString* GetAotId();
+#endif
+
+#if NET_4_0
+        static intptr_t InternalGetReferencedAssemblies(Il2CppReflectionAssembly* module);
+#endif
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/AssemblyName.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppString;
+struct Il2CppReflectionAssemblyName;
+struct Il2CppMonoAssemblyName;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API AssemblyName
+    {
+    public:
+        static bool ParseName(Il2CppReflectionAssemblyName* aname, Il2CppString* assemblyName);
+#if NET_4_0
+        static void get_public_token(uint8_t* token, uint8_t* pubkey, int32_t len);
+        static Il2CppMonoAssemblyName* GetNativeName(intptr_t assembly_ptr);
+        static bool ParseAssemblyName(intptr_t name, Il2CppMonoAssemblyName* aname, bool* is_version_defined, bool* is_token_defined);
+#endif
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/CustomAttributeData.h

@@ -0,0 +1,26 @@
+#if NET_4_0
+#pragma once
+
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API CustomAttributeData
+    {
+    public:
+        static void ResolveArgumentsInternal(Il2CppObject* ctor, Il2CppObject* assembly, intptr_t data, uint32_t data_length, Il2CppArray** ctorArgs, Il2CppArray** namedArgs);
+    };
+} // namespace Reflection
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/EventInfo.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#if NET_4_0
+
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API EventInfo
+    {
+    public:
+        static Il2CppReflectionEvent* internal_from_handle_type(intptr_t event_handle, intptr_t type_handle);
+    };
+} // namespace Reflection
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/FieldInfo.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "il2cpp-object-internals.h"
+#include "il2cpp-config.h"
+
+struct Il2CppReflectionField;
+struct Il2CppReflectionMarshal;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API FieldInfo
+    {
+    public:
+        static Il2CppReflectionMarshal* GetUnmanagedMarshal(Il2CppReflectionField* field);
+        static Il2CppReflectionField* internal_from_handle_type(intptr_t field_handle, intptr_t type_handle);
+        static Il2CppArray* GetTypeModifiers(Il2CppReflectionField* field, bool optional);
+#if NET_4_0
+        static Il2CppObject* get_marshal_info(Il2CppObject* _this);
+#endif
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/MemberInfo.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API MemberInfo
+    {
+    public:
+        static int32_t get_MetadataToken(Il2CppObject* /* System.Reflection.MemberInfo */ self);
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/MethodBase.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API MethodBase
+    {
+    public:
+        static Il2CppReflectionMethod* GetCurrentMethod();
+        static void* /* System.Reflection.MethodBody */ GetMethodBodyInternal(intptr_t handle);
+        static Il2CppReflectionMethod* GetMethodFromHandleInternalType(intptr_t method, intptr_t type);
+
+#if NET_4_0
+        static Il2CppReflectionMethod* GetMethodFromHandleInternalType_native(intptr_t method_handle, intptr_t type_handle, bool genericCheck);
+#endif
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/Module.h

@@ -0,0 +1,45 @@
+#pragma once
+
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppArray;
+struct Il2CppString;
+struct mscorlib_System_Reflection_Module;
+
+typedef int32_t PortableExecutableKinds;
+typedef int32_t ImageFileMachine;
+typedef int32_t ResolveTokenError;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API Module
+    {
+    public:
+        static Il2CppReflectionType* GetGlobalType(Il2CppReflectionModule* self);
+        static Il2CppString* GetGuidInternal(mscorlib_System_Reflection_Module * thisPtr);
+        static int32_t GetMDStreamVersion(intptr_t module_handle);
+        static void GetPEKind(intptr_t module, PortableExecutableKinds* peKind, ImageFileMachine* machine);
+        static Il2CppArray* InternalGetTypes(Il2CppReflectionModule * self);
+        static intptr_t ResolveFieldToken(intptr_t module, int32_t token, Il2CppArray* type_args, Il2CppArray* method_args, ResolveTokenError* error);
+        static void* /* System.Reflection.MemberInfo */ ResolveMemberToken(intptr_t module, int32_t token, Il2CppArray* type_args, Il2CppArray* method_args, ResolveTokenError* error);
+        static intptr_t ResolveMethodToken(intptr_t module, int32_t token, Il2CppArray* type_args, Il2CppArray* method_args, ResolveTokenError* error);
+        static Il2CppArray* ResolveSignature(intptr_t module, int32_t metadataToken, ResolveTokenError* error);
+        static Il2CppString* ResolveStringToken(intptr_t module, int32_t token, ResolveTokenError* error);
+        static intptr_t ResolveTypeToken(intptr_t module, int32_t token, Il2CppArray* type_args, Il2CppArray* method_args, ResolveTokenError* error);
+        static int32_t get_MetadataToken(Il2CppReflectionModule* self);
+        static intptr_t GetHINSTANCE(mscorlib_System_Reflection_Module * thisPtr);
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/MonoCMethod.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API MonoCMethod
+    {
+    public:
+        static Il2CppObject* InternalInvoke(void* /* System.Reflection.MonoCMethod */ self, Il2CppObject* obj, Il2CppArray* parameters, Il2CppException** exc);
+#if NET_4_0
+        static int32_t get_core_clr_security_level(Il2CppObject* _this);
+#endif
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/MonoEventInfo.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppReflectionMonoEvent;
+struct Il2CppReflectionMonoEventInfo;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API MonoEventInfo
+    {
+    public:
+        static void get_event_info(Il2CppReflectionMonoEvent* event, Il2CppReflectionMonoEventInfo* eventInfo);
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/MonoField.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct mscorlib_System_Reflection_FieldInfo;
+struct mscorlib_System_Reflection_Emit_UnmanagedMarshal;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API MonoField
+    {
+    public:
+        static int32_t GetFieldOffset(Il2CppReflectionField * thisPtr);
+        static Il2CppReflectionType * GetParentType(Il2CppReflectionField * field, bool declaring);
+        static Il2CppObject* GetRawConstantValue(Il2CppReflectionField* field);
+        static Il2CppObject * GetValueInternal(Il2CppReflectionField * thisPtr, Il2CppObject * obj);
+        static void SetValueInternal(Il2CppReflectionField * fi, Il2CppObject * obj, Il2CppObject * value);
+
+#if NET_4_0
+        static int32_t get_core_clr_security_level(Il2CppObject* _this);
+        static Il2CppObject* ResolveType(Il2CppObject* _this);
+#endif
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/MonoGenericCMethod.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API MonoGenericCMethod
+    {
+    public:
+        static Il2CppReflectionType* get_ReflectedType(void* /* System.Reflection.MonoGenericCMethod */ self);
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/MonoGenericClass.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppArray;
+struct mscorlib_System_Reflection_MonoGenericClass;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API MonoGenericClass
+    {
+    public:
+        static void initialize(mscorlib_System_Reflection_MonoGenericClass * thisPtr, Il2CppArray* methods, Il2CppArray* ctors, Il2CppArray* fields, Il2CppArray* properties, Il2CppArray* events);
+#if NET_4_0
+        static void initialize40(Il2CppObject* _this, Il2CppArray* fields);
+        static void register_with_runtime(Il2CppObject* type);
+#endif
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/MonoGenericMethod.h

@@ -0,0 +1,38 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API MonoGenericMethod
+    {
+    public:
+        static Il2CppReflectionType* get_ReflectedType(void* /* System.Reflection.MonoGenericMethod */ self);
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/MonoMethod.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct mscorlib_System_Runtime_InteropServices_DllImportAttribute;
+struct mscorlib_System_Reflection_MethodInfo;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API MonoMethod
+    {
+    public:
+        static mscorlib_System_Runtime_InteropServices_DllImportAttribute * GetDllImportAttribute(intptr_t);
+        static Il2CppArray * GetGenericArguments(Il2CppReflectionMethod *);
+        static Il2CppReflectionMethod* GetGenericMethodDefinition_impl(Il2CppReflectionMethod* method);
+        static Il2CppObject * InternalInvoke(Il2CppReflectionMethod * method, Il2CppObject * thisPtr, Il2CppArray * params, Il2CppObject * * exc);
+        static bool get_IsGenericMethod(Il2CppReflectionMethod *);
+        static bool get_IsGenericMethodDefinition(Il2CppReflectionMethod *);
+        static Il2CppReflectionMethod* get_base_definition(Il2CppReflectionMethod *);
+        static Il2CppString *  get_name(Il2CppReflectionMethod * m);
+        static Il2CppReflectionMethod* MakeGenericMethod_impl(Il2CppReflectionMethod *, Il2CppArray *);
+
+#if NET_4_0
+        static int32_t get_core_clr_security_level(Il2CppObject* _this);
+        static Il2CppReflectionMethod* get_base_method(Il2CppReflectionMethod* method, bool definition);
+        static void GetPInvoke(Il2CppReflectionMethod* _this, int32_t* flags, Il2CppString** entryPoint, Il2CppString** dllName);
+#endif
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/MonoMethodInfo.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API MonoMethodInfo
+    {
+    public:
+        static void get_method_info(intptr_t methodPtr, Il2CppMethodInfo* info);
+        static void* /* System.Reflection.Emit.UnmanagedMarshal */ get_retval_marshal(intptr_t handle);
+        static Il2CppArray* get_parameter_info(intptr_t methodPtr, Il2CppReflectionMethod* member);
+
+#if NET_4_0
+        static int32_t get_method_attributes(intptr_t methodPtr);
+#endif
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/MonoPropertyInfo.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppReflectionProperty;
+struct Il2CppPropertyInfo;
+struct Il2CppArray;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    typedef enum
+    {
+        PInfo_Attributes = 1,
+        PInfo_GetMethod  = 1 << 1,
+        PInfo_SetMethod  = 1 << 2,
+        PInfo_ReflectedType = 1 << 3,
+        PInfo_DeclaringType = 1 << 4,
+        PInfo_Name = 1 << 5
+    } PInfo;
+
+    class LIBIL2CPP_CODEGEN_API MonoPropertyInfo
+    {
+    public:
+        static Il2CppArray* GetTypeModifiers(void* /* System.Reflection.MonoProperty */ prop, bool optional);
+        static void get_property_info(Il2CppReflectionProperty *property, Il2CppPropertyInfo *info, PInfo req_info);
+
+#if NET_4_0
+        static Il2CppObject* get_default_value(Il2CppReflectionProperty* prop);
+#endif
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/ParameterInfo.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API ParameterInfo
+    {
+    public:
+        static Il2CppArray* GetTypeModifiers(void* /* System.Reflection.ParameterInfo */ self, bool optional);
+        static int32_t GetMetadataToken(Il2CppReflectionParameter* self);
+    };
+} /* namespace Reflection */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/PropertyInfo.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#if NET_4_0
+
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API PropertyInfo
+    {
+    public:
+        static Il2CppReflectionProperty* internal_from_handle_type(intptr_t event_handle, intptr_t type_handle);
+    };
+} // namespace Reflection
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Reflection/RtFieldInfo.h

@@ -0,0 +1,25 @@
+#pragma once
+#if NET_4_0
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Reflection
+{
+    class LIBIL2CPP_CODEGEN_API RtFieldInfo
+    {
+    public:
+        static Il2CppObject* UnsafeGetValue(Il2CppReflectionField* _this, Il2CppObject* obj);
+    };
+} // namespace Reflection
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.CompilerServices/RuntimeHelpers.h

@@ -0,0 +1,36 @@
+#pragma once
+
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Runtime
+{
+namespace CompilerServices
+{
+    class LIBIL2CPP_CODEGEN_API RuntimeHelpers
+    {
+    public:
+        static Il2CppObject* GetObjectValue(Il2CppObject* obj);
+        static void RunClassConstructor(intptr_t type);
+        static void RunModuleConstructor(intptr_t module);
+        static int get_OffsetToStringData(void);
+        static void InitializeArray(Il2CppArray* arr, intptr_t ptr);
+
+#if NET_4_0
+        static bool SufficientExecutionStack();
+#endif
+    };
+} /* namespace CompilerServices */
+} /* namespace Runtime */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.InteropServices.WindowsRuntime/UnsafeNativeMethods.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#if NET_4_0
+
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Runtime
+{
+namespace InteropServices
+{
+namespace WindowsRuntime
+{
+    class LIBIL2CPP_CODEGEN_API UnsafeNativeMethods
+    {
+    public:
+        static bool RoOriginateLanguageException(int32_t error, Il2CppString* message, intptr_t languageException);
+        static Il2CppChar* WindowsGetStringRawBuffer(intptr_t hstring, uint32_t* length);
+        static int32_t WindowsCreateString(Il2CppString* sourceString, int32_t length, intptr_t* hstring);
+        static int32_t WindowsDeleteString(intptr_t hstring);
+        static Il2CppObject* GetRestrictedErrorInfo();
+        static void RoReportUnhandledError(Il2CppObject* error);
+    };
+} // namespace WindowsRuntime
+} // namespace InteropServices
+} // namespace Runtime
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.InteropServices/GCHandle.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Runtime
+{
+namespace InteropServices
+{
+    class LIBIL2CPP_CODEGEN_API GCHandle
+    {
+    public:
+        static bool CheckCurrentDomain(int32_t handle);
+        static void FreeHandle(int32_t handle);
+        static intptr_t GetAddrOfPinnedObject(int32_t handle);
+        static Il2CppObject * GetTarget(int32_t handle);
+        static int32_t GetTargetHandle(Il2CppObject * obj, int32_t handle, int32_t type);
+    };
+} /* namespace InteropServices */
+} /* namespace Runtime */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.InteropServices/Marshal.h

@@ -0,0 +1,99 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct mscorlib_System_Guid;
+struct mscorlib_System_Reflection_MemberInfo;
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Runtime
+{
+namespace InteropServices
+{
+    class LIBIL2CPP_CODEGEN_API Marshal
+    {
+    public:
+        static int32_t GetLastWin32Error();
+        static int32_t AddRefInternal(intptr_t pUnk);
+        static intptr_t AllocCoTaskMem(int32_t size);
+        static intptr_t AllocHGlobal(intptr_t size);
+        static void DestroyStructure(intptr_t ptr, Il2CppReflectionType* structureType);
+        static void FreeBSTR(intptr_t ptr);
+        static void FreeCoTaskMem(intptr_t ptr);
+        static void FreeHGlobal(intptr_t hglobal);
+        static intptr_t GetCCW(Il2CppObject* o, Il2CppReflectionType * T);
+        static int32_t GetComSlotForMethodInfoInternal(mscorlib_System_Reflection_MemberInfo * m);
+        static Il2CppDelegate* GetDelegateForFunctionPointerInternal(intptr_t ptr, Il2CppReflectionType* t);
+        static intptr_t GetFunctionPointerForDelegateInternal(Il2CppDelegate* d);
+        static intptr_t GetIDispatchForObjectInternal(Il2CppObject* o);
+        static intptr_t GetIUnknownForObjectInternal(Il2CppObject* o);
+        static Il2CppObject* GetObjectForCCW(intptr_t pUnk);
+        static bool IsComObject(Il2CppObject* o);
+        static intptr_t OffsetOf(Il2CppReflectionType* t, Il2CppString* fieldName);
+        static void Prelink(Il2CppReflectionMethod* m);
+        static void PrelinkAll(Il2CppReflectionType* c);
+        static Il2CppString* PtrToStringAnsi_mscorlib_System_String_mscorlib_System_IntPtr(intptr_t ptr);
+        static Il2CppString* PtrToStringAnsi_mscorlib_System_String_mscorlib_System_IntPtr_mscorlib_System_Int32(intptr_t ptr, int32_t len);
+        static Il2CppString* PtrToStringBSTR(intptr_t ptr);
+        static Il2CppString* PtrToStringUni_mscorlib_System_String_mscorlib_System_IntPtr(intptr_t ptr);
+        static Il2CppString* PtrToStringUni_mscorlib_System_String_mscorlib_System_IntPtr_mscorlib_System_Int32(intptr_t ptr, int32_t len);
+        static Il2CppObject* PtrToStructure(intptr_t ptr, Il2CppReflectionType * structureType);
+        static void PtrToStructureObject(intptr_t ptr, Il2CppObject* structure);
+        static int32_t QueryInterfaceInternal(intptr_t pUnk, mscorlib_System_Guid * iid, intptr_t* ppv);
+        static intptr_t ReAllocCoTaskMem(intptr_t ptr, int32_t size);
+        static intptr_t ReAllocHGlobal(intptr_t ptr, intptr_t size);
+        static uint8_t ReadByte(intptr_t ptr, int32_t ofs);
+        static int16_t ReadInt16(intptr_t ptr, int32_t ofs);
+        static int32_t ReadInt32(intptr_t ptr, int32_t ofs);
+        static int64_t ReadInt64(intptr_t ptr, int32_t ofs);
+        static intptr_t ReadIntPtr(intptr_t ptr, int32_t ofs);
+        static int32_t ReleaseComObjectInternal(Il2CppObject* co);
+        static int32_t ReleaseInternal(intptr_t pUnk);
+        static int SizeOf(Il2CppReflectionType * rtype);
+        static intptr_t StringToBSTR(Il2CppString* s);
+        static intptr_t StringToHGlobalAnsi(Il2CppString* s);
+        static intptr_t StringToHGlobalUni(Il2CppString* s);
+        static void StructureToPtr(Il2CppObject* structure, intptr_t ptr, bool deleteOld);
+        static intptr_t UnsafeAddrOfPinnedArrayElement(Il2CppArray* arr, int32_t index);
+        static void WriteByte(intptr_t ptr, int32_t ofs, uint8_t val);
+        static void WriteInt16(intptr_t ptr, int32_t ofs, int16_t val);
+        static void WriteInt32(intptr_t ptr, int32_t ofs, int32_t val);
+        static void WriteInt64(intptr_t ptr, int32_t ofs, int64_t val);
+        static void copy_from_unmanaged(intptr_t, int, Il2CppArray *, int);
+        static void copy_to_unmanaged(Il2CppArray * source, int32_t startIndex, intptr_t destination, int32_t length);
+        static void WriteIntPtr(intptr_t ptr, int32_t ofs, intptr_t val);
+
+#if NET_4_0
+        static intptr_t BufferToBSTR(Il2CppArray* ptr, int32_t slen);
+#endif
+
+#if NET_4_0
+        static int32_t GetHRForException_WinRT(Il2CppException* e);
+        static intptr_t GetRawIUnknownForComObjectNoAddRef(Il2CppObject* o);
+        static Il2CppObject* GetNativeActivationFactory(Il2CppObject* type);
+#endif
+
+#if NET_4_0
+        static intptr_t AllocCoTaskMemSize(intptr_t sizet);
+#endif
+    };
+} /* namespace InteropServices */
+} /* namespace Runtime */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.Remoting.Activation/ActivationServices.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppObject;
+struct Il2CppReflectionType;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Runtime
+{
+namespace Remoting
+{
+namespace Activation
+{
+    class LIBIL2CPP_CODEGEN_API ActivationServices
+    {
+    public:
+        static void EnableProxyActivation(Il2CppReflectionType*, bool);
+        static Il2CppObject * AllocateUninitializedClassInstance(Il2CppReflectionType*);
+    };
+} /* namespace Activation */
+} /* namespace Remoting */
+} /* namespace Runtime */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.Remoting.Contexts/Context.h

@@ -0,0 +1,31 @@
+#pragma once
+#if NET_4_0
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Runtime
+{
+namespace Remoting
+{
+namespace Contexts
+{
+    class LIBIL2CPP_CODEGEN_API Context
+    {
+    public:
+        static void RegisterContext(Il2CppObject* ctx);
+        static void ReleaseContext(Il2CppObject* ctx);
+    };
+} // namespace Contexts
+} // namespace Remoting
+} // namespace Runtime
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.Remoting.Messaging/AsyncResult.h

@@ -0,0 +1,30 @@
+#pragma once
+#if NET_4_0
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Runtime
+{
+namespace Remoting
+{
+namespace Messaging
+{
+    class LIBIL2CPP_CODEGEN_API AsyncResult
+    {
+    public:
+        static Il2CppObject* Invoke(Il2CppObject* _this);
+    };
+} // namespace Messaging
+} // namespace Remoting
+} // namespace Runtime
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.Remoting.Messaging/MonoMethodMessage.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppArray;
+struct Il2CppMethodMessage;
+struct Il2CppReflectionMethod;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Runtime
+{
+namespace Remoting
+{
+namespace Messaging
+{
+    class LIBIL2CPP_CODEGEN_API MonoMethodMessage
+    {
+    public:
+        static void InitMessage(Il2CppMethodMessage*, Il2CppReflectionMethod*, Il2CppArray*);
+    };
+} /* namespace Messaging */
+} /* namespace Remoting */
+} /* namespace Runtime */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.Remoting.Proxies/RealProxy.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppObject;
+struct Il2CppReflectionType;
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Runtime
+{
+namespace Remoting
+{
+namespace Proxies
+{
+    class LIBIL2CPP_CODEGEN_API RealProxy
+    {
+    public:
+        static Il2CppObject* InternalGetTransparentProxy(Il2CppObject*, Il2CppString*);
+        static Il2CppReflectionType* InternalGetProxyType(Il2CppObject*);
+    };
+} /* namespace Proxies */
+} /* namespace Remoting */
+} /* namespace Runtime */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.Remoting/RemotingServices.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppArray;
+struct Il2CppObject;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionType;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Runtime
+{
+namespace Remoting
+{
+    class LIBIL2CPP_CODEGEN_API RemotingServices
+    {
+    public:
+        static Il2CppReflectionMethod * GetVirtualMethod(Il2CppReflectionType*, Il2CppReflectionMethod*);
+        static Il2CppObject* InternalExecute(Il2CppReflectionMethod*, Il2CppObject*, Il2CppArray*, Il2CppArray**);
+        static bool IsTransparentProxy(Il2CppObject*);
+    };
+} /* namespace Remoting */
+} /* namespace Runtime */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Runtime.Versioning/VersioningHelper.h

@@ -0,0 +1,27 @@
+#pragma once
+#if NET_4_0
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Runtime
+{
+namespace Versioning
+{
+    class LIBIL2CPP_CODEGEN_API VersioningHelper
+    {
+    public:
+        static int32_t GetRuntimeId();
+    };
+} // namespace Versioning
+} // namespace Runtime
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Security.Cryptography/RNGCryptoServiceProvider.h

@@ -0,0 +1,31 @@
+#pragma once
+
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Security
+{
+namespace Cryptography
+{
+    class LIBIL2CPP_CODEGEN_API RNGCryptoServiceProvider
+    {
+    public:
+        static void RngClose(intptr_t handle);
+        static intptr_t RngGetBytes(intptr_t, Il2CppArray *);
+        static intptr_t RngInitialize(Il2CppArray *);
+        static bool RngOpen();
+    };
+} /* namespace Cryptography */
+} /* namespace Security */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Security.Policy/Evidence.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Security
+{
+namespace Policy
+{
+    class LIBIL2CPP_CODEGEN_API Evidence
+    {
+    public:
+        static bool IsAuthenticodePresent(Il2CppAssembly* a);
+    };
+} /* namespace Policy */
+} /* namespace Security */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Security.Principal/WindowsIdentity.h

@@ -0,0 +1,33 @@
+#pragma once
+
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Security
+{
+namespace Principal
+{
+    class LIBIL2CPP_CODEGEN_API WindowsIdentity
+    {
+    public:
+        static intptr_t GetUserToken(Il2CppString* username);
+        static Il2CppArray* _GetRoles(intptr_t token);
+        static Il2CppString* GetTokenName(intptr_t token);
+        static intptr_t GetCurrentToken();
+    };
+} /* namespace Principal */
+} /* namespace Security */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Security.Principal/WindowsImpersonationContext.h

@@ -0,0 +1,44 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Security
+{
+namespace Principal
+{
+    class LIBIL2CPP_CODEGEN_API WindowsImpersonationContext
+    {
+    public:
+        static bool RevertToSelf();
+        static intptr_t DuplicateToken(intptr_t token);
+        static bool SetCurrentToken(intptr_t token);
+        static bool CloseToken(intptr_t token);
+    };
+} /* namespace Principal */
+} /* namespace Security */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Security.Principal/WindowsPrincipal.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Security
+{
+namespace Principal
+{
+    class LIBIL2CPP_CODEGEN_API WindowsPrincipal
+    {
+    public:
+        static bool IsMemberOfGroupName(intptr_t user, Il2CppString* group);
+        static bool IsMemberOfGroupId(intptr_t user, intptr_t group);
+    };
+} /* namespace Principal */
+} /* namespace Security */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Security/SecurityFrame.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+struct Il2CppArray;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Security
+{
+    class LIBIL2CPP_CODEGEN_API SecurityFrame
+    {
+    public:
+        static void* /* System.Security.RuntimeSecurityFrame */ _GetSecurityFrame(int32_t skip);
+        static Il2CppArray * _GetSecurityStack(int32_t skip);
+    };
+} /* namespace Security */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Security/SecurityManager.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct mscorlib_System_Reflection_MethodBase;
+struct mscorlib_System_Security_RuntimeDeclSecurityActions;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Security
+{
+    class LIBIL2CPP_CODEGEN_API SecurityManager
+    {
+    public:
+        static bool get_CheckExecutionRights();
+        static void set_CheckExecutionRights(bool value);
+        static void set_SecurityEnabled(bool value);
+        static bool GetLinkDemandSecurity(mscorlib_System_Reflection_MethodBase * method, mscorlib_System_Security_RuntimeDeclSecurityActions * _____cdecl, mscorlib_System_Security_RuntimeDeclSecurityActions * mdecl);
+        static bool get_SecurityEnabled();
+    };
+} /* namespace Security */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Text/Encoding.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include "il2cpp-config.h"
+#include <stdint.h>
+
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Text
+{
+    class LIBIL2CPP_CODEGEN_API Encoding
+    {
+    public:
+        static Il2CppString* InternalCodePage(int32_t *codePage);
+    };
+} /* namespace Text */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Text/EncodingHelper.h

@@ -0,0 +1,24 @@
+#pragma once
+#if NET_4_0
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Text
+{
+    class LIBIL2CPP_CODEGEN_API EncodingHelper
+    {
+    public:
+        static Il2CppString* InternalCodePage(int32_t* code_page);
+    };
+} // namespace Text
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Text/Normalization.h

@@ -0,0 +1,25 @@
+#pragma once
+#if NET_4_0
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Text
+{
+    class LIBIL2CPP_CODEGEN_API Normalization
+    {
+    public:
+        static void load_normalization_resource(intptr_t* props, intptr_t* mappedChars, intptr_t* charMapIndex, intptr_t* helperIndex, intptr_t* mapIdxToComposite, intptr_t* combiningClass);
+    };
+} // namespace Text
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/Interlocked.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Threading
+{
+    class LIBIL2CPP_CODEGEN_API Interlocked
+    {
+    public:
+        static int32_t Add(int32_t* location1, int32_t value);
+        static int64_t Add64(int64_t* location1, int64_t value);
+        static int32_t CompareExchange(int32_t* location, int32_t value, int32_t comparand);
+        static int64_t CompareExchange64(int64_t* location1, int64_t value, int64_t comparand);
+        static double CompareExchangeDouble(double* location1, double value, double comparand);
+        static intptr_t CompareExchangeIntPtr(intptr_t* location, intptr_t value, intptr_t comparand);
+        static float CompareExchangeSingle(float* location1, float value, float comparand);
+        static void* CompareExchange_T(void** location, void* value, void* comparand);
+        static int32_t Decrement(int32_t* location);
+        static int64_t Decrement64(int64_t* location);
+        static intptr_t ExchangeIntPtr(intptr_t* location, intptr_t value);
+        static int32_t Exchange(int32_t* location1, int32_t value);
+        static int64_t Exchange64(int64_t* location1, int64_t value);
+        static double ExchangeDouble(double* location1, double value);
+        static void* ExchangePointer(void** location1, void* value);
+        static float ExchangeSingle(float* location1, float value);
+        static int32_t Increment(int32_t* value);
+        static int64_t Increment64(int64_t* location);
+        static int64_t Read(int64_t* location);
+#if NET_4_0
+        static int32_t CompareExchange(int32_t* location1, int32_t value, int32_t comparand, bool* succeeded);
+#endif
+    };
+} /* namespace Threading */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/InternalThread.h

@@ -0,0 +1,27 @@
+#pragma once
+#if NET_4_0
+#include "il2cpp-object-internals.h"
+
+struct Il2CppInternalThread;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Threading
+{
+    class LIBIL2CPP_CODEGEN_API InternalThread
+    {
+    public:
+        static void Thread_free_internal(Il2CppInternalThread* _this);
+    };
+} // namespace Threading
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/Monitor.h

@@ -0,0 +1,37 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+struct Il2CppObject;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Threading
+{
+    class LIBIL2CPP_CODEGEN_API Monitor
+    {
+    public:
+        static void Enter(Il2CppObject *);
+        static void Exit(Il2CppObject *);
+        static void Monitor_pulse(Il2CppObject* obj);
+        static void Monitor_pulse_all(Il2CppObject* obj);
+        static bool Monitor_test_synchronised(Il2CppObject* obj);
+        static bool Monitor_try_enter(Il2CppObject* obj, int32_t ms);
+        static bool Monitor_wait(Il2CppObject* obj, int32_t ms);
+#if NET_4_0
+        static bool Monitor_test_owner(Il2CppObject* obj);
+        static void enter_with_atomic_var(Il2CppObject* obj, bool* lockTaken);
+        static void try_enter_with_atomic_var(Il2CppObject* obj, int32_t millisecondsTimeout, bool* lockTaken);
+#endif
+    };
+} /* namespace Threading */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/Mutex.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-object-internals.h"
+#include "il2cpp-config.h"
+
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Threading
+{
+    struct MonoIOError;
+
+    typedef int32_t MutexRights;
+
+    class LIBIL2CPP_CODEGEN_API Mutex
+    {
+    public:
+        static intptr_t CreateMutex_internal(bool initiallyOwned, Il2CppString* name, bool* created);
+        static intptr_t OpenMutex_internal(Il2CppString* name, MutexRights rights, MonoIOError* error);
+        static bool ReleaseMutex_internal(intptr_t handle);
+    };
+} /* namespace Threading */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/NativeEventCalls.h

@@ -0,0 +1,43 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-object-internals.h"
+#include "il2cpp-config.h"
+
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Threading
+{
+    struct MonoIOError;
+
+    typedef int32_t EventWaitHandleRights;
+
+    class LIBIL2CPP_CODEGEN_API NativeEventCalls
+    {
+    public:
+
+#if !NET_4_0
+        static intptr_t CreateEvent_internal(bool manualReset, bool signaled, Il2CppString* name, bool* created);
+        static intptr_t OpenEvent_internal(Il2CppString* name, EventWaitHandleRights rights, MonoIOError* error);
+#else
+        static intptr_t CreateEvent_internal(bool manual, bool initial, Il2CppString* name, int32_t* errorCode);
+        static intptr_t OpenEvent_internal(Il2CppString* name, EventWaitHandleRights rights, int32_t* errorCode);
+#endif
+
+        static bool ResetEvent_internal(intptr_t handlePtr);
+        static bool SetEvent_internal(intptr_t handlePtr);
+        static void CloseEvent_internal(intptr_t handlePtr);
+    };
+} /* namespace Threading */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/Thread.h

@@ -0,0 +1,112 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-object-internals.h"
+#include "vm/Thread.h"
+#include "il2cpp-config.h"
+
+struct Il2CppString;
+struct Il2CppThread;
+struct mscorlib_System_Globalization_CultureInfo;
+struct Il2CppDelegate;
+struct mscorlib_System_Threading_Thread;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Threading
+{
+    class LIBIL2CPP_CODEGEN_API Thread
+    {
+    public:
+        static int32_t GetDomainID();
+        static Il2CppThread * CurrentThread_internal();
+        static void ResetAbort_internal();
+        static void MemoryBarrier_();
+        static void SpinWait_nop();
+        static void Abort_internal(Il2CppThread* thisPtr, Il2CppObject* stateInfo);
+        static void ClrState(Il2CppThread* thisPtr, il2cpp::vm::ThreadState clr);
+        static void FreeLocalSlotValues(int32_t slot, bool use_thread_local);
+        static Il2CppObject* GetAbortExceptionState(void* /* System.Threading.Thread */ self);
+        static mscorlib_System_Globalization_CultureInfo * GetCachedCurrentCulture(Il2CppThread* thisPtr);
+        static mscorlib_System_Globalization_CultureInfo* GetCachedCurrentUICulture(Il2CppThread* thisPtr);
+        static Il2CppString* GetName_internal(Il2CppThread* thisPtr);
+        static void SetName_internal(Il2CppThread* thisPtr, Il2CppString* name);
+        static int32_t GetNewManagedId_internal();
+#if !NET_4_0
+        static Il2CppArray * GetSerializedCurrentCulture(Il2CppThread* thisPtr);
+        static Il2CppArray* GetSerializedCurrentUICulture(Il2CppThread* thisPtr);
+#endif
+        static il2cpp::vm::ThreadState GetState(Il2CppThread * thisPtr);
+        static void Interrupt_internal(Il2CppThread* thisPtr);
+        static bool Join_internal(Il2CppThread * thisPtr, int32_t ms, void* thread);
+        static void Resume_internal(void* /* System.Threading.Thread */ self);
+        static void SetCachedCurrentCulture(Il2CppThread *thisPtr, Il2CppObject* culture);
+        static void SetCachedCurrentUICulture(Il2CppThread* thisPtr, Il2CppObject* culture);
+#if !NET_4_0
+        static void SetSerializedCurrentCulture(Il2CppThread* thisPtr, Il2CppArray* culture);
+        static void SetSerializedCurrentUICulture(Il2CppThread* thisPtr, Il2CppArray* culture);
+#endif
+        static void SetState(Il2CppThread * thisPtr, il2cpp::vm::ThreadState state);
+        static void Sleep_internal(int32_t milliseconds);
+        static void Suspend_internal(void* /* System.Threading.Thread */ self);
+        static void Thread_init(Il2CppThread* thisPtr);
+        static intptr_t Thread_internal(Il2CppThread* thisPtr, Il2CppDelegate * start);
+        static int8_t VolatileReadInt8(volatile void* address);
+        static int16_t VolatileReadInt16(volatile void* address);
+        static int32_t VolatileReadInt32(volatile void* address);
+        static int64_t VolatileReadInt64(volatile void* address);
+        static float VolatileReadFloat(volatile void* address);
+        static double VolatileReadDouble(volatile void* address);
+        static void* VolatileReadPtr(volatile void* address);
+        static intptr_t VolatileReadIntPtr(volatile void* address);
+        static void VolatileWriteInt8(volatile void* address, int8_t value);
+        static void VolatileWriteInt16(volatile void* address, int16_t value);
+        static void VolatileWriteInt32(volatile void* address, int32_t value);
+        static void VolatileWriteInt64(volatile void* address, int64_t value);
+        static void VolatileWriteFloat(volatile void* address, float value);
+        static void VolatileWriteDouble(volatile void* address, double value);
+        static void VolatileWritePtr(volatile void* address, void* value);
+        static void VolatileWriteIntPtr(volatile void* address, intptr_t value);
+#if !NET_4_0
+        static void Thread_free_internal(Il2CppThread* thisPtr, intptr_t handle);
+#endif
+
+#if NET_4_0
+        static Il2CppArray* ByteArrayToCurrentDomain(Il2CppArray* arr);
+        static Il2CppArray* ByteArrayToRootDomain(Il2CppArray* arr);
+        static bool YieldInternal();
+        static bool JoinInternal(Il2CppThread* _this, int32_t millisecondsTimeout);
+        static int32_t GetPriorityNative(Il2CppThread* _this);
+        static int32_t SystemMaxStackStize();
+        static Il2CppString* GetName_internal40(Il2CppInternalThread* thread);
+        static Il2CppInternalThread* CurrentInternalThread_internal();
+        static int32_t GetState40(Il2CppInternalThread* thread);
+        static void Abort_internal40(Il2CppInternalThread* thread, Il2CppObject* stateInfo);
+        static void ClrState40(Il2CppInternalThread* thread, il2cpp::vm::ThreadState clr);
+        static void ConstructInternalThread(Il2CppThread* _this);
+        static void GetStackTraces(Il2CppArray** threads, Il2CppArray** stack_frames);
+        static void InterruptInternal(Il2CppThread* _this);
+        static void ResetAbortNative(Il2CppObject* _this);
+        static void ResumeInternal(Il2CppObject* _this);
+        static void SetName_internal40(Il2CppInternalThread* thread, Il2CppString* name);
+        static void SetPriorityNative(Il2CppThread* _this, int32_t priority);
+        static void SetState40(Il2CppInternalThread* thread, vm::ThreadState set);
+        static void SleepInternal(int32_t millisecondsTimeout);
+        static void SuspendInternal(Il2CppObject* _this);
+#endif
+
+#if NET_4_0
+        static Il2CppThread* GetCurrentThread();
+#endif
+    };
+} /* namespace Threading */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/ThreadPool.h

@@ -0,0 +1,46 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-object-internals.h"
+#include "il2cpp-config.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+#if NET_4_0
+struct Il2CppNativeOverlapped;
+#endif
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Threading
+{
+    class LIBIL2CPP_CODEGEN_API ThreadPool
+    {
+    public:
+        static void GetAvailableThreads(int32_t* workerThreads, int32_t* completionPortThreads);
+        static void GetMinThreads(int32_t* workerThreads, int32_t* completionPortThreads);
+        static bool SetMaxThreads(int32_t workerThreads, int32_t completionPortThreads);
+        static bool SetMinThreads(int32_t workerThreads, int32_t completionPortThreads);
+        static void GetMaxThreads(int32_t* workerThreads, int32_t* completionPortThreads);
+    };
+} /* namespace Threading */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/Timer.h

@@ -0,0 +1,24 @@
+#pragma once
+#if NET_4_0
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Threading
+{
+    class LIBIL2CPP_CODEGEN_API Timer
+    {
+    public:
+        static int64_t GetTimeMonotonic();
+    };
+} // namespace Threading
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System.Threading/WaitHandle.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-object-internals.h"
+#include "il2cpp-config.h"
+
+struct Il2CppArray;
+struct Il2CppObject;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+namespace Threading
+{
+    class LIBIL2CPP_CODEGEN_API WaitHandle
+    {
+    public:
+        static bool SignalAndWait_Internal(intptr_t toSignal, intptr_t toWaitOn, int32_t ms, bool exitContext);
+        static bool WaitAll_internal(Il2CppArray* handles, int32_t ms, bool exitContext);
+        static int32_t WaitAny_internal(Il2CppArray* handles, int32_t ms, bool exitContext);
+        static bool WaitOne_internal(Il2CppObject* unused, intptr_t handlePtr, int32_t ms, bool exitContext);
+#if NET_4_0
+        static int32_t SignalAndWait_Internal40(intptr_t toSignal, intptr_t toWaitOn, int32_t ms);
+        static int32_t Wait_internal(void* *handles, int32_t numhandles, bool waitall, int32_t timeout);
+#endif
+
+    private:
+        static const int m_waitIntervalMs = 10;
+    };
+} /* namespace Threading */
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Activator.h

@@ -0,0 +1,24 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+struct Il2CppObject;
+struct Il2CppReflectionType;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Activator
+    {
+    public:
+        static Il2CppObject* CreateInstanceInternal(Il2CppReflectionType *type);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/AppDomain.h

@@ -0,0 +1,61 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct mscorlib_System_AppDomain;
+struct mscorlib_System_AppDomainSetup;
+struct mscorlib_System_Runtime_Remoting_Contexts_Context;
+struct mscorlib_System_Security_Policy_Evidence;
+struct mscorlib_System_Reflection_Assembly;
+
+struct Il2CppObject;
+struct Il2CppString;
+struct Il2CppArray;
+struct Il2CppAssembly;
+struct Il2CppAppDomain;
+struct Il2CppAppDomainSetup;
+struct Il2CppReflectionAssembly;
+struct Il2CppAppContext;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API AppDomain
+    {
+    public:
+        static void InternalPopDomainRef();
+        static Il2CppAppDomain* getCurDomain();
+        static Il2CppAppDomain* getRootDomain();
+        static int32_t ExecuteAssembly(Il2CppAppDomain* self, Il2CppAssembly* a, Il2CppArray* args);
+        static Il2CppObject* GetData(Il2CppAppDomain* self, Il2CppString* name);
+        static Il2CppAppContext* InternalGetContext(void);
+        static Il2CppAppContext* InternalGetDefaultContext(void);
+        static Il2CppString* InternalGetProcessGuid(Il2CppString* newguid);
+        static bool InternalIsFinalizingForUnload(int32_t domain_id);
+        static void InternalPushDomainRef(mscorlib_System_AppDomain * domain);
+        static void InternalPushDomainRefByID(int32_t domain_id);
+        static mscorlib_System_Runtime_Remoting_Contexts_Context * InternalSetContext(mscorlib_System_Runtime_Remoting_Contexts_Context * context);
+        static mscorlib_System_AppDomain * InternalSetDomain(mscorlib_System_AppDomain * context);
+        static mscorlib_System_AppDomain * InternalSetDomainByID(int32_t domain_id);
+        static void InternalUnload(int32_t domain_id);
+        static Il2CppReflectionAssembly* LoadAssembly(Il2CppAppDomain* ad, Il2CppString* assemblyRef, struct mscorlib_System_Security_Policy_Evidence* evidence, bool refOnly);
+        static Il2CppAssembly* LoadAssemblyRaw(Il2CppAppDomain* self, Il2CppArray* rawAssembly, Il2CppArray* rawSymbolStore, void* /* System.Security.Policy.Evidence */ securityEvidence, bool refonly);
+        static void SetData(Il2CppAppDomain* self, Il2CppString* name, Il2CppObject* data);
+        static Il2CppAppDomain* createDomain(Il2CppString*, mscorlib_System_AppDomainSetup*);
+        static Il2CppString * getFriendlyName(Il2CppAppDomain* ad);
+        static Il2CppAppDomainSetup* getSetup(Il2CppAppDomain* domain);
+        static Il2CppArray* GetAssemblies(Il2CppAppDomain* ad, bool refonly);
+#if NET_4_0
+        static void DoUnhandledException(Il2CppObject* _this, Il2CppException* e);
+#endif
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/ArgIterator.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct mscorlib_System_ArgIterator;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API ArgIterator
+    {
+    public:
+        static void* /* System.TypedReference */ IntGetNextArg(ArgIterator self);
+        static Il2CppTypedRef IntGetNextArg_mscorlib_System_TypedReference(mscorlib_System_ArgIterator * thisPtr);
+        static Il2CppTypedRef IntGetNextArg_mscorlib_System_TypedReference_mscorlib_System_IntPtr(mscorlib_System_ArgIterator * thisPtr, intptr_t rth);
+        static void Setup(mscorlib_System_ArgIterator * thisPtr, intptr_t argsp, intptr_t start);
+        static intptr_t IntGetNextArgType(mscorlib_System_ArgIterator * thisPtr);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Array.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+struct Il2CppArray;
+struct Il2CppReflectionType;
+struct Il2CppObject;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Array
+    {
+    public:
+        static void ClearInternal(Il2CppArray* arr, int32_t idx, int32_t length);
+        static Il2CppArray* Clone(Il2CppArray* arr);
+        static Il2CppArray* CreateInstanceImpl(Il2CppReflectionType* elementType, Il2CppArray* lengths, Il2CppArray* bounds);
+        static bool FastCopy(Il2CppArray* source, int32_t source_idx, Il2CppArray* dest, int32_t dest_idx, int32_t length);
+        static int32_t GetLength(Il2CppArray* thisPtr, int dimension);
+        static int32_t GetLowerBound(Il2CppArray* , int32_t);
+        static Il2CppObject* GetValue(Il2CppArray* thisPtr, Il2CppArray* indices);
+        static Il2CppObject* GetValueImpl(Il2CppArray* thisPtr, int32_t pos);
+        static void SetValue(Il2CppArray* , Il2CppObject* , Il2CppArray*);
+        static void SetValueImpl(Il2CppArray* thisPtr, Il2CppObject* value, int index);
+        static int GetRank(Il2CppArray* array);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Buffer.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppArray;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Buffer
+    {
+    public:
+        static bool BlockCopyInternal(Il2CppArray * src, int src_offset, Il2CppArray * dest, int dest_offset, int count);
+        static int32_t ByteLengthInternal(Il2CppArray* arr);
+        static uint8_t GetByteInternal(Il2CppArray* arr, int idx);
+        static void SetByteInternal(Il2CppArray* arr, int idx, int value);
+#if NET_4_0
+        static uint8_t _GetByte(Il2CppArray* array, int32_t index);
+        static bool InternalBlockCopy(Il2CppArray* src, int32_t srcOffsetBytes, Il2CppArray* dst, int32_t dstOffsetBytes, int32_t byteCount);
+        static int32_t _ByteLength(Il2CppArray* array);
+        static void _SetByte(Il2CppArray* array, int32_t index, uint8_t value);
+#endif
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/CLRConfig.h

@@ -0,0 +1,21 @@
+#pragma once
+#if NET_4_0
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API CLRConfig
+    {
+    public:
+        static bool CheckThrowUnobservedTaskExceptions();
+    };
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Char.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Char
+    {
+    public:
+        static void GetDataTablePointers(
+            const unsigned char** category_data,
+            const unsigned char** numeric_data,
+            const double** numeric_data_values,
+            const Il2CppChar** to_lower_data_low,
+            const Il2CppChar** to_lower_data_high,
+            const Il2CppChar** to_upper_data_low,
+            const Il2CppChar** to_upper_data_high);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/ConsoleDriver.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API ConsoleDriver
+    {
+    public:
+        static int32_t InternalKeyAvailable(int32_t ms_timeout);
+        static bool SetBreak(bool wantBreak);
+        static bool SetEcho(bool wantEcho);
+        static bool TtySetup(Il2CppString* keypadXmit, Il2CppString* teardown, Il2CppArray** control_characters, int32_t** size);
+        static bool Isatty(intptr_t handle);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Convert.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppArray;
+struct Il2CppString;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Convert
+    {
+    public:
+        static Il2CppArray* InternalFromBase64CharArray(Il2CppArray* arr, int32_t offset, int32_t length);
+        static Il2CppArray* InternalFromBase64String(Il2CppString* str, bool allowWhitespaceOnly);
+        static Il2CppArray* Base64ToByteArray(Il2CppChar* start, int length, bool allowWhitespaceOnly);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/CurrentSystemTimeZone.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppArray;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API CurrentSystemTimeZone
+    {
+    public:
+#if NET_4_0
+        static bool GetTimeZoneData40(int year, Il2CppArray * *, Il2CppArray * *, bool * daylight_inverted);
+#else
+        static bool GetTimeZoneData(int, Il2CppArray * *, Il2CppArray * *);
+#endif
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/DateTime.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API DateTime
+    {
+    public:
+        static int64_t GetNow(void);
+        static int64_t GetTimeMonotonic();
+#if NET_4_0
+        static int64_t GetSystemTimeAsFileTime();
+#endif
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Decimal.h

@@ -0,0 +1,52 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppString;
+struct mscorlib_System_Decimal;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Decimal
+    {
+    public:
+#if !NET_4_0
+        static int32_t decimal2Int64(il2cpp_decimal_repr* val, int64_t* result);
+        static int32_t decimal2UInt64(il2cpp_decimal_repr* val, uint64_t* result);
+        static int32_t decimal2string(il2cpp_decimal_repr* val, int32_t digits, int32_t decimals, Il2CppArray* bufDigits, int32_t bufSize, int32_t* decPos, int32_t* sign);
+        static int decimalCompare(il2cpp_decimal_repr *pA, il2cpp_decimal_repr *pB);
+        static int32_t decimalDiv(il2cpp_decimal_repr* pC, il2cpp_decimal_repr* pA, il2cpp_decimal_repr* pB);
+        static void decimalFloorAndTrunc(il2cpp_decimal_repr * pA, int32_t floorFlag);
+        static int32_t decimalIncr(il2cpp_decimal_repr * d1, il2cpp_decimal_repr * d2);
+        static int32_t decimalIntDiv(il2cpp_decimal_repr* pc, il2cpp_decimal_repr* pa, il2cpp_decimal_repr* pb);
+        static int32_t decimalMult(il2cpp_decimal_repr* pA, il2cpp_decimal_repr* pB);
+        static int decimalSetExponent(il2cpp_decimal_repr*, int);
+        static int string2decimal(il2cpp_decimal_repr *pA, Il2CppString *str, unsigned int decrDecimal, int sign);
+        static double decimal2double(il2cpp_decimal_repr* val);
+#else
+        static double ToDouble(Il2CppDecimal d);
+        static int32_t FCallCompare(Il2CppDecimal* left, Il2CppDecimal* right);
+        static int32_t FCallToInt32(Il2CppDecimal d);
+        static int32_t GetHashCode(Il2CppDecimal* _this);
+        static float ToSingle(Il2CppDecimal d);
+        static void ConstructorDouble(Il2CppDecimal* _this, double value);
+        static void ConstructorFloat(Il2CppDecimal* _this, float value);
+        static void FCallAddSub(Il2CppDecimal* left, Il2CppDecimal* right, uint8_t sign);
+        static void FCallDivide(Il2CppDecimal* left, Il2CppDecimal* right);
+        static void FCallFloor(Il2CppDecimal* d);
+        static void FCallMultiply(Il2CppDecimal* d1, Il2CppDecimal* d2);
+        static void FCallRound(Il2CppDecimal* d, int32_t decimals);
+        static void FCallTruncate(Il2CppDecimal* d);
+#endif
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Delegate.h

@@ -0,0 +1,34 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppObject;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+
+struct Il2CppDelegate;
+struct Il2CppMulticastDelegate;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Delegate
+    {
+    public:
+        static Il2CppDelegate * CreateDelegate_internal(Il2CppReflectionType *, Il2CppObject *, Il2CppReflectionMethod *, bool);
+        static void SetMulticastInvoke(Il2CppDelegate *);
+#if NET_4_0
+        static Il2CppMulticastDelegate* AllocDelegateLike_internal(Il2CppDelegate* d);
+        static Il2CppObject* GetVirtualMethod_internal(Il2CppObject* _this);
+#endif
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Double.h

@@ -0,0 +1,22 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Double
+    {
+    public:
+        static bool ParseImpl(char *, double *);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Enum.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include "il2cpp-config.h"
+struct Il2CppObject;
+struct Il2CppReflectionType;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Enum
+    {
+    public:
+        static Il2CppObject* ToObject(Il2CppReflectionType* enumType, Il2CppObject* value);
+        static int compare_value_to(Il2CppObject* thisPtr, Il2CppObject* other);
+        static int32_t get_hashcode(Il2CppObject* thisPtr);
+        static Il2CppObject* get_value(Il2CppObject* thisPtr);
+        static Il2CppReflectionType* get_underlying_type(Il2CppReflectionType* type);
+
+#if NET_4_0
+        static bool GetEnumValuesAndNames(Il2CppReflectionRuntimeType* enumType, Il2CppArray** values, Il2CppArray** names);
+        static bool InternalHasFlag(Il2CppObject* thisPtr, Il2CppObject* flags);
+        static int32_t InternalCompareTo(Il2CppObject* o1, Il2CppObject* o2);
+        static Il2CppObject* InternalBoxEnum(Il2CppReflectionRuntimeType* enumType, int64_t value);
+        static Il2CppReflectionRuntimeType* InternalGetUnderlyingType(Il2CppReflectionRuntimeType* enumType);
+#endif
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Environment.h

@@ -0,0 +1,54 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppString;
+struct Il2CppArray;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Environment
+    {
+    public:
+        static Il2CppString* internalGetGacPath();
+        static int32_t get_ProcessorCount();
+        static bool get_SocketSecurityEnabled();
+        static void internalBroadcastSettingChange();
+        static Il2CppString* GetOSVersionString();
+        static Il2CppString* GetMachineConfigPath();
+        static Il2CppArray* GetLogicalDrivesInternal();
+        static Il2CppArray* GetEnvironmentVariableNames();
+        static Il2CppArray* GetCommandLineArgs();
+        static Il2CppString* internalGetHome();
+        static Il2CppString*  get_NewLine();
+        static Il2CppString* get_MachineName();
+        static int32_t get_ExitCode();
+        static bool get_HasShutdownStarted();
+        static Il2CppString* get_EmbeddingHostName();
+        static Il2CppString* get_UserName();
+        static int get_Platform();
+        static int32_t get_TickCount();
+        static void Exit(int32_t exitCode);
+        static Il2CppString* GetWindowsFolderPath(int32_t folder);
+        static Il2CppString* internalGetEnvironmentVariable(Il2CppString *);
+        static void set_ExitCode(int32_t value);
+        static void InternalSetEnvironmentVariable(Il2CppString* variable, Il2CppString* value);
+#if NET_4_0
+        static bool GetIs64BitOperatingSystem();
+        static int32_t GetPageSize();
+        static Il2CppString* GetNewLine();
+        static Il2CppString* internalGetEnvironmentVariable_native(intptr_t variable);
+        static Il2CppString* get_bundled_machine_config();
+#endif
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Exception.h

@@ -0,0 +1,22 @@
+#pragma once
+#if NET_4_0
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Exception
+    {
+    public:
+        static bool nIsTransient(int32_t hr);
+        static Il2CppObject* GetMethodFromStackTrace(Il2CppObject* stackTrace);
+    };
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/GC.h

@@ -0,0 +1,41 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppObject;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API GC
+    {
+    public:
+        static int get_MaxGeneration();
+        static int32_t CollectionCount(int32_t generation);
+        static int32_t GetGeneration(Il2CppObject* obj);
+        static int64_t GetTotalMemory(bool forceFullCollection);
+        static void InternalCollect(int generation);
+        static void KeepAlive(Il2CppObject* obj);
+        static void ReRegisterForFinalize(Il2CppObject* obj);
+        static void SuppressFinalize(Il2CppObject *);
+        static void RecordPressure(int64_t bytesAllocated);
+        static void WaitForPendingFinalizers();
+#if NET_4_0
+        static Il2CppObject* get_ephemeron_tombstone();
+        static void register_ephemeron_array(Il2CppArray* array);
+        static int32_t GetCollectionCount(int32_t generation);
+        static int32_t GetMaxGeneration();
+        static void _ReRegisterForFinalize(Il2CppObject* o);
+        static void _SuppressFinalize(Il2CppObject* o);
+#endif
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Math.h

@@ -0,0 +1,43 @@
+#pragma once
+#include "il2cpp-config.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Math
+    {
+    public:
+        static double Acos(double val);
+        static double Asin(double val);
+        static double Atan(double val);
+        static double Atan2(double y, double x);
+        static double Cos(double val);
+        static double Cosh(double val);
+        static double Exp(double val);
+        static double Floor(double x);
+        static double Log(double x);
+        static double Log10(double val);
+        static double Pow(double val, double exp);
+        static double Round(double x);
+        static double Round2(double value, int32_t digits, bool away_from_zero);
+        static double Sin(double val);
+        static double Sinh(double val);
+        static double Sqrt(double val);
+        static double Tan(double val);
+        static double Tanh(double val);
+#if NET_4_0
+        static double Abs(double value);
+        static double Ceiling(double a);
+        static double SplitFractionDouble(double* value);
+        static float Abs(float value);
+#endif
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/MissingMemberException.h

@@ -0,0 +1,21 @@
+#pragma once
+#if NET_4_0
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API MissingMemberException
+    {
+    public:
+        static Il2CppString* FormatSignature(Il2CppArray* signature);
+    };
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/MonoCustomAttrs.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppArray;
+struct Il2CppObject;
+struct Il2CppReflectionType;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API MonoCustomAttrs
+    {
+    public:
+        static Il2CppArray* GetCustomAttributesDataInternal(Il2CppObject* obj);
+        static Il2CppArray * GetCustomAttributesInternal(Il2CppObject* obj, Il2CppReflectionType* type, bool pseudoAttrs);
+        static bool IsDefinedInternal(Il2CppObject *obj, Il2CppReflectionType *attr_type);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/MonoEnumInfo.h

@@ -0,0 +1,27 @@
+#pragma once
+#include "il2cpp-config.h"
+
+#if !NET_4_0
+
+struct Il2CppReflectionType;
+struct Il2CppEnumInfo;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API MonoEnumInfo
+    {
+    public:
+        static void get_enum_info(Il2CppReflectionType* type, Il2CppEnumInfo* info);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/MonoType.h

@@ -0,0 +1,90 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct mscorlib_System_Reflection_MethodInfo;
+
+struct Il2CppArray;
+struct Il2CppString;
+struct Il2CppReflectionAssembly;
+struct Il2CppReflectionField;
+struct Il2CppReflectionModule;
+struct Il2CppReflectionMonoType;
+struct Il2CppReflectionType;
+struct Il2CppReflectionEvent;
+
+typedef int32_t BindingFlags;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    enum
+    {
+        BFLAGS_IgnoreCase = 1,
+        BFLAGS_DeclaredOnly = 2,
+        BFLAGS_Instance = 4,
+        BFLAGS_Static = 8,
+        BFLAGS_Public = 0x10,
+        BFLAGS_NonPublic = 0x20,
+        BFLAGS_FlattenHierarchy = 0x40,
+        BFLAGS_InvokeMethod = 0x100,
+        BFLAGS_CreateInstance = 0x200,
+        BFLAGS_GetField = 0x400,
+        BFLAGS_SetField = 0x800,
+        BFLAGS_GetProperty = 0x1000,
+        BFLAGS_SetProperty = 0x2000,
+        BFLAGS_ExactBinding = 0x10000,
+        BFLAGS_SuppressChangeType = 0x20000,
+        BFLAGS_OptionalParamBinding = 0x40000
+    };
+
+
+    class LIBIL2CPP_CODEGEN_API MonoType
+    {
+    public:
+        static Il2CppString* getFullName(Il2CppReflectionType* type, bool full_name, bool assembly_qualified);
+        static Il2CppArray* GetFields_internal(Il2CppReflectionType* _this, int, Il2CppReflectionType* reflectedType);
+        static Il2CppArray* GetFieldsByName(Il2CppReflectionType* _this, Il2CppString* name, int, Il2CppReflectionType* reflectedType);
+        static int GetArrayRank(Il2CppReflectionType* type);
+        static Il2CppArray* GetConstructors_internal(Il2CppReflectionType* type, int32_t bflags, Il2CppReflectionType* reftype);
+        static Il2CppReflectionType* GetElementType(Il2CppReflectionType* type);
+        static Il2CppArray* GetEvents_internal(Il2CppReflectionType* thisPtr, int32_t bindingFlags, Il2CppReflectionType* type);
+        static Il2CppArray* GetEventsByName(Il2CppReflectionType* _this, Il2CppString* name, int bindingFlags, Il2CppReflectionType* reflectedType);
+        static Il2CppReflectionField* GetField(Il2CppReflectionType* _this, Il2CppString* name, int32_t bindingFlags);
+        static Il2CppArray* GetGenericArguments(Il2CppReflectionType* type);
+        static Il2CppArray* GetInterfaces(Il2CppReflectionType* type);
+        static Il2CppArray* GetMethodsByName(Il2CppReflectionType* _this, Il2CppString* name, int bindingFlags, bool ignoreCase, Il2CppReflectionType* type);
+        static Il2CppReflectionType* GetNestedType(Il2CppReflectionType* type, Il2CppString* name, BindingFlags bindingFlags);
+        static Il2CppArray* GetNestedTypesByName(Il2CppReflectionType* type, Il2CppString* name, int32_t bindingAttr);
+        static Il2CppArray* GetNestedTypes(Il2CppReflectionType* type, int32_t bindingAttr);
+        static Il2CppArray* GetPropertiesByName(Il2CppReflectionType* _this, Il2CppString* name, uint32_t bindingFlags, bool ignoreCase, Il2CppReflectionType* type);
+        static Il2CppReflectionEvent* InternalGetEvent(Il2CppReflectionType* _this, Il2CppString* name, int32_t bindingFlags);
+        static bool IsByRefImpl(Il2CppReflectionType* type);
+        static bool IsCOMObjectImpl(Il2CppReflectionMonoType*);
+        static bool IsPointerImpl(Il2CppReflectionType* type);
+        static Il2CppReflectionAssembly* get_Assembly(Il2CppReflectionType*);
+        static Il2CppReflectionType* get_BaseType(Il2CppReflectionType* type);
+        static void* /* System.Reflection.MethodBase */ get_DeclaringMethod(void* /* System.MonoType */ self);
+        static Il2CppReflectionType* get_DeclaringType(Il2CppReflectionMonoType*);
+        static bool get_IsGenericParameter(Il2CppReflectionType*);
+        static bool IsGenericParameter(const Il2CppType *type);
+        static Il2CppReflectionModule* get_Module(Il2CppReflectionType* thisPtr);
+        static Il2CppString* get_Name(Il2CppReflectionType* type);
+        static Il2CppString* get_Namespace(Il2CppReflectionType* type);
+        static int get_attributes(Il2CppReflectionType* type);
+        static void type_from_obj(void* /* System.MonoType */ type, Il2CppObject* obj);
+        static bool IsPrimitiveImpl(Il2CppReflectionType*);
+        static bool PropertyEqual(const PropertyInfo* prop1, const PropertyInfo* prop2);
+        static bool PropertyAccessorNonPublic(const MethodInfo* accessor, bool start_klass);
+        static bool MethodNonPublic(const MethodInfo* method, bool start_klass);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Number.h

@@ -0,0 +1,24 @@
+#pragma once
+#if NET_4_0
+
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Number
+    {
+    public:
+        static bool NumberBufferToDecimal(uint8_t* number, Il2CppDecimal* value);
+        static bool NumberBufferToDouble(uint8_t* number, double* value);
+    };
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/NumberFormatter.h

@@ -0,0 +1,27 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API NumberFormatter
+    {
+    public:
+        static void GetFormatterTables(uint64_t * * mantissas,
+            int32_t * * exponents,
+            int16_t * * digitLowerTable,
+            int16_t * * digitUpperTable,
+            int64_t * * tenPowersList,
+            int32_t * * decHexDigits);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Object.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppObject;
+struct Il2CppReflectionType;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Object
+    {
+    public:
+        static Il2CppReflectionType* GetType(Il2CppObject* obj);
+        static int InternalGetHashCode(Il2CppObject* obj);
+        static intptr_t obj_address(Il2CppObject* obj);
+        static Il2CppObject* MemberwiseClone(Il2CppObject* obj);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/RuntimeFieldHandle.h

@@ -0,0 +1,23 @@
+#pragma once
+#if NET_4_0
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API RuntimeFieldHandle
+    {
+    public:
+        static void SetValueDirect(Il2CppReflectionField* field, Il2CppObject* fieldType, Il2CppTypedRef* typedRef, Il2CppObject* value, Il2CppObject* contextType);
+        static void SetValueInternal(Il2CppReflectionField* fi, Il2CppObject* obj, Il2CppObject* value);
+    };
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/RuntimeMethodHandle.h

@@ -0,0 +1,35 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-object-internals.h"
+#include "il2cpp-config.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API RuntimeMethodHandle
+    {
+    public:
+        static intptr_t GetFunctionPointer(intptr_t m);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/RuntimeType.h

@@ -0,0 +1,63 @@
+#pragma once
+
+#if NET_4_0
+
+struct Il2CppReflectionRuntimeType;
+
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API RuntimeType
+    {
+    public:
+        static bool IsTypeExportedToWindowsRuntime(Il2CppObject* type);
+        static bool IsWindowsRuntimeObjectType(Il2CppObject* type);
+        static int32_t get_core_clr_security_level(Il2CppObject* _this);
+        static int32_t GetGenericParameterPosition(Il2CppReflectionRuntimeType* _this);
+        static Il2CppObject* CreateInstanceInternal(Il2CppReflectionType* type);
+        static int32_t GetGenericParameterAttributes(Il2CppReflectionRuntimeType* _this);
+        static Il2CppObject* get_DeclaringMethod(Il2CppObject* _this);
+        static Il2CppArray* GetConstructors_internal(Il2CppReflectionRuntimeType* _this, int32_t bindingAttr, Il2CppReflectionType* reflected_type);
+        static Il2CppArray* GetEvents_internal(Il2CppReflectionRuntimeType* _this, Il2CppString* name, int32_t bindingAttr, Il2CppReflectionType* reflected_type);
+        static Il2CppArray* GetFields_internal(Il2CppReflectionRuntimeType* _this, Il2CppString* name, int32_t bindingAttr, Il2CppReflectionType* reflected_type);
+        static Il2CppArray* GetMethodsByName(Il2CppReflectionRuntimeType* _this, Il2CppString* name, int32_t bindingAttr, bool ignoreCase, Il2CppReflectionType* reflected_type);
+        static Il2CppArray* GetPropertiesByName(Il2CppReflectionRuntimeType* _this, Il2CppString* name, int32_t bindingAttr, bool icase, Il2CppReflectionType* reflected_type);
+        static Il2CppArray* GetNestedTypes_internal(Il2CppReflectionRuntimeType* _this, Il2CppString* name, int32_t bindingFlags);
+        static Il2CppString* get_Name(Il2CppReflectionRuntimeType* _this);
+        static Il2CppString* get_Namespace(Il2CppReflectionRuntimeType* _this);
+        static Il2CppString* getFullName(Il2CppReflectionRuntimeType* _this, bool full_name, bool assembly_qualified);
+        static Il2CppReflectionType* get_DeclaringType(Il2CppReflectionRuntimeType* _this);
+        static Il2CppReflectionType* make_array_type(Il2CppReflectionRuntimeType* _this, int32_t rank);
+        static Il2CppReflectionType* make_byref_type(Il2CppReflectionRuntimeType* _this);
+        static Il2CppReflectionType* MakeGenericType(Il2CppReflectionType* gt, Il2CppArray* types);
+        static Il2CppReflectionType* MakePointerType(Il2CppReflectionType* type);
+        static Il2CppArray* GetGenericArgumentsInternal(Il2CppReflectionRuntimeType* _this, bool runtimeArray);
+        static Il2CppArray* GetGenericParameterConstraints_impl(Il2CppReflectionRuntimeType* _this);
+        static Il2CppArray* GetInterfaces(Il2CppReflectionRuntimeType* _this);
+        static int32_t GetTypeCodeImplInternal(Il2CppReflectionType* type);
+        static void GetInterfaceMapData(Il2CppReflectionType* t, Il2CppReflectionType* iface, Il2CppArray** targets, Il2CppArray** methods);
+        static void GetPacking(Il2CppReflectionRuntimeType* _this, int32_t* packing, int32_t* size);
+
+        static intptr_t GetConstructors_native(Il2CppReflectionRuntimeType* thisPtr, int32_t bindingAttr);
+        static intptr_t GetEvents_native(Il2CppReflectionRuntimeType* thisPtr, intptr_t name, int32_t bindingAttr);
+        static intptr_t GetFields_native(Il2CppReflectionRuntimeType* thisPtr, intptr_t name, int32_t bindingAttr);
+        static intptr_t GetMethodsByName_native(Il2CppReflectionRuntimeType* thisPtr, intptr_t namePtr, int32_t bindingAttr, bool ignoreCase);
+        static intptr_t GetNestedTypes_native(Il2CppReflectionRuntimeType* thisPtr, intptr_t name, int32_t bindingAttr);
+        static intptr_t GetPropertiesByName_native(Il2CppReflectionRuntimeType* thisPtr, intptr_t name, int32_t bindingAttr, bool icase);
+
+        static void* /* System.Reflection.ConstructorInfo */ GetCorrespondingInflatedConstructor(void* /* System.MonoType */ self, void* /* System.Reflection.ConstructorInfo */ genericInfo);
+        static mscorlib_System_Reflection_MethodInfo* GetCorrespondingInflatedMethod(Il2CppReflectionMonoType*, Il2CppReflectionMonoType*);
+    };
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/RuntimeTypeHandle.h

@@ -0,0 +1,42 @@
+#pragma once
+
+#if NET_4_0
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API RuntimeTypeHandle
+    {
+    public:
+        static bool HasInstantiation(Il2CppReflectionRuntimeType* type);
+        static bool HasReferences(Il2CppReflectionRuntimeType* type);
+        static bool IsArray(Il2CppReflectionRuntimeType* type);
+        static bool IsByRef(Il2CppReflectionRuntimeType* type);
+        static bool IsComObject(Il2CppReflectionRuntimeType* type);
+        static bool IsGenericTypeDefinition(Il2CppReflectionRuntimeType* type);
+        static bool IsGenericVariable(Il2CppReflectionRuntimeType* type);
+        static bool IsInstanceOfType(Il2CppReflectionRuntimeType* type, Il2CppObject* o);
+        static bool IsPointer(Il2CppReflectionRuntimeType* type);
+        static bool IsPrimitive(Il2CppReflectionRuntimeType* type);
+        static bool type_is_assignable_from(Il2CppReflectionType* a, Il2CppReflectionType* b);
+        static int32_t GetArrayRank(Il2CppReflectionRuntimeType* type);
+        static int32_t GetMetadataToken(Il2CppReflectionRuntimeType* type);
+        static Il2CppReflectionAssembly* GetAssembly(Il2CppReflectionRuntimeType* type);
+        static Il2CppReflectionModule* GetModule(Il2CppReflectionRuntimeType* type);
+        static int32_t GetAttributes(Il2CppReflectionRuntimeType* type);
+        static Il2CppReflectionRuntimeType* GetBaseType(Il2CppReflectionRuntimeType* type);
+        static Il2CppReflectionRuntimeType* GetElementType(Il2CppReflectionRuntimeType* type);
+        static Il2CppReflectionType* GetGenericTypeDefinition_impl(Il2CppReflectionRuntimeType* type);
+        static intptr_t GetGenericParameterInfo(Il2CppReflectionRuntimeType* type);
+    };
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/SizedReference.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#if NET_4_0
+
+#include "il2cpp-object-internals.h"
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API SizedReference
+    {
+    public:
+        static int64_t GetApproximateSizeOfSizedRef(intptr_t h);
+        static intptr_t CreateSizedRef(Il2CppObject* o);
+        static Il2CppObject* GetTargetOfSizedRef(intptr_t h);
+        static void FreeSizedRef(intptr_t h);
+    };
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/String.h

@@ -0,0 +1,32 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppString;
+struct Il2CppArray;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API String
+    {
+    public:
+        static void RedirectToCreateString();
+        static Il2CppString* InternalAllocateStr(int length);
+        static Il2CppString* InternalIntern(Il2CppString* str);
+        static Il2CppArray* InternalSplit(Il2CppString *, Il2CppArray*, int, int);
+        static Il2CppString* InternalIsInterned(Il2CppString* str);
+#if NET_4_0
+        static Il2CppString* FastAllocateString(int32_t length);
+#endif
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/TimeSpan.h

@@ -0,0 +1,21 @@
+#pragma once
+#if NET_4_0
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API TimeSpan
+    {
+    public:
+        static bool LegacyFormatMode();
+    };
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/TimeZoneInfo.h

@@ -0,0 +1,23 @@
+#pragma once
+
+#if NET_4_0
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API TimeZoneInfo
+    {
+    public:
+        static inline bool UseRegistryForTimeZoneInformation() { return IL2CPP_TARGET_WINDOWS_DESKTOP; }
+    };
+} // namespace System
+} // namespace mscorlib
+} // namespace icalls
+} // namespace il2cpp
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/Type.h

@@ -0,0 +1,47 @@
+#pragma once
+
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct mscorlib_System_Reflection_Assembly;
+struct mscorlib_System_Reflection_Module;
+struct mscorlib_System_Reflection_MethodInfo;
+
+typedef int32_t Il2CppGenericParameterAttributes;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API Type
+    {
+    public:
+        static bool EqualsInternal(Il2CppReflectionType* left, Il2CppReflectionType* right);
+        static Il2CppGenericParameterAttributes GetGenericParameterAttributes(Il2CppReflectionType* type);
+        static Il2CppArray* GetGenericParameterConstraints_impl(Il2CppReflectionType* type);
+        static int32_t GetGenericParameterPosition(Il2CppReflectionType* type);
+        static Il2CppReflectionType* GetGenericTypeDefinition_impl(Il2CppReflectionType*);
+        static void GetInterfaceMapData(Il2CppReflectionType* t, Il2CppReflectionType* iface, Il2CppArray** targets, Il2CppArray** methods);
+        static void GetPacking(Il2CppReflectionType* type, int32_t* packing, int32_t* size);
+        static int GetTypeCodeInternal(Il2CppReflectionType*);
+        static bool IsArrayImpl(Il2CppReflectionType* t);
+        static bool IsInstanceOfType(Il2CppReflectionType* type, Il2CppObject* obj);
+        static Il2CppReflectionType* MakeGenericType(Il2CppReflectionType* , Il2CppArray*);
+        static Il2CppReflectionType* MakePointerType(Il2CppReflectionType* thisPtr);
+        static bool get_IsGenericType(Il2CppReflectionType*);
+        static bool get_IsGenericTypeDefinition(Il2CppReflectionType* type);
+        static Il2CppReflectionType* internal_from_handle(intptr_t ptr);
+        static Il2CppReflectionType* internal_from_name(Il2CppString* name, bool throwOnError, bool ignoreCase);
+        static Il2CppReflectionType* make_array_type(Il2CppReflectionType* type, int32_t rank);
+        static bool type_is_assignable_from(Il2CppReflectionType* type, Il2CppReflectionType* c);
+        static bool type_is_subtype_of(Il2CppReflectionType* type, Il2CppReflectionType* c, bool check_interfaces);
+        static Il2CppReflectionType* make_byref_type(Il2CppReflectionType* type);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/TypedReference.h

@@ -0,0 +1,39 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppObject;
+struct Il2CppDelegate;
+struct Il2CppReflectionType;
+struct Il2CppReflectionMethod;
+struct Il2CppReflectionField;
+struct Il2CppArray;
+struct Il2CppException;
+struct Il2CppReflectionModule;
+struct Il2CppAssembly;
+struct Il2CppAssemblyName;
+struct Il2CppAppDomain;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API TypedReference
+    {
+    public:
+        static Il2CppObject* ToObject(void* /* System.TypedReference */ value);
+#if NET_4_0
+        static Il2CppObject* InternalToObject(Il2CppTypedRef* typedRef);
+        static Il2CppTypedRef MakeTypedReferenceInternal(Il2CppObject* target, Il2CppArray* fields);
+#endif
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/ValueType.h

@@ -0,0 +1,26 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+
+struct Il2CppArray;
+struct Il2CppObject;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API ValueType
+    {
+    public:
+        static bool InternalEquals(Il2CppObject * thisPtr, Il2CppObject * that, Il2CppArray** fields);
+        static int InternalGetHashCode(Il2CppObject *, Il2CppArray * *);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/icalls/mscorlib/System/__ComObject.h

@@ -0,0 +1,28 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-config.h"
+#include "il2cpp-object-internals.h"
+
+struct Il2CppReflectionType;
+struct mscorlib_System___ComObject;
+
+namespace il2cpp
+{
+namespace icalls
+{
+namespace mscorlib
+{
+namespace System
+{
+    class LIBIL2CPP_CODEGEN_API __ComObject
+    {
+    public:
+        static mscorlib_System___ComObject * CreateRCW(Il2CppReflectionType * t);
+        static void ReleaseInterfaces(mscorlib_System___ComObject * thisPtr);
+        static intptr_t GetInterfaceInternal(mscorlib_System___ComObject * thisPtr, Il2CppReflectionType * t, bool throwException);
+    };
+} /* namespace System */
+} /* namespace mscorlib */
+} /* namespace icalls */
+} /* namespace il2cpp */

App/LearnWithTouch_ios/Libraries/libil2cpp/include/il2cpp-api-functions.h

@@ -0,0 +1,274 @@
+#ifndef DO_API_NO_RETURN
+#define DO_API_NO_RETURN(r, n, p) DO_API(r,n,p)
+#endif
+
+
+DO_API(void, il2cpp_init, (const char* domain_name));
+DO_API(void, il2cpp_init_utf16, (const Il2CppChar * domain_name));
+DO_API(void, il2cpp_shutdown, ());
+DO_API(void, il2cpp_set_config_dir, (const char *config_path));
+DO_API(void, il2cpp_set_data_dir, (const char *data_path));
+DO_API(void, il2cpp_set_temp_dir, (const char *temp_path));
+DO_API(void, il2cpp_set_commandline_arguments, (int argc, const char* const argv[], const char* basedir));
+DO_API(void, il2cpp_set_commandline_arguments_utf16, (int argc, const Il2CppChar * const argv[], const char* basedir));
+DO_API(void, il2cpp_set_config_utf16, (const Il2CppChar * executablePath));
+DO_API(void, il2cpp_set_config, (const char* executablePath));
+
+DO_API(void, il2cpp_set_memory_callbacks, (Il2CppMemoryCallbacks * callbacks));
+DO_API(const Il2CppImage*, il2cpp_get_corlib, ());
+DO_API(void, il2cpp_add_internal_call, (const char* name, Il2CppMethodPointer method));
+DO_API(Il2CppMethodPointer, il2cpp_resolve_icall, (const char* name));
+
+DO_API(void*, il2cpp_alloc, (size_t size));
+DO_API(void, il2cpp_free, (void* ptr));
+
+// array
+DO_API(Il2CppClass*, il2cpp_array_class_get, (Il2CppClass * element_class, uint32_t rank));
+DO_API(uint32_t, il2cpp_array_length, (Il2CppArray * array));
+DO_API(uint32_t, il2cpp_array_get_byte_length, (Il2CppArray * array));
+DO_API(Il2CppArray*, il2cpp_array_new, (Il2CppClass * elementTypeInfo, il2cpp_array_size_t length));
+DO_API(Il2CppArray*, il2cpp_array_new_specific, (Il2CppClass * arrayTypeInfo, il2cpp_array_size_t length));
+DO_API(Il2CppArray*, il2cpp_array_new_full, (Il2CppClass * array_class, il2cpp_array_size_t * lengths, il2cpp_array_size_t * lower_bounds));
+DO_API(Il2CppClass*, il2cpp_bounded_array_class_get, (Il2CppClass * element_class, uint32_t rank, bool bounded));
+DO_API(int, il2cpp_array_element_size, (const Il2CppClass * array_class));
+
+// assembly
+DO_API(const Il2CppImage*, il2cpp_assembly_get_image, (const Il2CppAssembly * assembly));
+
+// class
+DO_API(const Il2CppType*, il2cpp_class_enum_basetype, (Il2CppClass * klass));
+DO_API(bool, il2cpp_class_is_generic, (const Il2CppClass * klass));
+DO_API(bool, il2cpp_class_is_inflated, (const Il2CppClass * klass));
+DO_API(bool, il2cpp_class_is_assignable_from, (Il2CppClass * klass, Il2CppClass * oklass));
+DO_API(bool, il2cpp_class_is_subclass_of, (Il2CppClass * klass, Il2CppClass * klassc, bool check_interfaces));
+DO_API(bool, il2cpp_class_has_parent, (Il2CppClass * klass, Il2CppClass * klassc));
+DO_API(Il2CppClass*, il2cpp_class_from_il2cpp_type, (const Il2CppType * type));
+DO_API(Il2CppClass*, il2cpp_class_from_name, (const Il2CppImage * image, const char* namespaze, const char *name));
+DO_API(Il2CppClass*, il2cpp_class_from_system_type, (Il2CppReflectionType * type));
+DO_API(Il2CppClass*, il2cpp_class_get_element_class, (Il2CppClass * klass));
+DO_API(const EventInfo*, il2cpp_class_get_events, (Il2CppClass * klass, void* *iter));
+DO_API(FieldInfo*, il2cpp_class_get_fields, (Il2CppClass * klass, void* *iter));
+DO_API(Il2CppClass*, il2cpp_class_get_nested_types, (Il2CppClass * klass, void* *iter));
+DO_API(Il2CppClass*, il2cpp_class_get_interfaces, (Il2CppClass * klass, void* *iter));
+DO_API(const PropertyInfo*, il2cpp_class_get_properties, (Il2CppClass * klass, void* *iter));
+DO_API(const PropertyInfo*, il2cpp_class_get_property_from_name, (Il2CppClass * klass, const char *name));
+DO_API(FieldInfo*, il2cpp_class_get_field_from_name, (Il2CppClass * klass, const char *name));
+DO_API(const MethodInfo*, il2cpp_class_get_methods, (Il2CppClass * klass, void* *iter));
+DO_API(const MethodInfo*, il2cpp_class_get_method_from_name, (Il2CppClass * klass, const char* name, int argsCount));
+DO_API(const char*, il2cpp_class_get_name, (Il2CppClass * klass));
+DO_API(const char*, il2cpp_class_get_namespace, (Il2CppClass * klass));
+DO_API(Il2CppClass*, il2cpp_class_get_parent, (Il2CppClass * klass));
+DO_API(Il2CppClass*, il2cpp_class_get_declaring_type, (Il2CppClass * klass));
+DO_API(int32_t, il2cpp_class_instance_size, (Il2CppClass * klass));
+DO_API(size_t, il2cpp_class_num_fields, (const Il2CppClass * enumKlass));
+DO_API(bool, il2cpp_class_is_valuetype, (const Il2CppClass * klass));
+DO_API(int32_t, il2cpp_class_value_size, (Il2CppClass * klass, uint32_t * align));
+DO_API(bool, il2cpp_class_is_blittable, (const Il2CppClass * klass));
+DO_API(int, il2cpp_class_get_flags, (const Il2CppClass * klass));
+DO_API(bool, il2cpp_class_is_abstract, (const Il2CppClass * klass));
+DO_API(bool, il2cpp_class_is_interface, (const Il2CppClass * klass));
+DO_API(int, il2cpp_class_array_element_size, (const Il2CppClass * klass));
+DO_API(Il2CppClass*, il2cpp_class_from_type, (const Il2CppType * type));
+DO_API(const Il2CppType*, il2cpp_class_get_type, (Il2CppClass * klass));
+DO_API(uint32_t, il2cpp_class_get_type_token, (Il2CppClass * klass));
+DO_API(bool, il2cpp_class_has_attribute, (Il2CppClass * klass, Il2CppClass * attr_class));
+DO_API(bool, il2cpp_class_has_references, (Il2CppClass * klass));
+DO_API(bool, il2cpp_class_is_enum, (const Il2CppClass * klass));
+DO_API(const Il2CppImage*, il2cpp_class_get_image, (Il2CppClass * klass));
+DO_API(const char*, il2cpp_class_get_assemblyname, (const Il2CppClass * klass));
+DO_API(int, il2cpp_class_get_rank, (const Il2CppClass * klass));
+
+// testing only
+DO_API(size_t, il2cpp_class_get_bitmap_size, (const Il2CppClass * klass));
+DO_API(void, il2cpp_class_get_bitmap, (Il2CppClass * klass, size_t * bitmap));
+
+// stats
+DO_API(bool, il2cpp_stats_dump_to_file, (const char *path));
+DO_API(uint64_t, il2cpp_stats_get_value, (Il2CppStat stat));
+
+// domain
+DO_API(Il2CppDomain*, il2cpp_domain_get, ());
+DO_API(const Il2CppAssembly*, il2cpp_domain_assembly_open, (Il2CppDomain * domain, const char* name));
+DO_API(const Il2CppAssembly**, il2cpp_domain_get_assemblies, (const Il2CppDomain * domain, size_t * size));
+
+// exception
+DO_API_NO_RETURN(void, il2cpp_raise_exception, (Il2CppException*));
+DO_API(Il2CppException*, il2cpp_exception_from_name_msg, (const Il2CppImage * image, const char *name_space, const char *name, const char *msg));
+DO_API(Il2CppException*, il2cpp_get_exception_argument_null, (const char *arg));
+DO_API(void, il2cpp_format_exception, (const Il2CppException * ex, char* message, int message_size));
+DO_API(void, il2cpp_format_stack_trace, (const Il2CppException * ex, char* output, int output_size));
+DO_API(void, il2cpp_unhandled_exception, (Il2CppException*));
+
+// field
+DO_API(int, il2cpp_field_get_flags, (FieldInfo * field));
+DO_API(const char*, il2cpp_field_get_name, (FieldInfo * field));
+DO_API(Il2CppClass*, il2cpp_field_get_parent, (FieldInfo * field));
+DO_API(size_t, il2cpp_field_get_offset, (FieldInfo * field));
+DO_API(const Il2CppType*, il2cpp_field_get_type, (FieldInfo * field));
+DO_API(void, il2cpp_field_get_value, (Il2CppObject * obj, FieldInfo * field, void *value));
+DO_API(Il2CppObject*, il2cpp_field_get_value_object, (FieldInfo * field, Il2CppObject * obj));
+DO_API(bool, il2cpp_field_has_attribute, (FieldInfo * field, Il2CppClass * attr_class));
+DO_API(void, il2cpp_field_set_value, (Il2CppObject * obj, FieldInfo * field, void *value));
+DO_API(void, il2cpp_field_static_get_value, (FieldInfo * field, void *value));
+DO_API(void, il2cpp_field_static_set_value, (FieldInfo * field, void *value));
+DO_API(void, il2cpp_field_set_value_object, (Il2CppObject * instance, FieldInfo * field, Il2CppObject * value));
+
+// gc
+DO_API(void, il2cpp_gc_collect, (int maxGenerations));
+DO_API(int32_t, il2cpp_gc_collect_a_little, ());
+DO_API(void, il2cpp_gc_disable, ());
+DO_API(void, il2cpp_gc_enable, ());
+DO_API(bool, il2cpp_gc_is_disabled, ());
+DO_API(int64_t, il2cpp_gc_get_used_size, ());
+DO_API(int64_t, il2cpp_gc_get_heap_size, ());
+DO_API(void, il2cpp_gc_wbarrier_set_field, (Il2CppObject * obj, void **targetAddress, void *object));
+
+// gchandle
+DO_API(uint32_t, il2cpp_gchandle_new, (Il2CppObject * obj, bool pinned));
+DO_API(uint32_t, il2cpp_gchandle_new_weakref, (Il2CppObject * obj, bool track_resurrection));
+DO_API(Il2CppObject*, il2cpp_gchandle_get_target , (uint32_t gchandle));
+DO_API(void, il2cpp_gchandle_free, (uint32_t gchandle));
+
+// liveness
+DO_API(void*, il2cpp_unity_liveness_calculation_begin, (Il2CppClass * filter, int max_object_count, il2cpp_register_object_callback callback, void* userdata, il2cpp_WorldChangedCallback onWorldStarted, il2cpp_WorldChangedCallback onWorldStopped));
+DO_API(void, il2cpp_unity_liveness_calculation_end, (void* state));
+DO_API(void, il2cpp_unity_liveness_calculation_from_root, (Il2CppObject * root, void* state));
+DO_API(void, il2cpp_unity_liveness_calculation_from_statics, (void* state));
+
+// method
+DO_API(const Il2CppType*, il2cpp_method_get_return_type, (const MethodInfo * method));
+DO_API(Il2CppClass*, il2cpp_method_get_declaring_type, (const MethodInfo * method));
+DO_API(const char*, il2cpp_method_get_name, (const MethodInfo * method));
+DO_API(const MethodInfo*, il2cpp_method_get_from_reflection, (const Il2CppReflectionMethod * method));
+DO_API(Il2CppReflectionMethod*, il2cpp_method_get_object, (const MethodInfo * method, Il2CppClass * refclass));
+DO_API(bool, il2cpp_method_is_generic, (const MethodInfo * method));
+DO_API(bool, il2cpp_method_is_inflated, (const MethodInfo * method));
+DO_API(bool, il2cpp_method_is_instance, (const MethodInfo * method));
+DO_API(uint32_t, il2cpp_method_get_param_count, (const MethodInfo * method));
+DO_API(const Il2CppType*, il2cpp_method_get_param, (const MethodInfo * method, uint32_t index));
+DO_API(Il2CppClass*, il2cpp_method_get_class, (const MethodInfo * method));
+DO_API(bool, il2cpp_method_has_attribute, (const MethodInfo * method, Il2CppClass * attr_class));
+DO_API(uint32_t, il2cpp_method_get_flags, (const MethodInfo * method, uint32_t * iflags));
+DO_API(uint32_t, il2cpp_method_get_token, (const MethodInfo * method));
+DO_API(const char*, il2cpp_method_get_param_name, (const MethodInfo * method, uint32_t index));
+
+// profiler
+#if IL2CPP_ENABLE_PROFILER
+
+DO_API(void, il2cpp_profiler_install, (Il2CppProfiler * prof, Il2CppProfileFunc shutdown_callback));
+DO_API(void, il2cpp_profiler_set_events, (Il2CppProfileFlags events));
+DO_API(void, il2cpp_profiler_install_enter_leave, (Il2CppProfileMethodFunc enter, Il2CppProfileMethodFunc fleave));
+DO_API(void, il2cpp_profiler_install_allocation, (Il2CppProfileAllocFunc callback));
+DO_API(void, il2cpp_profiler_install_gc, (Il2CppProfileGCFunc callback, Il2CppProfileGCResizeFunc heap_resize_callback));
+DO_API(void, il2cpp_profiler_install_fileio, (Il2CppProfileFileIOFunc callback));
+DO_API(void, il2cpp_profiler_install_thread, (Il2CppProfileThreadFunc start, Il2CppProfileThreadFunc end));
+
+#endif
+
+// property
+DO_API(uint32_t, il2cpp_property_get_flags, (PropertyInfo * prop));
+DO_API(const MethodInfo*, il2cpp_property_get_get_method, (PropertyInfo * prop));
+DO_API(const MethodInfo*, il2cpp_property_get_set_method, (PropertyInfo * prop));
+DO_API(const char*, il2cpp_property_get_name, (PropertyInfo * prop));
+DO_API(Il2CppClass*, il2cpp_property_get_parent, (PropertyInfo * prop));
+
+// object
+DO_API(Il2CppClass*, il2cpp_object_get_class, (Il2CppObject * obj));
+DO_API(uint32_t, il2cpp_object_get_size, (Il2CppObject * obj));
+DO_API(const MethodInfo*, il2cpp_object_get_virtual_method, (Il2CppObject * obj, const MethodInfo * method));
+DO_API(Il2CppObject*, il2cpp_object_new, (const Il2CppClass * klass));
+DO_API(void*, il2cpp_object_unbox, (Il2CppObject * obj));
+
+DO_API(Il2CppObject*, il2cpp_value_box, (Il2CppClass * klass, void* data));
+
+// monitor
+DO_API(void, il2cpp_monitor_enter, (Il2CppObject * obj));
+DO_API(bool, il2cpp_monitor_try_enter, (Il2CppObject * obj, uint32_t timeout));
+DO_API(void, il2cpp_monitor_exit, (Il2CppObject * obj));
+DO_API(void, il2cpp_monitor_pulse, (Il2CppObject * obj));
+DO_API(void, il2cpp_monitor_pulse_all, (Il2CppObject * obj));
+DO_API(void, il2cpp_monitor_wait, (Il2CppObject * obj));
+DO_API(bool, il2cpp_monitor_try_wait, (Il2CppObject * obj, uint32_t timeout));
+
+// runtime
+DO_API(Il2CppObject*, il2cpp_runtime_invoke, (const MethodInfo * method, void *obj, void **params, Il2CppException **exc));
+DO_API(Il2CppObject*, il2cpp_runtime_invoke_convert_args, (const MethodInfo * method, void *obj, Il2CppObject **params, int paramCount, Il2CppException **exc));
+DO_API(void, il2cpp_runtime_class_init, (Il2CppClass * klass));
+DO_API(void, il2cpp_runtime_object_init, (Il2CppObject * obj));
+
+DO_API(void, il2cpp_runtime_object_init_exception, (Il2CppObject * obj, Il2CppException** exc));
+
+DO_API(void, il2cpp_runtime_unhandled_exception_policy_set, (Il2CppRuntimeUnhandledExceptionPolicy value));
+
+// string
+DO_API(int32_t, il2cpp_string_length, (Il2CppString * str));
+DO_API(Il2CppChar*, il2cpp_string_chars, (Il2CppString * str));
+DO_API(Il2CppString*, il2cpp_string_new, (const char* str));
+DO_API(Il2CppString*, il2cpp_string_new_len, (const char* str, uint32_t length));
+DO_API(Il2CppString*, il2cpp_string_new_utf16, (const Il2CppChar * text, int32_t len));
+DO_API(Il2CppString*, il2cpp_string_new_wrapper, (const char* str));
+DO_API(Il2CppString*, il2cpp_string_intern, (Il2CppString * str));
+DO_API(Il2CppString*, il2cpp_string_is_interned, (Il2CppString * str));
+
+// thread
+DO_API(Il2CppThread*, il2cpp_thread_current, ());
+DO_API(Il2CppThread*, il2cpp_thread_attach, (Il2CppDomain * domain));
+DO_API(void, il2cpp_thread_detach, (Il2CppThread * thread));
+
+DO_API(Il2CppThread**, il2cpp_thread_get_all_attached_threads, (size_t * size));
+DO_API(bool, il2cpp_is_vm_thread, (Il2CppThread * thread));
+
+// stacktrace
+DO_API(void, il2cpp_current_thread_walk_frame_stack, (Il2CppFrameWalkFunc func, void* user_data));
+DO_API(void, il2cpp_thread_walk_frame_stack, (Il2CppThread * thread, Il2CppFrameWalkFunc func, void* user_data));
+DO_API(bool, il2cpp_current_thread_get_top_frame, (Il2CppStackFrameInfo * frame));
+DO_API(bool, il2cpp_thread_get_top_frame, (Il2CppThread * thread, Il2CppStackFrameInfo * frame));
+DO_API(bool, il2cpp_current_thread_get_frame_at, (int32_t offset, Il2CppStackFrameInfo * frame));
+DO_API(bool, il2cpp_thread_get_frame_at, (Il2CppThread * thread, int32_t offset, Il2CppStackFrameInfo * frame));
+DO_API(int32_t, il2cpp_current_thread_get_stack_depth, ());
+DO_API(int32_t, il2cpp_thread_get_stack_depth, (Il2CppThread * thread));
+
+// type
+DO_API(Il2CppObject*, il2cpp_type_get_object, (const Il2CppType * type));
+DO_API(int, il2cpp_type_get_type, (const Il2CppType * type));
+DO_API(Il2CppClass*, il2cpp_type_get_class_or_element_class, (const Il2CppType * type));
+DO_API(char*, il2cpp_type_get_name, (const Il2CppType * type));
+DO_API(bool, il2cpp_type_is_byref, (const Il2CppType * type));
+DO_API(uint32_t, il2cpp_type_get_attrs, (const Il2CppType * type));
+DO_API(bool, il2cpp_type_equals, (const Il2CppType * type, const Il2CppType * otherType));
+DO_API(char*, il2cpp_type_get_assembly_qualified_name, (const Il2CppType * type));
+
+// image
+DO_API(const Il2CppAssembly*, il2cpp_image_get_assembly, (const Il2CppImage * image));
+DO_API(const char*, il2cpp_image_get_name, (const Il2CppImage * image));
+DO_API(const char*, il2cpp_image_get_filename, (const Il2CppImage * image));
+DO_API(const MethodInfo*, il2cpp_image_get_entry_point, (const Il2CppImage * image));
+
+DO_API(size_t, il2cpp_image_get_class_count, (const Il2CppImage * image));
+DO_API(const Il2CppClass*, il2cpp_image_get_class, (const Il2CppImage * image, size_t index));
+
+// Memory information
+DO_API(Il2CppManagedMemorySnapshot*, il2cpp_capture_memory_snapshot, ());
+DO_API(void, il2cpp_free_captured_memory_snapshot, (Il2CppManagedMemorySnapshot * snapshot));
+
+DO_API(void, il2cpp_set_find_plugin_callback, (Il2CppSetFindPlugInCallback method));
+
+// Logging
+DO_API(void, il2cpp_register_log_callback, (Il2CppLogCallback method));
+
+// Debugger
+DO_API(void, il2cpp_debugger_set_agent_options, (const char* options));
+DO_API(bool, il2cpp_is_debugger_attached, ());
+
+// TLS module
+DO_API(void, il2cpp_unity_install_unitytls_interface, (const void* unitytlsInterfaceStruct));
+
+// custom attributes
+DO_API(Il2CppCustomAttrInfo*, il2cpp_custom_attrs_from_class, (Il2CppClass * klass));
+DO_API(Il2CppCustomAttrInfo*, il2cpp_custom_attrs_from_method, (const MethodInfo * method));
+
+DO_API(Il2CppObject*, il2cpp_custom_attrs_get_attr, (Il2CppCustomAttrInfo * ainfo, Il2CppClass * attr_klass));
+DO_API(bool, il2cpp_custom_attrs_has_attr, (Il2CppCustomAttrInfo * ainfo, Il2CppClass * attr_klass));
+DO_API(Il2CppArray*,  il2cpp_custom_attrs_construct, (Il2CppCustomAttrInfo * cinfo));
+
+DO_API(void, il2cpp_custom_attrs_free, (Il2CppCustomAttrInfo * ainfo));

App/LearnWithTouch_ios/Libraries/libil2cpp/include/il2cpp-api-types.h

@@ -0,0 +1,161 @@
+#pragma once
+
+#include <stdint.h>
+#include <stddef.h>
+
+#if !defined(__cplusplus)
+#define bool uint8_t
+#endif // !__cplusplus
+
+typedef struct Il2CppClass Il2CppClass;
+typedef struct Il2CppType Il2CppType;
+typedef struct EventInfo EventInfo;
+typedef struct MethodInfo MethodInfo;
+typedef struct FieldInfo FieldInfo;
+typedef struct PropertyInfo PropertyInfo;
+
+typedef struct Il2CppAssembly Il2CppAssembly;
+typedef struct Il2CppArray Il2CppArray;
+typedef struct Il2CppDelegate Il2CppDelegate;
+typedef struct Il2CppDomain Il2CppDomain;
+typedef struct Il2CppImage Il2CppImage;
+typedef struct Il2CppException Il2CppException;
+typedef struct Il2CppProfiler Il2CppProfiler;
+typedef struct Il2CppObject Il2CppObject;
+typedef struct Il2CppReflectionMethod Il2CppReflectionMethod;
+typedef struct Il2CppReflectionType Il2CppReflectionType;
+typedef struct Il2CppString Il2CppString;
+typedef struct Il2CppThread Il2CppThread;
+typedef struct Il2CppAsyncResult Il2CppAsyncResult;
+typedef struct Il2CppManagedMemorySnapshot Il2CppManagedMemorySnapshot;
+typedef struct Il2CppCustomAttrInfo Il2CppCustomAttrInfo;
+
+typedef enum
+{
+    IL2CPP_PROFILE_NONE = 0,
+    IL2CPP_PROFILE_APPDOMAIN_EVENTS = 1 << 0,
+    IL2CPP_PROFILE_ASSEMBLY_EVENTS  = 1 << 1,
+    IL2CPP_PROFILE_MODULE_EVENTS    = 1 << 2,
+    IL2CPP_PROFILE_CLASS_EVENTS     = 1 << 3,
+    IL2CPP_PROFILE_JIT_COMPILATION  = 1 << 4,
+    IL2CPP_PROFILE_INLINING         = 1 << 5,
+    IL2CPP_PROFILE_EXCEPTIONS       = 1 << 6,
+    IL2CPP_PROFILE_ALLOCATIONS      = 1 << 7,
+    IL2CPP_PROFILE_GC               = 1 << 8,
+    IL2CPP_PROFILE_THREADS          = 1 << 9,
+    IL2CPP_PROFILE_REMOTING         = 1 << 10,
+    IL2CPP_PROFILE_TRANSITIONS      = 1 << 11,
+    IL2CPP_PROFILE_ENTER_LEAVE      = 1 << 12,
+    IL2CPP_PROFILE_COVERAGE         = 1 << 13,
+    IL2CPP_PROFILE_INS_COVERAGE     = 1 << 14,
+    IL2CPP_PROFILE_STATISTICAL      = 1 << 15,
+    IL2CPP_PROFILE_METHOD_EVENTS    = 1 << 16,
+    IL2CPP_PROFILE_MONITOR_EVENTS   = 1 << 17,
+    IL2CPP_PROFILE_IOMAP_EVENTS     = 1 << 18, /* this should likely be removed, too */
+    IL2CPP_PROFILE_GC_MOVES         = 1 << 19,
+    IL2CPP_PROFILE_FILEIO           = 1 << 20
+} Il2CppProfileFlags;
+
+typedef enum
+{
+    IL2CPP_PROFILE_FILEIO_WRITE = 0,
+    IL2CPP_PROFILE_FILEIO_READ
+} Il2CppProfileFileIOKind;
+
+typedef enum
+{
+    IL2CPP_GC_EVENT_START,
+    IL2CPP_GC_EVENT_MARK_START,
+    IL2CPP_GC_EVENT_MARK_END,
+    IL2CPP_GC_EVENT_RECLAIM_START,
+    IL2CPP_GC_EVENT_RECLAIM_END,
+    IL2CPP_GC_EVENT_END,
+    IL2CPP_GC_EVENT_PRE_STOP_WORLD,
+    IL2CPP_GC_EVENT_POST_STOP_WORLD,
+    IL2CPP_GC_EVENT_PRE_START_WORLD,
+    IL2CPP_GC_EVENT_POST_START_WORLD
+} Il2CppGCEvent;
+
+typedef enum
+{
+    IL2CPP_STAT_NEW_OBJECT_COUNT,
+    IL2CPP_STAT_INITIALIZED_CLASS_COUNT,
+    //IL2CPP_STAT_GENERIC_VTABLE_COUNT,
+    //IL2CPP_STAT_USED_CLASS_COUNT,
+    IL2CPP_STAT_METHOD_COUNT,
+    //IL2CPP_STAT_CLASS_VTABLE_SIZE,
+    IL2CPP_STAT_CLASS_STATIC_DATA_SIZE,
+    IL2CPP_STAT_GENERIC_INSTANCE_COUNT,
+    IL2CPP_STAT_GENERIC_CLASS_COUNT,
+    IL2CPP_STAT_INFLATED_METHOD_COUNT,
+    IL2CPP_STAT_INFLATED_TYPE_COUNT,
+    //IL2CPP_STAT_DELEGATE_CREATIONS,
+    //IL2CPP_STAT_MINOR_GC_COUNT,
+    //IL2CPP_STAT_MAJOR_GC_COUNT,
+    //IL2CPP_STAT_MINOR_GC_TIME_USECS,
+    //IL2CPP_STAT_MAJOR_GC_TIME_USECS
+} Il2CppStat;
+
+typedef enum
+{
+    IL2CPP_UNHANDLED_POLICY_LEGACY,
+    IL2CPP_UNHANDLED_POLICY_CURRENT
+} Il2CppRuntimeUnhandledExceptionPolicy;
+
+typedef struct Il2CppStackFrameInfo
+{
+    const MethodInfo *method;
+} Il2CppStackFrameInfo;
+
+typedef struct
+{
+    void* (*malloc_func)(size_t size);
+    void* (*aligned_malloc_func)(size_t size, size_t alignment);
+    void (*free_func)(void *ptr);
+    void (*aligned_free_func)(void *ptr);
+    void* (*calloc_func)(size_t nmemb, size_t size);
+    void* (*realloc_func)(void *ptr, size_t size);
+    void* (*aligned_realloc_func)(void *ptr, size_t size, size_t alignment);
+} Il2CppMemoryCallbacks;
+
+#if !__SNC__ // SNC doesn't like the following define: "warning 1576: predefined meaning of __has_feature discarded"
+#ifndef __has_feature // clang specific __has_feature check
+#define __has_feature(x) 0 // Compatibility with non-clang compilers.
+#endif
+#endif
+
+#if _MSC_VER
+typedef wchar_t Il2CppChar;
+#elif __has_feature(cxx_unicode_literals)
+typedef char16_t Il2CppChar;
+#else
+typedef uint16_t Il2CppChar;
+#endif
+
+#if _MSC_VER
+typedef wchar_t Il2CppNativeChar;
+#define IL2CPP_NATIVE_STRING(str) L##str
+#else
+typedef char Il2CppNativeChar;
+#define IL2CPP_NATIVE_STRING(str) str
+#endif
+
+typedef void (*il2cpp_register_object_callback)(Il2CppObject** arr, int size, void* userdata);
+typedef void (*il2cpp_WorldChangedCallback)();
+typedef void (*Il2CppFrameWalkFunc) (const Il2CppStackFrameInfo *info, void *user_data);
+typedef void (*Il2CppProfileFunc) (Il2CppProfiler* prof);
+typedef void (*Il2CppProfileMethodFunc) (Il2CppProfiler* prof, const MethodInfo *method);
+typedef void (*Il2CppProfileAllocFunc) (Il2CppProfiler* prof, Il2CppObject *obj, Il2CppClass *klass);
+typedef void (*Il2CppProfileGCFunc) (Il2CppProfiler* prof, Il2CppGCEvent event, int generation);
+typedef void (*Il2CppProfileGCResizeFunc) (Il2CppProfiler* prof, int64_t new_size);
+typedef void (*Il2CppProfileFileIOFunc) (Il2CppProfiler* prof, Il2CppProfileFileIOKind kind, int count);
+typedef void (*Il2CppProfileThreadFunc) (Il2CppProfiler *prof, unsigned long tid);
+
+typedef const Il2CppNativeChar* (*Il2CppSetFindPlugInCallback)(const Il2CppNativeChar*);
+typedef void (*Il2CppLogCallback)(const char*);
+
+struct Il2CppManagedMemorySnapshot;
+
+typedef void (*Il2CppMethodPointer)();
+typedef uintptr_t il2cpp_array_size_t;
+#define ARRAY_LENGTH_AS_INT32(a) ((int32_t)a)

App/LearnWithTouch_ios/Libraries/libil2cpp/include/il2cpp-api.h

@@ -0,0 +1,30 @@
+#pragma once
+
+#include <stdint.h>
+
+#include "il2cpp-config-api.h"
+
+#if IL2CPP_API_DYNAMIC_NO_DLSYM
+#if defined(__cplusplus)
+extern "C"
+{
+#endif // __cplusplus
+IL2CPP_EXPORT void il2cpp_api_register_symbols(void);
+IL2CPP_EXPORT void* il2cpp_api_lookup_symbol(const char* name);
+#if defined(__cplusplus)
+}
+#endif // __cplusplus
+#endif
+
+#if defined(__cplusplus)
+extern "C"
+{
+#endif // __cplusplus
+#define DO_API(r, n, p)             IL2CPP_EXPORT r n p;
+#define DO_API_NO_RETURN(r, n, p)   IL2CPP_EXPORT NORETURN r n p;
+#include "il2cpp-api-functions.h"
+#undef DO_API
+#undef DO_API_NORETURN
+#if defined(__cplusplus)
+}
+#endif // __cplusplus

App/LearnWithTouch_ios/Libraries/libil2cpp/include/il2cpp-blob.h

@@ -0,0 +1,46 @@
+#pragma once
+
+// Corresponds to element type signatures
+// See ECMA-335, II.23.1.16
+
+typedef enum Il2CppTypeEnum
+{
+    IL2CPP_TYPE_END        = 0x00,       /* End of List */
+    IL2CPP_TYPE_VOID       = 0x01,
+    IL2CPP_TYPE_BOOLEAN    = 0x02,
+    IL2CPP_TYPE_CHAR       = 0x03,
+    IL2CPP_TYPE_I1         = 0x04,
+    IL2CPP_TYPE_U1         = 0x05,
+    IL2CPP_TYPE_I2         = 0x06,
+    IL2CPP_TYPE_U2         = 0x07,
+    IL2CPP_TYPE_I4         = 0x08,
+    IL2CPP_TYPE_U4         = 0x09,
+    IL2CPP_TYPE_I8         = 0x0a,
+    IL2CPP_TYPE_U8         = 0x0b,
+    IL2CPP_TYPE_R4         = 0x0c,
+    IL2CPP_TYPE_R8         = 0x0d,
+    IL2CPP_TYPE_STRING     = 0x0e,
+    IL2CPP_TYPE_PTR        = 0x0f,       /* arg: <type> token */
+    IL2CPP_TYPE_BYREF      = 0x10,       /* arg: <type> token */
+    IL2CPP_TYPE_VALUETYPE  = 0x11,       /* arg: <type> token */
+    IL2CPP_TYPE_CLASS      = 0x12,       /* arg: <type> token */
+    IL2CPP_TYPE_VAR        = 0x13,       /* Generic parameter in a generic type definition, represented as number (compressed unsigned integer) number */
+    IL2CPP_TYPE_ARRAY      = 0x14,       /* type, rank, boundsCount, bound1, loCount, lo1 */
+    IL2CPP_TYPE_GENERICINST = 0x15,     /* <type> <type-arg-count> <type-1> \x{2026} <type-n> */
+    IL2CPP_TYPE_TYPEDBYREF = 0x16,
+    IL2CPP_TYPE_I          = 0x18,
+    IL2CPP_TYPE_U          = 0x19,
+    IL2CPP_TYPE_FNPTR      = 0x1b,        /* arg: full method signature */
+    IL2CPP_TYPE_OBJECT     = 0x1c,
+    IL2CPP_TYPE_SZARRAY    = 0x1d,       /* 0-based one-dim-array */
+    IL2CPP_TYPE_MVAR       = 0x1e,       /* Generic parameter in a generic method definition, represented as number (compressed unsigned integer)  */
+    IL2CPP_TYPE_CMOD_REQD  = 0x1f,       /* arg: typedef or typeref token */
+    IL2CPP_TYPE_CMOD_OPT   = 0x20,       /* optional arg: typedef or typref token */
+    IL2CPP_TYPE_INTERNAL   = 0x21,       /* CLR internal type */
+
+    IL2CPP_TYPE_MODIFIER   = 0x40,       /* Or with the following types */
+    IL2CPP_TYPE_SENTINEL   = 0x41,       /* Sentinel for varargs method signature */
+    IL2CPP_TYPE_PINNED     = 0x45,       /* Local var that points to pinned object */
+
+    IL2CPP_TYPE_ENUM       = 0x55        /* an enumeration */
+} Il2CppTypeEnum;

App/LearnWithTouch_ios/Libraries/libil2cpp/include/il2cpp-class-internals.h

@@ -0,0 +1,741 @@
+#pragma once
+
+#include "il2cpp-config.h"
+#include <stdint.h>
+#include "il2cpp-runtime-metadata.h"
+#include "il2cpp-metadata.h"
+
+
+#define IL2CPP_CLASS_IS_ARRAY(c) ((c)->rank)
+
+typedef struct Il2CppClass Il2CppClass;
+typedef struct Il2CppGuid Il2CppGuid;
+typedef struct Il2CppImage Il2CppImage;
+typedef struct Il2CppAppDomain Il2CppAppDomain;
+typedef struct Il2CppAppDomainSetup Il2CppAppDomainSetup;
+typedef struct Il2CppDelegate Il2CppDelegate;
+typedef struct Il2CppAppContext Il2CppAppContext;
+typedef struct Il2CppNameToTypeDefinitionIndexHashTable Il2CppNameToTypeDefinitionIndexHashTable;
+
+#if RUNTIME_MONO
+extern "C"
+{
+#include <mono/metadata/metadata.h>
+}
+#endif
+
+typedef struct VirtualInvokeData
+{
+    Il2CppMethodPointer methodPtr;
+#if RUNTIME_MONO
+    const MonoMethod* method;
+#else
+    const MethodInfo* method;
+#endif
+} VirtualInvokeData;
+
+typedef enum Il2CppTypeNameFormat
+{
+    IL2CPP_TYPE_NAME_FORMAT_IL,
+    IL2CPP_TYPE_NAME_FORMAT_REFLECTION,
+    IL2CPP_TYPE_NAME_FORMAT_FULL_NAME,
+    IL2CPP_TYPE_NAME_FORMAT_ASSEMBLY_QUALIFIED
+} Il2CppTypeNameFormat;
+
+
+typedef struct Il2CppDefaults
+{
+    Il2CppImage *corlib;
+    Il2CppClass *object_class;
+    Il2CppClass *byte_class;
+    Il2CppClass *void_class;
+    Il2CppClass *boolean_class;
+    Il2CppClass *sbyte_class;
+    Il2CppClass *int16_class;
+    Il2CppClass *uint16_class;
+    Il2CppClass *int32_class;
+    Il2CppClass *uint32_class;
+    Il2CppClass *int_class;
+    Il2CppClass *uint_class;
+    Il2CppClass *int64_class;
+    Il2CppClass *uint64_class;
+    Il2CppClass *single_class;
+    Il2CppClass *double_class;
+    Il2CppClass *char_class;
+    Il2CppClass *string_class;
+    Il2CppClass *enum_class;
+    Il2CppClass *array_class;
+    Il2CppClass *delegate_class;
+    Il2CppClass *multicastdelegate_class;
+    Il2CppClass *asyncresult_class;
+    Il2CppClass *manualresetevent_class;
+    Il2CppClass *typehandle_class;
+    Il2CppClass *fieldhandle_class;
+    Il2CppClass *methodhandle_class;
+    Il2CppClass *systemtype_class;
+    Il2CppClass *monotype_class;
+    Il2CppClass *exception_class;
+    Il2CppClass *threadabortexception_class;
+    Il2CppClass *thread_class;
+#if NET_4_0
+    Il2CppClass *internal_thread_class;
+#endif
+    /*Il2CppClass *transparent_proxy_class;
+    Il2CppClass *real_proxy_class;
+    Il2CppClass *mono_method_message_class;*/
+    Il2CppClass *appdomain_class;
+    Il2CppClass *appdomain_setup_class;
+    Il2CppClass *field_info_class;
+    Il2CppClass *method_info_class;
+    Il2CppClass *property_info_class;
+    Il2CppClass *event_info_class;
+    Il2CppClass *mono_event_info_class;
+    Il2CppClass *stringbuilder_class;
+    /*Il2CppClass *math_class;*/
+    Il2CppClass *stack_frame_class;
+    Il2CppClass *stack_trace_class;
+    Il2CppClass *marshal_class;
+    /*Il2CppClass *iserializeable_class;
+    Il2CppClass *serializationinfo_class;
+    Il2CppClass *streamingcontext_class;*/
+    Il2CppClass *typed_reference_class;
+    /*Il2CppClass *argumenthandle_class;*/
+    Il2CppClass *marshalbyrefobject_class;
+    /*Il2CppClass *monitor_class;
+    Il2CppClass *iremotingtypeinfo_class;
+    Il2CppClass *runtimesecurityframe_class;
+    Il2CppClass *executioncontext_class;
+    Il2CppClass *internals_visible_class;*/
+    Il2CppClass *generic_ilist_class;
+    Il2CppClass *generic_icollection_class;
+    Il2CppClass *generic_ienumerable_class;
+#if NET_4_0
+    Il2CppClass *generic_ireadonlylist_class;
+    Il2CppClass *generic_ireadonlycollection_class;
+    Il2CppClass *runtimetype_class;
+#endif
+    Il2CppClass *generic_nullable_class;
+    /*Il2CppClass *variant_class;
+    Il2CppClass *com_object_class;*/
+    Il2CppClass *il2cpp_com_object_class;
+    /*Il2CppClass *com_interop_proxy_class;
+    Il2CppClass *iunknown_class;
+    Il2CppClass *idispatch_class;
+    Il2CppClass *safehandle_class;
+    Il2CppClass *handleref_class;*/
+    Il2CppClass *attribute_class;
+    Il2CppClass *customattribute_data_class;
+    //Il2CppClass *critical_finalizer_object;
+    Il2CppClass *version;
+    Il2CppClass *culture_info;
+    Il2CppClass *async_call_class;
+    Il2CppClass *assembly_class;
+#if NET_4_0
+    Il2CppClass *mono_assembly_class;
+#endif
+    Il2CppClass *assembly_name_class;
+#if !NET_4_0
+    Il2CppClass *enum_info_class;
+#endif
+    Il2CppClass *mono_field_class;
+    Il2CppClass *mono_method_class;
+    Il2CppClass *mono_method_info_class;
+    Il2CppClass *mono_property_info_class;
+    Il2CppClass *parameter_info_class;
+#if NET_4_0
+    Il2CppClass *mono_parameter_info_class;
+#endif
+    Il2CppClass *module_class;
+    Il2CppClass *pointer_class;
+    Il2CppClass *system_exception_class;
+    Il2CppClass *argument_exception_class;
+    Il2CppClass *wait_handle_class;
+    Il2CppClass *safe_handle_class;
+    Il2CppClass *sort_key_class;
+    Il2CppClass *dbnull_class;
+    Il2CppClass *error_wrapper_class;
+    Il2CppClass *missing_class;
+    Il2CppClass *value_type_class;
+
+#if NET_4_0
+    // Stuff used by the mono code
+    Il2CppClass *threadpool_wait_callback_class;
+    MethodInfo *threadpool_perform_wait_callback_method;
+    Il2CppClass *mono_method_message_class;
+#endif
+
+    // Windows.Foundation.IReference`1<T>
+    Il2CppClass* ireference_class;
+    // Windows.Foundation.IReferenceArray`1<T>
+    Il2CppClass* ireferencearray_class;
+    // Windows.Foundation.Collections.IKeyValuePair`2<K, V>
+    Il2CppClass* ikey_value_pair_class;
+    // System.Collections.Generic.KeyValuePair`2<K, V>
+    Il2CppClass* key_value_pair_class;
+    // Windows.Foundation.Uri
+    Il2CppClass* windows_foundation_uri_class;
+    // Windows.Foundation.IUriRuntimeClass
+    Il2CppClass* windows_foundation_iuri_runtime_class_class;
+    // System.Uri
+    Il2CppClass* system_uri_class;
+    // System.Guid
+    Il2CppClass* system_guid_class;
+
+#if NET_4_0
+    Il2CppClass* sbyte_shared_enum;
+    Il2CppClass* int16_shared_enum;
+    Il2CppClass* int32_shared_enum;
+    Il2CppClass* int64_shared_enum;
+
+    Il2CppClass* byte_shared_enum;
+    Il2CppClass* uint16_shared_enum;
+    Il2CppClass* uint32_shared_enum;
+    Il2CppClass* uint64_shared_enum;
+#endif
+} Il2CppDefaults;
+
+extern LIBIL2CPP_CODEGEN_API Il2CppDefaults il2cpp_defaults;
+
+struct Il2CppClass;
+struct MethodInfo;
+struct FieldInfo;
+struct Il2CppObject;
+struct MemberInfo;
+
+typedef struct CustomAttributesCache
+{
+    int count;
+    Il2CppObject** attributes;
+} CustomAttributesCache;
+
+typedef void (*CustomAttributesCacheGenerator)(CustomAttributesCache*);
+
+const int THREAD_STATIC_FIELD_OFFSET = -1;
+
+typedef struct FieldInfo
+{
+    const char* name;
+    const Il2CppType* type;
+    Il2CppClass *parent;
+    int32_t offset; // If offset is -1, then it's thread static
+    uint32_t token;
+} FieldInfo;
+
+typedef struct PropertyInfo
+{
+    Il2CppClass *parent;
+    const char *name;
+    const MethodInfo *get;
+    const MethodInfo *set;
+    uint32_t attrs;
+    uint32_t token;
+} PropertyInfo;
+
+typedef struct EventInfo
+{
+    const char* name;
+    const Il2CppType* eventType;
+    Il2CppClass* parent;
+    const MethodInfo* add;
+    const MethodInfo* remove;
+    const MethodInfo* raise;
+    uint32_t token;
+} EventInfo;
+
+typedef struct ParameterInfo
+{
+    const char* name;
+    int32_t position;
+    uint32_t token;
+    const Il2CppType* parameter_type;
+} ParameterInfo;
+
+#if RUNTIME_MONO
+typedef void* (*InvokerMethod)(Il2CppMethodPointer, const MonoMethod*, void*, void**);
+#else
+typedef void* (*InvokerMethod)(Il2CppMethodPointer, const MethodInfo*, void*, void**);
+#endif
+
+typedef enum MethodVariableKind
+{
+    kMethodVariableKind_This,
+    kMethodVariableKind_Parameter,
+    kMethodVariableKind_LocalVariable
+} MethodVariableKind;
+
+typedef enum SequencePointKind
+{
+    kSequencePointKind_Normal,
+    kSequencePointKind_StepOut
+} SequencePointKind;
+
+typedef struct Il2CppMethodExecutionContextInfo
+{
+    TypeIndex typeIndex;
+    int32_t nameIndex;
+    int32_t scopeIndex;
+} Il2CppMethodExecutionContextInfo;
+
+typedef struct Il2CppMethodExecutionContextInfoIndex
+{
+    int8_t tableIndex;
+    int32_t startIndex;
+    int32_t count;
+} Il2CppMethodExecutionContextInfoIndex;
+
+typedef struct Il2CppMethodScope
+{
+    int32_t startOffset;
+    int32_t endOffset;
+} Il2CppMethodScope;
+
+typedef struct Il2CppMethodHeaderInfo
+{
+    int32_t codeSize;
+    int32_t startScope;
+    int32_t numScopes;
+} Il2CppMethodHeaderInfo;
+
+typedef struct Il2CppSequencePointIndex
+{
+    uint8_t tableIndex;
+    int32_t index;
+} Il2CppSequencePointIndex;
+
+typedef struct Il2CppSequencePointSourceFile
+{
+    const char *file;
+    uint8_t hash[16];
+} Il2CppSequencePointSourceFile;
+
+typedef struct Il2CppTypeSourceFilePair
+{
+    TypeIndex klassIndex;
+    int32_t sourceFileIndex;
+} Il2CppTypeSourceFilePair;
+
+typedef struct Il2CppSequencePoint
+{
+    MethodIndex methodDefinitionIndex;
+    TypeIndex catchTypeIndex;
+    int32_t sourceFileIndex;
+    int32_t lineStart, lineEnd;
+    int32_t columnStart, columnEnd;
+    int32_t ilOffset;
+    SequencePointKind kind;
+    uint8_t isActive;
+    int32_t id;
+    uint8_t tryDepth;
+} Il2CppSequencePoint;
+
+typedef struct Il2CppDebuggerMetadataRegistration
+{
+    Il2CppMethodExecutionContextInfo** methodExecutionContextInfos;
+    Il2CppMethodExecutionContextInfoIndex* methodExecutionContextInfoIndexes;
+    Il2CppMethodScope* methodScopes;
+    Il2CppMethodHeaderInfo* methodHeaderInfos;
+    Il2CppSequencePointSourceFile* sequencePointSourceFiles;
+    int32_t numSequencePoints;
+    Il2CppSequencePointIndex* sequencePointIndexes;
+    Il2CppSequencePoint** sequencePoints;
+    int32_t numTypeSourceFileEntries;
+    Il2CppTypeSourceFilePair* typeSourceFiles;
+    const char** methodExecutionContextInfoStrings;
+} Il2CppDebuggerMetadataRegistration;
+
+typedef union Il2CppRGCTXData
+{
+    void* rgctxDataDummy;
+    const MethodInfo* method;
+    const Il2CppType* type;
+    Il2CppClass* klass;
+} Il2CppRGCTXData;
+
+typedef struct MethodInfo
+{
+    Il2CppMethodPointer methodPointer;
+    InvokerMethod invoker_method;
+    const char* name;
+    Il2CppClass *klass;
+    const Il2CppType *return_type;
+    const ParameterInfo* parameters;
+
+    union
+    {
+        const Il2CppRGCTXData* rgctx_data; /* is_inflated is true and is_generic is false, i.e. a generic instance method */
+        const Il2CppMethodDefinition* methodDefinition;
+    };
+
+    /* note, when is_generic == true and is_inflated == true the method represents an uninflated generic method on an inflated type. */
+    union
+    {
+        const Il2CppGenericMethod* genericMethod; /* is_inflated is true */
+        const Il2CppGenericContainer* genericContainer; /* is_inflated is false and is_generic is true */
+    };
+
+    uint32_t token;
+    uint16_t flags;
+    uint16_t iflags;
+    uint16_t slot;
+    uint8_t parameters_count;
+    uint8_t is_generic : 1; /* true if method is a generic method definition */
+    uint8_t is_inflated : 1; /* true if declaring_type is a generic instance or if method is a generic instance*/
+    uint8_t wrapper_type : 1; /* always zero (MONO_WRAPPER_NONE) needed for the debugger */
+    uint8_t is_marshaled_from_native : 1; /* a fake MethodInfo wrapping a native function pointer */
+} MethodInfo;
+
+typedef struct Il2CppRuntimeInterfaceOffsetPair
+{
+    Il2CppClass* interfaceType;
+    int32_t offset;
+} Il2CppRuntimeInterfaceOffsetPair;
+
+typedef void (*PInvokeMarshalToNativeFunc)(void* managedStructure, void* marshaledStructure);
+typedef void (*PInvokeMarshalFromNativeFunc)(void* marshaledStructure, void* managedStructure);
+typedef void (*PInvokeMarshalCleanupFunc)(void* marshaledStructure);
+typedef struct Il2CppIUnknown* (*CreateCCWFunc)(Il2CppObject* obj);
+
+#if RUNTIME_MONO
+#include "il2cpp-mapping.h"
+#endif
+
+typedef struct Il2CppInteropData
+{
+    Il2CppMethodPointer delegatePInvokeWrapperFunction;
+    PInvokeMarshalToNativeFunc pinvokeMarshalToNativeFunction;
+    PInvokeMarshalFromNativeFunc pinvokeMarshalFromNativeFunction;
+    PInvokeMarshalCleanupFunc pinvokeMarshalCleanupFunction;
+    CreateCCWFunc createCCWFunction;
+    const Il2CppGuid* guid;
+#if RUNTIME_MONO
+    MonoMetadataToken typeToken;
+    uint64_t hash;
+#else
+    const Il2CppType* type;
+#endif
+} Il2CppInteropData;
+
+#if IL2CPP_COMPILER_MSVC
+#pragma warning( push )
+#pragma warning( disable : 4200 )
+#elif defined(__clang__)
+#pragma clang diagnostic push
+#pragma clang diagnostic ignored "-Winvalid-offsetof"
+#endif
+
+typedef struct Il2CppClass
+{
+    // The following fields are always valid for a Il2CppClass structure
+    const Il2CppImage* image;
+    void* gc_desc;
+    const char* name;
+    const char* namespaze;
+    Il2CppType byval_arg;
+    Il2CppType this_arg;
+    Il2CppClass* element_class;
+    Il2CppClass* castClass;
+    Il2CppClass* declaringType;
+    Il2CppClass* parent;
+    Il2CppGenericClass *generic_class;
+    const Il2CppTypeDefinition* typeDefinition; // non-NULL for Il2CppClass's constructed from type defintions
+    const Il2CppInteropData* interopData;
+    Il2CppClass* klass; // hack to pretend we are a MonoVTable. Points to ourself
+    // End always valid fields
+
+    // The following fields need initialized before access. This can be done per field or as an aggregate via a call to Class::Init
+    FieldInfo* fields; // Initialized in SetupFields
+    const EventInfo* events; // Initialized in SetupEvents
+    const PropertyInfo* properties; // Initialized in SetupProperties
+    const MethodInfo** methods; // Initialized in SetupMethods
+    Il2CppClass** nestedTypes; // Initialized in SetupNestedTypes
+    Il2CppClass** implementedInterfaces; // Initialized in SetupInterfaces
+    Il2CppRuntimeInterfaceOffsetPair* interfaceOffsets; // Initialized in Init
+    void* static_fields; // Initialized in Init
+    const Il2CppRGCTXData* rgctx_data; // Initialized in Init
+    // used for fast parent checks
+    Il2CppClass** typeHierarchy; // Initialized in SetupTypeHierachy
+    // End initialization required fields
+
+    uint32_t initializationExceptionGCHandle;
+
+    uint32_t cctor_started;
+    uint32_t cctor_finished;
+    ALIGN_TYPE(8) uint64_t cctor_thread;
+
+    // Remaining fields are always valid except where noted
+    GenericContainerIndex genericContainerIndex;
+    uint32_t instance_size;
+    uint32_t actualSize;
+    uint32_t element_size;
+    int32_t native_size;
+    uint32_t static_fields_size;
+    uint32_t thread_static_fields_size;
+    int32_t thread_static_fields_offset;
+    uint32_t flags;
+    uint32_t token;
+
+    uint16_t method_count; // lazily calculated for arrays, i.e. when rank > 0
+    uint16_t property_count;
+    uint16_t field_count;
+    uint16_t event_count;
+    uint16_t nested_type_count;
+    uint16_t vtable_count; // lazily calculated for arrays, i.e. when rank > 0
+    uint16_t interfaces_count;
+    uint16_t interface_offsets_count; // lazily calculated for arrays, i.e. when rank > 0
+
+    uint8_t typeHierarchyDepth; // Initialized in SetupTypeHierachy
+    uint8_t genericRecursionDepth;
+    uint8_t rank;
+    uint8_t minimumAlignment;
+    uint8_t packingSize;
+
+    // this is critical for performance of Class::InitFromCodegen. Equals to initialized && !has_initialization_error at all times.
+    // Use Class::UpdateInitializedAndNoError to update
+    uint8_t initialized_and_no_error : 1;
+
+    uint8_t valuetype : 1;
+    uint8_t initialized : 1;
+    uint8_t enumtype : 1;
+    uint8_t is_generic : 1;
+    uint8_t has_references : 1;
+    uint8_t init_pending : 1;
+    uint8_t size_inited : 1;
+    uint8_t has_finalize : 1;
+    uint8_t has_cctor : 1;
+    uint8_t is_blittable : 1;
+    uint8_t is_import_or_windows_runtime : 1;
+    uint8_t is_vtable_initialized : 1;
+    uint8_t has_initialization_error : 1;
+    VirtualInvokeData vtable[IL2CPP_ZERO_LEN_ARRAY];
+} Il2CppClass;
+
+#if IL2CPP_COMPILER_MSVC
+#pragma warning( pop )
+#elif defined(__clang__)
+#pragma clang diagnostic pop
+#endif
+
+// compiler calcualted values
+typedef struct Il2CppTypeDefinitionSizes
+{
+    uint32_t instance_size;
+    int32_t native_size;
+    uint32_t static_fields_size;
+    uint32_t thread_static_fields_size;
+} Il2CppTypeDefinitionSizes;
+
+typedef struct Il2CppDomain
+{
+    Il2CppAppDomain* domain;
+    Il2CppAppDomainSetup* setup;
+    Il2CppAppContext* default_context;
+    const char* friendly_name;
+    uint32_t domain_id;
+
+#if NET_4_0
+    volatile int threadpool_jobs;
+#endif
+    void* agent_info;
+} Il2CppDomain;
+
+typedef struct Il2CppAssemblyName
+{
+    const char* name;
+    const char* culture;
+    const char* hash_value;
+    const char* public_key;
+    uint32_t hash_alg;
+    int32_t hash_len;
+    uint32_t flags;
+    int32_t major;
+    int32_t minor;
+    int32_t build;
+    int32_t revision;
+    uint8_t public_key_token[PUBLIC_KEY_BYTE_LENGTH];
+} Il2CppAssemblyName;
+
+typedef struct Il2CppImage
+{
+    const char* name;
+    const char *nameNoExt;
+    Il2CppAssembly* assembly;
+
+    TypeDefinitionIndex typeStart;
+    uint32_t typeCount;
+
+    TypeDefinitionIndex exportedTypeStart;
+    uint32_t exportedTypeCount;
+
+    CustomAttributeIndex customAttributeStart;
+    uint32_t customAttributeCount;
+
+    MethodIndex entryPointIndex;
+
+#ifdef __cplusplus
+    mutable
+#endif
+    Il2CppNameToTypeDefinitionIndexHashTable * nameToClassHashTable;
+
+    uint32_t token;
+    uint8_t dynamic;
+} Il2CppImage;
+
+typedef struct Il2CppAssembly
+{
+    Il2CppImage* image;
+    uint32_t token;
+    int32_t referencedAssemblyStart;
+    int32_t referencedAssemblyCount;
+    Il2CppAssemblyName aname;
+} Il2CppAssembly;
+
+typedef struct Il2CppCodeGenOptions
+{
+    bool enablePrimitiveValueTypeGenericSharing;
+} Il2CppCodeGenOptions;
+
+typedef struct Il2CppCodeRegistration
+{
+    uint32_t methodPointersCount;
+    const Il2CppMethodPointer* methodPointers;
+    uint32_t reversePInvokeWrapperCount;
+    const Il2CppMethodPointer* reversePInvokeWrappers;
+    uint32_t genericMethodPointersCount;
+    const Il2CppMethodPointer* genericMethodPointers;
+    uint32_t invokerPointersCount;
+    const InvokerMethod* invokerPointers;
+    CustomAttributeIndex customAttributeCount;
+    const CustomAttributesCacheGenerator* customAttributeGenerators;
+    uint32_t unresolvedVirtualCallCount;
+    const Il2CppMethodPointer* unresolvedVirtualCallPointers;
+    uint32_t interopDataCount;
+    Il2CppInteropData* interopData;
+} Il2CppCodeRegistration;
+
+typedef struct Il2CppMetadataRegistration
+{
+    int32_t genericClassesCount;
+    Il2CppGenericClass* const * genericClasses;
+    int32_t genericInstsCount;
+    const Il2CppGenericInst* const * genericInsts;
+    int32_t genericMethodTableCount;
+    const Il2CppGenericMethodFunctionsDefinitions* genericMethodTable;
+    int32_t typesCount;
+    const Il2CppType* const * types;
+    int32_t methodSpecsCount;
+    const Il2CppMethodSpec* methodSpecs;
+
+    FieldIndex fieldOffsetsCount;
+    const int32_t** fieldOffsets;
+
+    TypeDefinitionIndex typeDefinitionsSizesCount;
+    const Il2CppTypeDefinitionSizes** typeDefinitionsSizes;
+    const size_t metadataUsagesCount;
+    void** const* metadataUsages;
+} Il2CppMetadataRegistration;
+
+typedef struct Il2CppRuntimeStats
+{
+    uint64_t new_object_count;
+    uint64_t initialized_class_count;
+    // uint64_t generic_vtable_count;
+    // uint64_t used_class_count;
+    uint64_t method_count;
+    // uint64_t class_vtable_size;
+    uint64_t class_static_data_size;
+    uint64_t generic_instance_count;
+    uint64_t generic_class_count;
+    uint64_t inflated_method_count;
+    uint64_t inflated_type_count;
+    // uint64_t delegate_creations;
+    // uint64_t minor_gc_count;
+    // uint64_t major_gc_count;
+    // uint64_t minor_gc_time_usecs;
+    // uint64_t major_gc_time_usecs;
+    bool enabled;
+} Il2CppRuntimeStats;
+
+extern Il2CppRuntimeStats il2cpp_runtime_stats;
+
+/*
+* new structure to hold performance counters values that are exported
+* to managed code.
+* Note: never remove fields from this structure and only add them to the end.
+* Size of fields and type should not be changed as well.
+*/
+typedef struct Il2CppPerfCounters
+{
+    /* JIT category */
+    uint32_t jit_methods;
+    uint32_t jit_bytes;
+    uint32_t jit_time;
+    uint32_t jit_failures;
+    /* Exceptions category */
+    uint32_t exceptions_thrown;
+    uint32_t exceptions_filters;
+    uint32_t exceptions_finallys;
+    uint32_t exceptions_depth;
+    uint32_t aspnet_requests_queued;
+    uint32_t aspnet_requests;
+    /* Memory category */
+    uint32_t gc_collections0;
+    uint32_t gc_collections1;
+    uint32_t gc_collections2;
+    uint32_t gc_promotions0;
+    uint32_t gc_promotions1;
+    uint32_t gc_promotion_finalizers;
+    uint32_t gc_gen0size;
+    uint32_t gc_gen1size;
+    uint32_t gc_gen2size;
+    uint32_t gc_lossize;
+    uint32_t gc_fin_survivors;
+    uint32_t gc_num_handles;
+    uint32_t gc_allocated;
+    uint32_t gc_induced;
+    uint32_t gc_time;
+    uint32_t gc_total_bytes;
+    uint32_t gc_committed_bytes;
+    uint32_t gc_reserved_bytes;
+    uint32_t gc_num_pinned;
+    uint32_t gc_sync_blocks;
+    /* Remoting category */
+    uint32_t remoting_calls;
+    uint32_t remoting_channels;
+    uint32_t remoting_proxies;
+    uint32_t remoting_classes;
+    uint32_t remoting_objects;
+    uint32_t remoting_contexts;
+    /* Loader category */
+    uint32_t loader_classes;
+    uint32_t loader_total_classes;
+    uint32_t loader_appdomains;
+    uint32_t loader_total_appdomains;
+    uint32_t loader_assemblies;
+    uint32_t loader_total_assemblies;
+    uint32_t loader_failures;
+    uint32_t loader_bytes;
+    uint32_t loader_appdomains_uloaded;
+    /* Threads and Locks category  */
+    uint32_t thread_contentions;
+    uint32_t thread_queue_len;
+    uint32_t thread_queue_max;
+    uint32_t thread_num_logical;
+    uint32_t thread_num_physical;
+    uint32_t thread_cur_recognized;
+    uint32_t thread_num_recognized;
+    /* Interop category */
+    uint32_t interop_num_ccw;
+    uint32_t interop_num_stubs;
+    uint32_t interop_num_marshals;
+    /* Security category */
+    uint32_t security_num_checks;
+    uint32_t security_num_link_checks;
+    uint32_t security_time;
+    uint32_t security_depth;
+    uint32_t unused;
+    /* Threadpool */
+    uint64_t threadpool_workitems;
+    uint64_t threadpool_ioworkitems;
+    unsigned int threadpool_threads;
+    unsigned int threadpool_iothreads;
+} Il2CppPerfCounters;

App/LearnWithTouch_ios/Libraries/libil2cpp/include/il2cpp-config-api.h

@@ -0,0 +1,29 @@
+#pragma once
+
+#include "os/c-api/il2cpp-config-platforms.h"
+#include "os/c-api/il2cpp-config-api-platforms.h"
+#include "il2cpp-api-types.h"
+
+// If the platform loads il2cpp as a dynamic library but does not have dlsym (or equivalent) then
+// define IL2CPP_API_DYNAMIC_NO_DLSYM = 1 to add support for api function registration and symbol
+// lookup APIs, see il2cpp-api.cpp
+#ifndef IL2CPP_API_DYNAMIC_NO_DLSYM
+#define IL2CPP_API_DYNAMIC_NO_DLSYM 0
+#endif
+
+/* Profiler */
+#ifndef IL2CPP_ENABLE_PROFILER
+#define IL2CPP_ENABLE_PROFILER 1
+#endif
+
+#if IL2CPP_COMPILER_MSVC || defined(__ARMCC_VERSION)
+#define NORETURN __declspec(noreturn)
+#else
+#define NORETURN
+#endif
+
+#if IL2CPP_TARGET_IOS || IL2CPP_TARGET_ANDROID || IL2CPP_TARGET_DARWIN
+#define REAL_NORETURN __attribute__ ((noreturn))
+#else
+#define REAL_NORETURN NORETURN
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/il2cpp-config.h

@@ -0,0 +1,475 @@
+#pragma once
+
+#include <assert.h>
+#include <stddef.h>
+#include <stdlib.h>
+#include <stdio.h>
+#include <string.h>
+#include <stdint.h>
+
+/* first setup platform defines*/
+#include "os/c-api/il2cpp-config-platforms.h"
+#include "os/c-api/il2cpp-config-api-platforms.h"
+
+/* il2cpp-config-api.h need this define */
+#define IL2CPP_COMPILER_MSVC (IL2CPP_TARGET_WINDOWS || IL2CPP_TARGET_XBOXONE)
+
+#include "il2cpp-config-api.h"
+
+#ifndef IL2CPP_EXCEPTION_DISABLED
+#define IL2CPP_EXCEPTION_DISABLED 0
+#endif
+
+#ifdef LIBIL2CPP_EXPORT_CODEGEN_API
+# define LIBIL2CPP_CODEGEN_API IL2CPP_EXPORT
+#elif LIBIL2CPP_IMPORT_CODEGEN_API
+# define LIBIL2CPP_CODEGEN_API IL2CPP_IMPORT
+#else
+# define LIBIL2CPP_CODEGEN_API
+#endif
+
+#if defined(__ARMCC_VERSION)
+    #include <assert.h>
+    #include <wchar.h>
+    #include <ctype.h>
+    #define INTPTR_MAX 2147483647
+#endif
+
+#ifndef IL2CPP_METHOD_ATTR
+#define IL2CPP_METHOD_ATTR
+#endif
+
+#if defined(_MSC_VER)
+#define IL2CPP_CXX_ABI_MSVC 1
+#else
+#define IL2CPP_CXX_ABI_MSVC 0
+#endif
+
+#if IL2CPP_COMPILER_MSVC
+#ifndef STDCALL
+#define STDCALL __stdcall
+#endif
+#ifndef CDECL
+#define CDECL __cdecl
+#endif
+#ifndef FASTCALL
+#define FASTCALL __fastcall
+#endif
+#ifndef THISCALL
+#define THISCALL __thiscall
+#endif
+#else
+#define STDCALL
+#define CDECL
+#define FASTCALL
+#define THISCALL
+#endif
+
+#if IL2CPP_COMPILER_MSVC || defined(__ARMCC_VERSION)
+#define IL2CPP_NO_INLINE __declspec(noinline)
+#else
+#define IL2CPP_NO_INLINE __attribute__ ((noinline))
+#endif
+
+#if IL2CPP_COMPILER_MSVC
+#define NOVTABLE __declspec(novtable)
+#else
+#define NOVTABLE
+#endif
+
+#define IL2CPP_ENABLE_MONO_BUG_EMULATION 1
+
+// We currently use ALIGN_TYPE just for types decorated with IL2CPPStructAlignment, as it's needed for WebGL to properly align UnityEngine.Color.
+// On MSVC, it causes build issues on x86 since you cannot pass aligned type by value as an argument to a function:
+// error C2719: 'value': formal parameter with requested alignment of 16 won't be aligned
+// Since this isn't actually needed for Windows, and it's not a standard .NET feature but just IL2CPP extension, let's just turn it off on Windows
+#if defined(__GNUC__) || defined(__SNC__) || defined(__clang__)
+    #define ALIGN_OF(T) __alignof__(T)
+    #define ALIGN_TYPE(val) __attribute__((aligned(val)))
+    #define ALIGN_FIELD(val) ALIGN_TYPE(val)
+    #define FORCE_INLINE inline __attribute__ ((always_inline))
+#elif defined(_MSC_VER)
+    #define ALIGN_OF(T) __alignof(T)
+    #define ALIGN_TYPE(val)
+    #define ALIGN_FIELD(val) __declspec(align(val))
+    #define FORCE_INLINE __forceinline
+#else
+    #define ALIGN_TYPE(size)
+    #define ALIGN_FIELD(size)
+    #define FORCE_INLINE inline
+#endif
+
+#define IL2CPP_PAGE_SIZE 4096
+
+// 64-bit types are aligned to 8 bytes on 64-bit platforms and always on Windows
+#define IL2CPP_ENABLE_INTERLOCKED_64_REQUIRED_ALIGNMENT ((IL2CPP_SIZEOF_VOID_P == 8) || (IL2CPP_TARGET_WINDOWS))
+
+/* Debugging */
+#ifndef IL2CPP_DEBUG
+#define IL2CPP_DEBUG 0
+#endif
+
+#ifndef IL2CPP_DEVELOPMENT
+#define IL2CPP_DEVELOPMENT 0
+#endif
+
+#define IL2CPP_THREADS_ALL_ACCESS (!IL2CPP_THREADS_STD && IL2CPP_TARGET_XBOXONE)
+
+#if (IL2CPP_SUPPORT_THREADS && (!IL2CPP_THREADS_STD && !IL2CPP_THREADS_PTHREAD && !IL2CPP_THREADS_WIN32 && !IL2CPP_THREADS_XBOXONE && !IL2CPP_THREADS_N3DS && !IL2CPP_THREADS_PS4 && !IL2CPP_THREADS_PSP2 && !IL2CPP_THREADS_SWITCH))
+#error "No thread implementation defined"
+#endif
+
+/* Platform support to cleanup attached threads even when native threads are not exited cleanly */
+#define IL2CPP_HAS_NATIVE_THREAD_CLEANUP (IL2CPP_THREADS_PTHREAD || IL2CPP_THREADS_WIN32)
+
+#define IL2CPP_THREAD_IMPL_HAS_COM_APARTMENTS IL2CPP_TARGET_WINDOWS
+
+#if !defined(IL2CPP_ENABLE_PLATFORM_THREAD_STACKSIZE) && IL2CPP_TARGET_IOS
+#define IL2CPP_ENABLE_PLATFORM_THREAD_STACKSIZE 1
+#endif
+
+#define IL2CPP_ENABLE_STACKTRACES 1
+/* Platforms which use OS specific implementation to extract stracktrace */
+#if !defined(IL2CPP_ENABLE_NATIVE_STACKTRACES)
+#define IL2CPP_ENABLE_NATIVE_STACKTRACES (IL2CPP_TARGET_WINDOWS || IL2CPP_TARGET_LINUX || IL2CPP_TARGET_DARWIN || IL2CPP_TARGET_IOS || IL2CPP_TARGET_ANDROID || IL2CPP_TARGET_NOVA)
+#endif
+
+/* Platforms which use stacktrace sentries */
+#define IL2CPP_ENABLE_STACKTRACE_SENTRIES (IL2CPP_TARGET_JAVASCRIPT || IL2CPP_TARGET_N3DS || IL2CPP_TARGET_SWITCH)
+
+#if (IL2CPP_ENABLE_STACKTRACES && !IL2CPP_ENABLE_NATIVE_STACKTRACES && !IL2CPP_ENABLE_STACKTRACE_SENTRIES)
+#error "If stacktraces are supported, then either native stack traces must be supported, or usage of stacktrace sentries must be enabled!"
+#endif
+
+#if (IL2CPP_ENABLE_NATIVE_STACKTRACES + IL2CPP_ENABLE_STACKTRACE_SENTRIES) > 1
+#error "Only one type of stacktraces are allowed"
+#endif
+
+#define IL2CPP_CAN_USE_MULTIPLE_SYMBOL_MAPS IL2CPP_TARGET_IOS
+
+/* GC defines*/
+#define IL2CPP_GC_BOEHM 1
+#define IL2CPP_GC_NULL !IL2CPP_GC_BOEHM
+#define IL2CPP_ENABLE_DEFERRED_GC   IL2CPP_TARGET_JAVASCRIPT
+
+/* we always need to NULL pointer free memory with our current allocators */
+#define NEED_TO_ZERO_PTRFREE 1
+#define IL2CPP_HAS_GC_DESCRIPTORS 1
+
+#if defined(_MSC_VER)
+    #define IL2CPP_ZERO_LEN_ARRAY 0
+#else
+    #define IL2CPP_ZERO_LEN_ARRAY 0
+#endif
+
+#if defined(_MSC_VER)
+    #define IL2CPP_HAS_CXX_CONSTEXPR (_MSC_VER >= 1900)
+#else
+    #define IL2CPP_HAS_CXX_CONSTEXPR (__has_feature (cxx_constexpr))
+#endif
+
+/* clang specific __has_builtin check */
+#ifndef __has_builtin
+    #define __has_builtin(x) 0 // Compatibility with non-clang compilers.
+#endif
+
+#if _MSC_VER
+#define IL2CPP_UNREACHABLE __assume(0)
+#elif __has_builtin(__builtin_unreachable)
+#define IL2CPP_UNREACHABLE __builtin_unreachable()
+#else
+#define IL2CPP_UNREACHABLE
+#endif
+
+typedef uint32_t Il2CppMethodSlot;
+const uint32_t kInvalidIl2CppMethodSlot = 65535;
+
+/* Debug macros */
+#define STRINGIZE(L)          #L
+#define MAKE_STRING(M, L)     M(L)
+#define $Line                   MAKE_STRING( STRINGIZE, __LINE__ )
+#define FIXME                   __FILE__ "(" $Line ") : FIXME: "
+#define ICALLMESSAGE(name)      __FILE__ "(" $Line ") : FIXME: Missing internal call implementation: " name
+#define RUNTIMEMESSAGE(name)    __FILE__ "(" $Line ") : FIXME: Missing runtime implementation: " name
+#define NOTSUPPORTEDICALLMESSAGE(target, name, reason)  __FILE__ "(" $Line ") : Unsupported internal call for " target ":" name " - " reason
+
+// Keeping this for future usage if needed.
+//#if defined(_MSC_VER)
+//  #define PRAGMA_MESSAGE(value) __pragma(message(value))
+//#else
+//  #define PRAGMA_MESSAGE(value) _Pragma(STRINGIZE(value))
+//#endif
+#define PRAGMA_MESSAGE(value)
+
+#if !defined(EMSCRIPTEN)
+
+#define IL2CPP_NOT_IMPLEMENTED_ICALL(func) \
+    PRAGMA_MESSAGE(ICALLMESSAGE(#func)) \
+    IL2CPP_ASSERT(0 && #func)
+#define IL2CPP_NOT_IMPLEMENTED_ICALL_NO_ASSERT(func, reason) \
+    PRAGMA_MESSAGE(ICALLMESSAGE(#func))
+
+#define IL2CPP_NOT_IMPLEMENTED(func) \
+    PRAGMA_MESSAGE(RUNTIMEMESSAGE(#func)) \
+    IL2CPP_ASSERT(0 && #func)
+#define IL2CPP_NOT_IMPLEMENTED_NO_ASSERT(func, reason) \
+    PRAGMA_MESSAGE(RUNTIMEMESSAGE(#func))
+
+#else
+
+// emscripten's assert will throw an exception in js.
+// For now, we don't want that, so just printf and move on.
+    #define IL2CPP_NOT_IMPLEMENTED_ICALL(func) \
+    PRAGMA_MESSAGE(message(ICALLMESSAGE(#func))) \
+    printf("Not implemented icall: %s\n", #func);
+#define IL2CPP_NOT_IMPLEMENTED_ICALL_NO_ASSERT(func, reason) \
+    PRAGMA_MESSAGE(message(ICALLMESSAGE(#func)))
+
+#define IL2CPP_NOT_IMPLEMENTED(func) \
+    PRAGMA_MESSAGE(message(RUNTIMEMESSAGE(#func))) \
+    printf("Not implemented: %s\n", #func);
+#define IL2CPP_NOT_IMPLEMENTED_NO_ASSERT(func, reason) \
+    PRAGMA_MESSAGE(message(RUNTIMEMESSAGE(#func)))
+
+#endif
+
+#define NOT_SUPPORTED_IL2CPP(func, reason) \
+    il2cpp::vm::Exception::Raise (il2cpp::vm::Exception::GetNotSupportedException ( NOTSUPPORTEDICALLMESSAGE ("IL2CPP", #func, #reason) ))
+
+#define NOT_SUPPORTED_SRE(func) \
+    il2cpp::vm::Exception::Raise (il2cpp::vm::Exception::GetNotSupportedException ( NOTSUPPORTEDICALLMESSAGE ("IL2CPP", #func, "System.Reflection.Emit is not supported.") ))
+
+#define NOT_SUPPORTED_REMOTING(func) \
+    il2cpp::vm::Exception::Raise (il2cpp::vm::Exception::GetNotSupportedException ( NOTSUPPORTEDICALLMESSAGE ("IL2CPP", #func, "System.Runtime.Remoting is not supported.") ))
+
+#if IL2CPP_TARGET_JAVASCRIPT
+#define NOT_SUPPORTED_WEBGL(func, reason) \
+    il2cpp::vm::Exception::Raise (il2cpp::vm::Exception::GetNotSupportedException ( NOTSUPPORTEDICALLMESSAGE ("WebGL", #func, #reason) ))
+#else
+#define NOT_SUPPORTED_WEBGL(func, reason)
+#endif
+
+#if IL2CPP_COMPILER_MSVC
+    #define IL2CPP_DIR_SEPARATOR '\\'   /* backslash */
+#else
+    #define IL2CPP_DIR_SEPARATOR '/'    /* forward slash */
+#endif
+
+#ifndef IL2CPP_DISABLE_FULL_MESSAGES
+    #define IL2CPP_DISABLE_FULL_MESSAGES    1
+#endif
+
+#if IL2CPP_COMPILER_MSVC
+    #define IL2CPP_USE_GENERIC_SOCKET_IMPL  0
+#else
+    #define IL2CPP_USE_GENERIC_SOCKET_IMPL  (!IL2CPP_TARGET_POSIX || IL2CPP_TARGET_JAVASCRIPT) &&  (!IL2CPP_TARGET_SWITCH)
+#endif
+
+/* set by platforms that require special handling of SIGPIPE signalling during socket sends */
+#ifndef IL2CPP_USE_SEND_NOSIGNAL
+    #define IL2CPP_USE_SEND_NOSIGNAL 0
+#endif
+
+#ifndef IL2CPP_USE_GENERIC_ENVIRONMENT
+#define IL2CPP_USE_GENERIC_ENVIRONMENT  (!IL2CPP_TARGET_WINDOWS && !IL2CPP_TARGET_POSIX)
+#endif
+
+#define IL2CPP_USE_GENERIC_COM  (!IL2CPP_TARGET_WINDOWS)
+#define IL2CPP_USE_GENERIC_COM_SAFEARRAYS   (!IL2CPP_TARGET_WINDOWS || IL2CPP_TARGET_XBOXONE)
+#define IL2CPP_USE_GENERIC_WINDOWSRUNTIME (!IL2CPP_TARGET_WINDOWS || RUNTIME_MONO || RUNTIME_NONE)
+
+#ifndef IL2CPP_USE_GENERIC_MEMORY_MAPPED_FILE
+#define IL2CPP_USE_GENERIC_MEMORY_MAPPED_FILE (IL2CPP_TARGET_XBOXONE || (!IL2CPP_TARGET_WINDOWS && !IL2CPP_TARGET_POSIX))
+#endif
+
+#ifndef IL2CPP_HAS_CLOSE_EXEC
+#define IL2CPP_HAS_CLOSE_EXEC (IL2CPP_TARGET_POSIX && !IL2CPP_TARGET_PS4)
+#endif
+
+#ifndef IL2CPP_HAS_DUP
+#define IL2CPP_HAS_DUP (IL2CPP_TARGET_POSIX && !IL2CPP_TARGET_PS4)
+#endif
+
+#ifndef IL2CPP_USE_GENERIC_FILE
+#define IL2CPP_USE_GENERIC_FILE (!IL2CPP_TARGET_WINDOWS && !IL2CPP_TARGET_DARWIN)
+#endif
+
+#ifndef IL2CPP_USE_GENERIC_DEBUG_LOG
+#define IL2CPP_USE_GENERIC_DEBUG_LOG !IL2CPP_TARGET_WINDOWS
+#endif
+
+#define IL2CPP_SIZEOF_STRUCT_WITH_NO_INSTANCE_FIELDS 1
+#define IL2CPP_VALIDATE_FIELD_LAYOUT 0
+
+#ifndef IL2CPP_USE_POSIX_COND_TIMEDWAIT_REL
+#define IL2CPP_USE_POSIX_COND_TIMEDWAIT_REL ( IL2CPP_TARGET_DARWIN || IL2CPP_TARGET_PSP2 || ( IL2CPP_TARGET_ANDROID && !IL2CPP_TARGET_ARM64 ) )
+#endif
+
+#if IL2CPP_MONO_DEBUGGER
+#define STORE_SEQ_POINT(storage, seqPointId) do { (storage).currentSequencePoint = seqPointId; } while (0)
+#define CHECK_SEQ_POINT(storage, seqPointId) il2cpp_codegen_check_sequence_point(&(storage), seqPointId)
+#define CHECK_METHOD_EXIT_SEQ_POINT(name, storage, seqPointId) MethodExitSequencePointChecker name(&(storage), seqPointId)
+#define DECLARE_METHOD_THIS(variableName, thisAddress) void* variableName[] = { thisAddress }
+#define DECLARE_METHOD_PARAMS(variableName, ...) void* variableName[] = { __VA_ARGS__ }
+#define DECLARE_METHOD_LOCALS(variableName, ...) void* variableName[] = { __VA_ARGS__ }
+#define DECLARE_METHOD_EXEC_CTX(ctxVariable, method, thisVariable, paramsVariable, localsVariable) Il2CppSequencePointExecutionContext ctxVariable(method, thisVariable, paramsVariable, localsVariable)
+#define CHECK_PAUSE_POINT il2cpp_codegen_check_pause_point()
+#else
+#define STORE_SEQ_POINT(storage, seqPointVar)
+#define CHECK_SEQ_POINT(storage, seqPointVar)
+#define CHECK_METHOD_EXIT_SEQ_POINT(name, storage, seqPointId)
+#define DECLARE_METHOD_THIS(variableName, thisAddress)
+#define DECLARE_METHOD_PARAMS(variableName, ...)
+#define DECLARE_METHOD_LOCALS(variableName, ...)
+#define DECLARE_METHOD_EXEC_CTX(ctxVariable, method, thisVariable, paramsVariable, localsVariable)
+#define CHECK_PAUSE_POINT
+#endif
+
+#ifdef __cplusplus
+template<bool value>
+struct Il2CppStaticAssertHelper;
+
+template<>
+struct Il2CppStaticAssertHelper<true>
+{
+};
+
+
+#define Assert(x) do { (void)(x); IL2CPP_ASSERT(x); } while (false)
+#define Il2CppStaticAssert(...) do { Il2CppStaticAssertHelper<(__VA_ARGS__)>(); } while (false)
+#endif
+
+const int32_t kIl2CppInt32Min = INT32_MIN;
+const int32_t kIl2CppInt32Max = INT32_MAX;
+const uint32_t kIl2CppUInt32Max = UINT32_MAX;
+const int64_t kIl2CppInt64Min = INT64_MIN;
+const int64_t kIl2CppInt64Max = INT64_MAX;
+const uint64_t kIl2CppUInt64Max = UINT64_MAX;
+
+#if IL2CPP_SIZEOF_VOID_P == 8
+const intptr_t kIl2CppIntPtrMin = INT64_MIN;
+const intptr_t kIl2CppIntPtrMax = INT64_MAX;
+const uintptr_t kIl2CppUIntPtrMax = UINT64_MAX;
+#else
+const intptr_t kIl2CppIntPtrMin = INT32_MIN;
+const intptr_t kIl2CppIntPtrMax = INT32_MAX;
+const uintptr_t kIl2CppUIntPtrMax = UINT32_MAX;
+#endif
+
+const int ipv6AddressSize = 16;
+#define IL2CPP_SUPPORT_IPV6 !IL2CPP_TARGET_PS4 && !IL2CPP_TARGET_SWITCH
+
+// Android: "There is no support for locales in the C library" https://code.google.com/p/android/issues/detail?id=57313
+// PS4/PS2: strtol_d doesn't exist
+#define IL2CPP_SUPPORT_LOCALE_INDEPENDENT_PARSING (!IL2CPP_TARGET_ANDROID && !IL2CPP_TARGET_PS4 && !IL2CPP_TARGET_PSP2 && !IL2CPP_TARGET_NOVA)
+
+#define NO_UNUSED_WARNING(expr) (void)(expr)
+
+typedef int32_t il2cpp_hresult_t;
+
+// Sorted numerically!
+#define IL2CPP_S_OK                          ((il2cpp_hresult_t)0)
+#define IL2CPP_E_BOUNDS                      ((il2cpp_hresult_t)0x8000000B)
+#define IL2CPP_E_CHANGED_STATE               ((il2cpp_hresult_t)0x8000000C)
+#define IL2CPP_E_ILLEGAL_METHOD_CALL         ((il2cpp_hresult_t)0x8000000E)
+#define IL2CPP_RO_E_CLOSED                   ((il2cpp_hresult_t)0x80000013)
+#define IL2CPP_E_NOTIMPL                     ((il2cpp_hresult_t)0x80004001)
+#define IL2CPP_E_NOINTERFACE                 ((il2cpp_hresult_t)0x80004002)
+#define IL2CPP_E_POINTER                     ((il2cpp_hresult_t)0x80004003)
+#define IL2CPP_E_ABORT                       ((il2cpp_hresult_t)0x80004004)
+#define IL2CPP_E_FAIL                        ((il2cpp_hresult_t)0x80004005)
+#define IL2CPP_E_UNEXPECTED                  ((il2cpp_hresult_t)0x8000FFFF)
+#define IL2CPP_RPC_E_DISCONNECTED            ((il2cpp_hresult_t)0x80010108)
+#define IL2CPP_RPC_E_WRONG_THREAD            ((il2cpp_hresult_t)0x8001010E)
+#define IL2CPP_DISP_E_PARAMNOTFOUND          ((il2cpp_hresult_t)0x80020004)
+#define IL2CPP_REGDB_E_CLASSNOTREG           ((il2cpp_hresult_t)0x80040154)
+#define IL2CPP_E_ACCESS_DENIED               ((il2cpp_hresult_t)0x80070005)
+#define IL2CPP_E_OUTOFMEMORY                 ((il2cpp_hresult_t)0x8007000E)
+#define IL2CPP_E_INVALIDARG                  ((il2cpp_hresult_t)0x80070057)
+#define IL2CPP_COR_E_EXCEPTION               ((il2cpp_hresult_t)0x80131500)
+#define IL2CPP_COR_E_INVALIDOPERATION        ((il2cpp_hresult_t)0x80131509)
+#define IL2CPP_COR_E_PLATFORMNOTSUPPORTED    ((il2cpp_hresult_t)0x80131539)
+#define IL2CPP_COR_E_OPERATIONCANCELED       ((il2cpp_hresult_t)0x8013153B)
+#define IL2CPP_COR_E_OBJECTDISPOSED          ((il2cpp_hresult_t)0x80131622)
+
+#define IL2CPP_HR_SUCCEEDED(hr) (((il2cpp_hresult_t)(hr)) >= 0)
+#define IL2CPP_HR_FAILED(hr) (((il2cpp_hresult_t)(hr)) < 0)
+
+#define IL2CPP_LITTLE_ENDIAN 1
+#define IL2CPP_BIG_ENDIAN 2
+#define IL2CPP_BYTE_ORDER IL2CPP_LITTLE_ENDIAN
+
+#if (defined(_MSC_VER) && _MSC_VER > 1600) || (__has_feature(cxx_override_control))
+#define IL2CPP_OVERRIDE override
+#define IL2CPP_FINAL final
+#else
+#define IL2CPP_OVERRIDE
+#define IL2CPP_FINAL
+#endif
+
+#if (__has_feature(cxx_deleted_functions) || (defined(_MSC_VER) && _MSC_VER >= 1800))
+#define IL2CPP_HAS_DELETED_FUNCTIONS 1
+#else
+#define IL2CPP_HAS_DELETED_FUNCTIONS 0
+#endif
+
+#if IL2CPP_TARGET_WINDOWS
+const Il2CppChar kIl2CppNewLine[] = { '\r', '\n', '\0' };
+#else
+const Il2CppChar kIl2CppNewLine[] = { '\n', '\0' };
+#endif
+
+
+#if IL2CPP_TARGET_ANDROID && defined(__i386__)
+// On Android with x86, function pointers are not aligned, so we
+// need to use all of the bits when comparing them. Hence we mask
+// nothing.
+#define IL2CPP_POINTER_SPARE_BITS 0
+#else
+// On ARMv7 with Thumb instructions the lowest bit is always set.
+// With Thumb2 the second-to-lowest bit is also set. Mask both of
+// them off so that we can do a comparison properly based on the data
+// from the linker map file. On other architectures this operation should
+// not matter, as we assume these two bits are always zero because the pointer
+// will be aligned.
+#define IL2CPP_POINTER_SPARE_BITS 3
+#endif
+
+#define MAXIMUM_NESTED_GENERICS_EXCEPTION_MESSAGE "IL2CPP encountered a managed type which it cannot convert ahead-of-time. The type uses generic or array types which are nested beyond the maximum depth which can be converted."
+#if IL2CPP_COMPILER_MSVC
+#define IL2CPP_ATTRIBUTE_WEAK
+#else
+#define IL2CPP_ATTRIBUTE_WEAK __attribute__((weak))
+#endif
+
+#if IL2CPP_TARGET_XBOXONE || IL2CPP_TARGET_WINRT || IL2CPP_TARGET_ANDROID || IL2CPP_TARGET_PS4 || IL2CPP_TARGET_PSP2
+#define IL2CPP_USE_GENERIC_CPU_INFO 1
+#else
+#define IL2CPP_USE_GENERIC_CPU_INFO 0
+#endif
+
+#define IL2CPP_CAN_CHECK_EXECUTABLE IL2CPP_TARGET_WINDOWS || (IL2CPP_TARGET_POSIX && !IL2CPP_TARGET_PS4)
+
+#if IL2CPP_MONO_DEBUGGER
+#define IL2CPP_DEBUG_BREAK() il2cpp::utils::Debugger::UserBreak()
+#else
+#ifdef _MSC_VER
+#define IL2CPP_DEBUG_BREAK() __debugbreak()
+#else
+#define IL2CPP_DEBUG_BREAK()
+#endif
+#endif
+
+#if defined(__cplusplus)
+
+template<typename Type, size_t Size>
+char(*il2cpp_array_size_helper(Type(&array)[Size]))[Size];
+
+#define IL2CPP_ARRAY_SIZE(array) (sizeof(*il2cpp_array_size_helper(array)))
+
+#endif // __cplusplus
+
+#ifndef IOSBUILDENV_IL2CPP_FIX
+#define IOSBUILDENV_IL2CPP_FIX
+#define il2cpp_array_size_t unsigned long // Pierre-Marie Baty -- necessary addition to work around a compiler bug
+#endif // IOSBUILDENV_IL2CPP_FIX

App/LearnWithTouch_ios/Libraries/libil2cpp/include/il2cpp-metadata.h

@@ -0,0 +1,467 @@
+#pragma once
+
+#include "il2cpp-config.h"
+#include <stdint.h>
+
+// This file contains the structures specifying how we store converted metadata.
+// These structures have 3 constraints:
+// 1. These structures will be stored in an external file, and as such must not contain any pointers.
+//    All references to other metadata should occur via an index into a corresponding table.
+// 2. These structures are assumed to be const. Either const structures in the binary or mapped as
+//    readonly memory from an external file. Do not add any 'calculated' fields which will be written to at runtime.
+// 3. These structures should be optimized for size. Other structures are used at runtime which can
+//    be larger to store cached information
+
+typedef int32_t TypeIndex;
+typedef int32_t TypeDefinitionIndex;
+typedef int32_t FieldIndex;
+typedef int32_t DefaultValueIndex;
+typedef int32_t DefaultValueDataIndex;
+typedef int32_t CustomAttributeIndex;
+typedef int32_t ParameterIndex;
+typedef int32_t MethodIndex;
+typedef int32_t GenericMethodIndex;
+typedef int32_t PropertyIndex;
+typedef int32_t EventIndex;
+typedef int32_t GenericContainerIndex;
+typedef int32_t GenericParameterIndex;
+typedef int16_t GenericParameterConstraintIndex;
+typedef int32_t NestedTypeIndex;
+typedef int32_t InterfacesIndex;
+typedef int32_t VTableIndex;
+typedef int32_t InterfaceOffsetIndex;
+typedef int32_t RGCTXIndex;
+typedef int32_t StringIndex;
+typedef int32_t StringLiteralIndex;
+typedef int32_t GenericInstIndex;
+typedef int32_t ImageIndex;
+typedef int32_t AssemblyIndex;
+typedef int32_t InteropDataIndex;
+
+const TypeIndex kTypeIndexInvalid = -1;
+const TypeDefinitionIndex kTypeDefinitionIndexInvalid = -1;
+const DefaultValueDataIndex kDefaultValueIndexNull = -1;
+const CustomAttributeIndex kCustomAttributeIndexInvalid = -1;
+const EventIndex kEventIndexInvalid = -1;
+const FieldIndex kFieldIndexInvalid = -1;
+const MethodIndex kMethodIndexInvalid = -1;
+const PropertyIndex kPropertyIndexInvalid = -1;
+const GenericContainerIndex kGenericContainerIndexInvalid = -1;
+const GenericParameterIndex kGenericParameterIndexInvalid = -1;
+const RGCTXIndex kRGCTXIndexInvalid = -1;
+const StringLiteralIndex kStringLiteralIndexInvalid = -1;
+const InteropDataIndex kInteropDataIndexInvalid = -1;
+
+// Encoded index (1 bit)
+// MethodDef - 0
+// MethodSpec - 1
+// We use the top 3 bits to indicate what table to index into
+// Type              Binary            Hex
+// Il2CppClass          001               0x20000000
+// Il2CppType        010               0x40000000
+// MethodInfo        011               0x60000000
+// FieldInfo         100               0x80000000
+// StringLiteral     101               0xA0000000
+// MethodRef         110               0xC0000000
+
+typedef uint32_t EncodedMethodIndex;
+
+enum Il2CppMetadataUsage
+{
+    kIl2CppMetadataUsageInvalid,
+    kIl2CppMetadataUsageTypeInfo,
+    kIl2CppMetadataUsageIl2CppType,
+    kIl2CppMetadataUsageMethodDef,
+    kIl2CppMetadataUsageFieldInfo,
+    kIl2CppMetadataUsageStringLiteral,
+    kIl2CppMetadataUsageMethodRef,
+};
+
+#ifdef __cplusplus
+static inline Il2CppMetadataUsage GetEncodedIndexType(EncodedMethodIndex index)
+{
+    return (Il2CppMetadataUsage)((index & 0xE0000000) >> 29);
+}
+
+static inline uint32_t GetDecodedMethodIndex(EncodedMethodIndex index)
+{
+    return index & 0x1FFFFFFFU;
+}
+
+#endif
+
+struct Il2CppImage;
+struct Il2CppType;
+struct Il2CppTypeDefinitionMetadata;
+
+typedef union Il2CppRGCTXDefinitionData
+{
+    int32_t rgctxDataDummy;
+    MethodIndex methodIndex;
+    TypeIndex typeIndex;
+} Il2CppRGCTXDefinitionData;
+
+typedef enum Il2CppRGCTXDataType
+{
+    IL2CPP_RGCTX_DATA_INVALID,
+    IL2CPP_RGCTX_DATA_TYPE,
+    IL2CPP_RGCTX_DATA_CLASS,
+    IL2CPP_RGCTX_DATA_METHOD,
+    IL2CPP_RGCTX_DATA_ARRAY,
+} Il2CppRGCTXDataType;
+
+typedef struct Il2CppRGCTXDefinition
+{
+    Il2CppRGCTXDataType type;
+    Il2CppRGCTXDefinitionData data;
+} Il2CppRGCTXDefinition;
+
+typedef struct Il2CppInterfaceOffsetPair
+{
+    TypeIndex interfaceTypeIndex;
+    int32_t offset;
+} Il2CppInterfaceOffsetPair;
+
+typedef struct Il2CppTypeDefinition
+{
+    StringIndex nameIndex;
+    StringIndex namespaceIndex;
+    TypeIndex byvalTypeIndex;
+    TypeIndex byrefTypeIndex;
+
+    TypeIndex declaringTypeIndex;
+    TypeIndex parentIndex;
+    TypeIndex elementTypeIndex; // we can probably remove this one. Only used for enums
+
+    RGCTXIndex rgctxStartIndex;
+    int32_t rgctxCount;
+
+    GenericContainerIndex genericContainerIndex;
+
+    uint32_t flags;
+
+    FieldIndex fieldStart;
+    MethodIndex methodStart;
+    EventIndex eventStart;
+    PropertyIndex propertyStart;
+    NestedTypeIndex nestedTypesStart;
+    InterfacesIndex interfacesStart;
+    VTableIndex vtableStart;
+    InterfacesIndex interfaceOffsetsStart;
+
+    uint16_t method_count;
+    uint16_t property_count;
+    uint16_t field_count;
+    uint16_t event_count;
+    uint16_t nested_type_count;
+    uint16_t vtable_count;
+    uint16_t interfaces_count;
+    uint16_t interface_offsets_count;
+
+    // bitfield to portably encode boolean values as single bits
+    // 01 - valuetype;
+    // 02 - enumtype;
+    // 03 - has_finalize;
+    // 04 - has_cctor;
+    // 05 - is_blittable;
+    // 06 - is_import_or_windows_runtime;
+    // 07-10 - One of nine possible PackingSize values (0, 1, 2, 4, 8, 16, 32, 64, or 128)
+    uint32_t bitfield;
+    uint32_t token;
+} Il2CppTypeDefinition;
+
+typedef struct Il2CppFieldDefinition
+{
+    StringIndex nameIndex;
+    TypeIndex typeIndex;
+    uint32_t token;
+} Il2CppFieldDefinition;
+
+typedef struct Il2CppFieldDefaultValue
+{
+    FieldIndex fieldIndex;
+    TypeIndex typeIndex;
+    DefaultValueDataIndex dataIndex;
+} Il2CppFieldDefaultValue;
+
+typedef struct Il2CppFieldMarshaledSize
+{
+    FieldIndex fieldIndex;
+    TypeIndex typeIndex;
+    int32_t size;
+} Il2CppFieldMarshaledSize;
+
+typedef struct Il2CppFieldRef
+{
+    TypeIndex typeIndex;
+    FieldIndex fieldIndex; // local offset into type fields
+} Il2CppFieldRef;
+
+typedef struct Il2CppParameterDefinition
+{
+    StringIndex nameIndex;
+    uint32_t token;
+    TypeIndex typeIndex;
+} Il2CppParameterDefinition;
+
+typedef struct Il2CppParameterDefaultValue
+{
+    ParameterIndex parameterIndex;
+    TypeIndex typeIndex;
+    DefaultValueDataIndex dataIndex;
+} Il2CppParameterDefaultValue;
+
+typedef struct Il2CppMethodDefinition
+{
+    StringIndex nameIndex;
+    TypeDefinitionIndex declaringType;
+    TypeIndex returnType;
+    ParameterIndex parameterStart;
+    GenericContainerIndex genericContainerIndex;
+    MethodIndex methodIndex;
+    MethodIndex invokerIndex;
+    MethodIndex reversePInvokeWrapperIndex;
+    RGCTXIndex rgctxStartIndex;
+    int32_t rgctxCount;
+    uint32_t token;
+    uint16_t flags;
+    uint16_t iflags;
+    uint16_t slot;
+    uint16_t parameterCount;
+} Il2CppMethodDefinition;
+
+typedef struct Il2CppEventDefinition
+{
+    StringIndex nameIndex;
+    TypeIndex typeIndex;
+    MethodIndex add;
+    MethodIndex remove;
+    MethodIndex raise;
+    uint32_t token;
+} Il2CppEventDefinition;
+
+typedef struct Il2CppPropertyDefinition
+{
+    StringIndex nameIndex;
+    MethodIndex get;
+    MethodIndex set;
+    uint32_t attrs;
+    uint32_t token;
+} Il2CppPropertyDefinition;
+
+typedef struct Il2CppMethodSpec
+{
+    MethodIndex methodDefinitionIndex;
+    GenericInstIndex classIndexIndex;
+    GenericInstIndex methodIndexIndex;
+} Il2CppMethodSpec;
+
+typedef struct Il2CppStringLiteral
+{
+    uint32_t length;
+    StringLiteralIndex dataIndex;
+} Il2CppStringLiteral;
+
+typedef struct
+{
+    MethodIndex methodIndex;
+    MethodIndex invokerIndex;
+} Il2CppGenericMethodIndices;
+
+typedef struct Il2CppGenericMethodFunctionsDefinitions
+{
+    GenericMethodIndex genericMethodIndex;
+    Il2CppGenericMethodIndices indices;
+} Il2CppGenericMethodFunctionsDefinitions;
+
+#define PUBLIC_KEY_BYTE_LENGTH 8
+const int kPublicKeyByteLength = PUBLIC_KEY_BYTE_LENGTH;
+
+typedef struct Il2CppAssemblyNameDefinition
+{
+    StringIndex nameIndex;
+    StringIndex cultureIndex;
+    StringIndex hashValueIndex;
+    StringIndex publicKeyIndex;
+    uint32_t hash_alg;
+    int32_t hash_len;
+    uint32_t flags;
+    int32_t major;
+    int32_t minor;
+    int32_t build;
+    int32_t revision;
+    uint8_t public_key_token[PUBLIC_KEY_BYTE_LENGTH];
+} Il2CppAssemblyNameDefinition;
+
+typedef struct Il2CppImageDefinition
+{
+    StringIndex nameIndex;
+    AssemblyIndex assemblyIndex;
+
+    TypeDefinitionIndex typeStart;
+    uint32_t typeCount;
+
+    TypeDefinitionIndex exportedTypeStart;
+    uint32_t exportedTypeCount;
+
+    MethodIndex entryPointIndex;
+    uint32_t token;
+
+    CustomAttributeIndex customAttributeStart;
+    uint32_t customAttributeCount;
+} Il2CppImageDefinition;
+
+typedef struct Il2CppAssemblyDefinition
+{
+    ImageIndex imageIndex;
+    uint32_t token;
+    int32_t referencedAssemblyStart;
+    int32_t referencedAssemblyCount;
+    Il2CppAssemblyNameDefinition aname;
+} Il2CppAssemblyDefinition;
+
+typedef struct Il2CppMetadataUsageList
+{
+    uint32_t start;
+    uint32_t count;
+} Il2CppMetadataUsageList;
+
+typedef struct Il2CppMetadataUsagePair
+{
+    uint32_t destinationIndex;
+    uint32_t encodedSourceIndex;
+} Il2CppMetadataUsagePair;
+
+typedef struct Il2CppCustomAttributeTypeRange
+{
+    uint32_t token;
+    int32_t start;
+    int32_t count;
+} Il2CppCustomAttributeTypeRange;
+
+typedef struct Il2CppRange
+{
+    int32_t start;
+    int32_t length;
+} Il2CppRange;
+
+typedef struct Il2CppWindowsRuntimeTypeNamePair
+{
+    StringIndex nameIndex;
+    TypeIndex typeIndex;
+} Il2CppWindowsRuntimeTypeNamePair;
+
+#pragma pack(push, p1,4)
+typedef struct Il2CppGlobalMetadataHeader
+{
+    int32_t sanity;
+    int32_t version;
+    int32_t stringLiteralOffset; // string data for managed code
+    int32_t stringLiteralCount;
+    int32_t stringLiteralDataOffset;
+    int32_t stringLiteralDataCount;
+    int32_t stringOffset; // string data for metadata
+    int32_t stringCount;
+    int32_t eventsOffset; // Il2CppEventDefinition
+    int32_t eventsCount;
+    int32_t propertiesOffset; // Il2CppPropertyDefinition
+    int32_t propertiesCount;
+    int32_t methodsOffset; // Il2CppMethodDefinition
+    int32_t methodsCount;
+    int32_t parameterDefaultValuesOffset; // Il2CppParameterDefaultValue
+    int32_t parameterDefaultValuesCount;
+    int32_t fieldDefaultValuesOffset; // Il2CppFieldDefaultValue
+    int32_t fieldDefaultValuesCount;
+    int32_t fieldAndParameterDefaultValueDataOffset; // uint8_t
+    int32_t fieldAndParameterDefaultValueDataCount;
+    int32_t fieldMarshaledSizesOffset; // Il2CppFieldMarshaledSize
+    int32_t fieldMarshaledSizesCount;
+    int32_t parametersOffset; // Il2CppParameterDefinition
+    int32_t parametersCount;
+    int32_t fieldsOffset; // Il2CppFieldDefinition
+    int32_t fieldsCount;
+    int32_t genericParametersOffset; // Il2CppGenericParameter
+    int32_t genericParametersCount;
+    int32_t genericParameterConstraintsOffset; // TypeIndex
+    int32_t genericParameterConstraintsCount;
+    int32_t genericContainersOffset; // Il2CppGenericContainer
+    int32_t genericContainersCount;
+    int32_t nestedTypesOffset; // TypeDefinitionIndex
+    int32_t nestedTypesCount;
+    int32_t interfacesOffset; // TypeIndex
+    int32_t interfacesCount;
+    int32_t vtableMethodsOffset; // EncodedMethodIndex
+    int32_t vtableMethodsCount;
+    int32_t interfaceOffsetsOffset; // Il2CppInterfaceOffsetPair
+    int32_t interfaceOffsetsCount;
+    int32_t typeDefinitionsOffset; // Il2CppTypeDefinition
+    int32_t typeDefinitionsCount;
+    int32_t rgctxEntriesOffset; // Il2CppRGCTXDefinition
+    int32_t rgctxEntriesCount;
+    int32_t imagesOffset; // Il2CppImageDefinition
+    int32_t imagesCount;
+    int32_t assembliesOffset; // Il2CppAssemblyDefinition
+    int32_t assembliesCount;
+    int32_t metadataUsageListsOffset; // Il2CppMetadataUsageList
+    int32_t metadataUsageListsCount;
+    int32_t metadataUsagePairsOffset; // Il2CppMetadataUsagePair
+    int32_t metadataUsagePairsCount;
+    int32_t fieldRefsOffset; // Il2CppFieldRef
+    int32_t fieldRefsCount;
+    int32_t referencedAssembliesOffset; // int32_t
+    int32_t referencedAssembliesCount;
+    int32_t attributesInfoOffset; // Il2CppCustomAttributeTypeRange
+    int32_t attributesInfoCount;
+    int32_t attributeTypesOffset; // TypeIndex
+    int32_t attributeTypesCount;
+    int32_t unresolvedVirtualCallParameterTypesOffset; // TypeIndex
+    int32_t unresolvedVirtualCallParameterTypesCount;
+    int32_t unresolvedVirtualCallParameterRangesOffset; // Il2CppRange
+    int32_t unresolvedVirtualCallParameterRangesCount;
+    int32_t windowsRuntimeTypeNamesOffset; // Il2CppWindowsRuntimeTypeNamePair
+    int32_t windowsRuntimeTypeNamesSize;
+    int32_t exportedTypeDefinitionsOffset; // TypeDefinitionIndex
+    int32_t exportedTypeDefinitionsCount;
+} Il2CppGlobalMetadataHeader;
+#pragma pack(pop, p1)
+
+#if RUNTIME_MONO
+
+#pragma pack(push, p1,4)
+typedef struct Il2CppGlobalMonoMetadataHeader
+{
+    int32_t sanity;
+    int32_t version;
+    int32_t stringOffset; // string data for metadata
+    int32_t stringCount;
+    int32_t methodInfoMappingOffset; // hash -> MonoMethodInfo mapping
+    int32_t methodInfoMappingCount;
+    int32_t genericMethodInfoMappingOffset; // hash -> generic MonoMethodInfo mapping
+    int32_t genericMethodInfoMappingCount;
+    int32_t rgctxIndicesOffset; // runtime generic context indices
+    int32_t rgctxIndicesCount;
+    int32_t rgctxInfoOffset; // runtime generic context info
+    int32_t rgctxInfoCount;
+    int32_t monoStringOffset; // mono strings
+    int32_t monoStringCount;
+    int32_t methodMetadataOffset; // method metadata
+    int32_t methodMetadataCount;
+    int32_t genericArgumentIndicesOffset; // generic argument indices
+    int32_t genericArgumentIndicesCount;
+    int32_t typeTableOffset; // type table
+    int32_t typeTableCount;
+    int32_t fieldTableOffset; // field table
+    int32_t fieldTableCount;
+    int32_t methodIndexTableOffset; // method index table
+    int32_t methodIndexTableCount;
+    int32_t genericMethodIndexTableOffset; // generic method index table
+    int32_t genericMethodIndexTableCount;
+    int32_t metaDataUsageListsTableOffset; // meta data usage lists table
+    int32_t metaDataUsageListsTableCount;
+    int32_t metaDataUsagePairsTableOffset; // meta data usage pairs table
+    int32_t metaDataUsagePairsTableCount;
+    int32_t assemblyNameTableOffset; // assembly names
+    int32_t assemblyNameTableCount;
+} Il2CppGlobalMonoMetadataHeader;
+#pragma pack(pop, p1)
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/il2cpp-number-formatter.h

@@ -0,0 +1,917 @@
+#ifndef _MONO_METADATA_NUMBER_FORMATTER_H_
+#define _MONO_METADATA_NUMBER_FORMATTER_H_ 1
+
+#include <stdint.h>
+
+static const uint64_t Formatter_MantissaBitsTable[] =
+{
+    4556951262222748432ULL, 9113902524445496865ULL, 1822780504889099373ULL,
+    3645561009778198746ULL, 7291122019556397492ULL, 14582244039112794984ULL,
+    2916448807822558996ULL, 5832897615645117993ULL, 11665795231290235987ULL,
+    2333159046258047197ULL, 4666318092516094394ULL, 9332636185032188789ULL,
+    1866527237006437757ULL, 3733054474012875515ULL, 7466108948025751031ULL,
+    14932217896051502063ULL, 2986443579210300412ULL, 5972887158420600825ULL,
+    11945774316841201651ULL, 2389154863368240330ULL, 4778309726736480660ULL,
+    9556619453472961320ULL, 1911323890694592264ULL, 3822647781389184528ULL,
+    7645295562778369056ULL, 15290591125556738113ULL, 3058118225111347622ULL,
+    6116236450222695245ULL, 12232472900445390490ULL, 2446494580089078098ULL,
+    4892989160178156196ULL, 9785978320356312392ULL, 1957195664071262478ULL,
+    3914391328142524957ULL, 7828782656285049914ULL, 15657565312570099828ULL,
+    3131513062514019965ULL, 6263026125028039931ULL, 12526052250056079862ULL,
+    2505210450011215972ULL, 5010420900022431944ULL, 10020841800044863889ULL,
+    2004168360008972777ULL, 4008336720017945555ULL, 8016673440035891111ULL,
+    16033346880071782223ULL, 3206669376014356444ULL, 6413338752028712889ULL,
+    12826677504057425779ULL, 2565335500811485155ULL, 5130671001622970311ULL,
+    10261342003245940623ULL, 2052268400649188124ULL, 4104536801298376249ULL,
+    8209073602596752498ULL, 16418147205193504997ULL, 3283629441038700999ULL,
+    6567258882077401998ULL, 13134517764154803997ULL, 2626903552830960799ULL,
+    5253807105661921599ULL, 10507614211323843198ULL, 2101522842264768639ULL,
+    4203045684529537279ULL, 8406091369059074558ULL, 16812182738118149117ULL,
+    3362436547623629823ULL, 6724873095247259646ULL, 13449746190494519293ULL,
+    2689949238098903858ULL, 5379898476197807717ULL, 10759796952395615435ULL,
+    2151959390479123087ULL, 4303918780958246174ULL, 8607837561916492348ULL,
+    17215675123832984696ULL, 3443135024766596939ULL, 6886270049533193878ULL,
+    13772540099066387756ULL, 2754508019813277551ULL, 5509016039626555102ULL,
+    11018032079253110205ULL, 2203606415850622041ULL, 4407212831701244082ULL,
+    8814425663402488164ULL, 17628851326804976328ULL, 3525770265360995265ULL,
+    7051540530721990531ULL, 14103081061443981063ULL, 2820616212288796212ULL,
+    5641232424577592425ULL, 11282464849155184850ULL, 2256492969831036970ULL,
+    4512985939662073940ULL, 9025971879324147880ULL, 18051943758648295760ULL,
+    3610388751729659152ULL, 7220777503459318304ULL, 14441555006918636608ULL,
+    2888311001383727321ULL, 5776622002767454643ULL, 11553244005534909286ULL,
+    2310648801106981857ULL, 4621297602213963714ULL, 9242595204427927429ULL,
+    1848519040885585485ULL, 3697038081771170971ULL, 7394076163542341943ULL,
+    14788152327084683887ULL, 2957630465416936777ULL, 5915260930833873554ULL,
+    11830521861667747109ULL, 2366104372333549421ULL, 4732208744667098843ULL,
+    9464417489334197687ULL, 1892883497866839537ULL, 3785766995733679075ULL,
+    7571533991467358150ULL, 15143067982934716300ULL, 3028613596586943260ULL,
+    6057227193173886520ULL, 12114454386347773040ULL, 2422890877269554608ULL,
+    4845781754539109216ULL, 9691563509078218432ULL, 1938312701815643686ULL,
+    3876625403631287372ULL, 7753250807262574745ULL, 15506501614525149491ULL,
+    3101300322905029898ULL, 6202600645810059796ULL, 12405201291620119593ULL,
+    2481040258324023918ULL, 4962080516648047837ULL, 9924161033296095674ULL,
+    1984832206659219134ULL, 3969664413318438269ULL, 7939328826636876539ULL,
+    15878657653273753079ULL, 3175731530654750615ULL, 6351463061309501231ULL,
+    12702926122619002463ULL, 2540585224523800492ULL, 5081170449047600985ULL,
+    10162340898095201970ULL, 2032468179619040394ULL, 4064936359238080788ULL,
+    8129872718476161576ULL, 16259745436952323153ULL, 3251949087390464630ULL,
+    6503898174780929261ULL, 13007796349561858522ULL, 2601559269912371704ULL,
+    5203118539824743409ULL, 10406237079649486818ULL, 2081247415929897363ULL,
+    4162494831859794727ULL, 8324989663719589454ULL, 16649979327439178909ULL,
+    3329995865487835781ULL, 6659991730975671563ULL, 13319983461951343127ULL,
+    2663996692390268625ULL, 5327993384780537250ULL, 10655986769561074501ULL,
+    2131197353912214900ULL, 4262394707824429800ULL, 8524789415648859601ULL,
+    17049578831297719202ULL, 3409915766259543840ULL, 6819831532519087681ULL,
+    13639663065038175362ULL, 2727932613007635072ULL, 5455865226015270144ULL,
+    10911730452030540289ULL, 2182346090406108057ULL, 4364692180812216115ULL,
+    8729384361624432231ULL, 17458768723248864463ULL, 3491753744649772892ULL,
+    6983507489299545785ULL, 13967014978599091570ULL, 2793402995719818314ULL,
+    5586805991439636628ULL, 11173611982879273256ULL, 2234722396575854651ULL,
+    4469444793151709302ULL, 8938889586303418605ULL, 17877779172606837210ULL,
+    3575555834521367442ULL, 7151111669042734884ULL, 14302223338085469768ULL,
+    2860444667617093953ULL, 5720889335234187907ULL, 11441778670468375814ULL,
+    2288355734093675162ULL, 4576711468187350325ULL, 9153422936374700651ULL,
+    1830684587274940130ULL, 3661369174549880260ULL, 7322738349099760521ULL,
+    14645476698199521043ULL, 2929095339639904208ULL, 5858190679279808417ULL,
+    11716381358559616834ULL, 2343276271711923366ULL, 4686552543423846733ULL,
+    9373105086847693467ULL, 1874621017369538693ULL, 3749242034739077387ULL,
+    7498484069478154774ULL, 14996968138956309548ULL, 2999393627791261909ULL,
+    5998787255582523819ULL, 11997574511165047638ULL, 2399514902233009527ULL,
+    4799029804466019055ULL, 9598059608932038110ULL, 1919611921786407622ULL,
+    3839223843572815244ULL, 7678447687145630488ULL, 15356895374291260977ULL,
+    3071379074858252195ULL, 6142758149716504390ULL, 12285516299433008781ULL,
+    2457103259886601756ULL, 4914206519773203512ULL, 9828413039546407025ULL,
+    1965682607909281405ULL, 3931365215818562810ULL, 7862730431637125620ULL,
+    15725460863274251240ULL, 3145092172654850248ULL, 6290184345309700496ULL,
+    12580368690619400992ULL, 2516073738123880198ULL, 5032147476247760397ULL,
+    10064294952495520794ULL, 2012858990499104158ULL, 4025717980998208317ULL,
+    8051435961996416635ULL, 16102871923992833270ULL, 3220574384798566654ULL,
+    6441148769597133308ULL, 12882297539194266616ULL, 2576459507838853323ULL,
+    5152919015677706646ULL, 10305838031355413293ULL, 2061167606271082658ULL,
+    4122335212542165317ULL, 8244670425084330634ULL, 16489340850168661269ULL,
+    3297868170033732253ULL, 6595736340067464507ULL, 13191472680134929015ULL,
+    2638294536026985803ULL, 5276589072053971606ULL, 10553178144107943212ULL,
+    2110635628821588642ULL, 4221271257643177284ULL, 8442542515286354569ULL,
+    16885085030572709139ULL, 3377017006114541827ULL, 6754034012229083655ULL,
+    13508068024458167311ULL, 2701613604891633462ULL, 5403227209783266924ULL,
+    10806454419566533849ULL, 2161290883913306769ULL, 4322581767826613539ULL,
+    8645163535653227079ULL, 17290327071306454158ULL, 3458065414261290831ULL,
+    6916130828522581663ULL, 13832261657045163327ULL, 2766452331409032665ULL,
+    5532904662818065330ULL, 11065809325636130661ULL, 2213161865127226132ULL,
+    4426323730254452264ULL, 8852647460508904529ULL, 17705294921017809058ULL,
+    3541058984203561811ULL, 7082117968407123623ULL, 14164235936814247246ULL,
+    2832847187362849449ULL, 5665694374725698898ULL, 11331388749451397797ULL,
+    2266277749890279559ULL, 4532555499780559119ULL, 9065110999561118238ULL,
+    1813022199912223647ULL, 3626044399824447295ULL, 7252088799648894590ULL,
+    14504177599297789180ULL, 2900835519859557836ULL, 5801671039719115672ULL,
+    11603342079438231344ULL, 2320668415887646268ULL, 4641336831775292537ULL,
+    9282673663550585075ULL, 1856534732710117015ULL, 3713069465420234030ULL,
+    7426138930840468060ULL, 14852277861680936121ULL, 2970455572336187224ULL,
+    5940911144672374448ULL, 11881822289344748896ULL, 2376364457868949779ULL,
+    4752728915737899558ULL, 9505457831475799117ULL, 1901091566295159823ULL,
+    3802183132590319647ULL, 7604366265180639294ULL, 15208732530361278588ULL,
+    3041746506072255717ULL, 6083493012144511435ULL, 12166986024289022870ULL,
+    2433397204857804574ULL, 4866794409715609148ULL, 9733588819431218296ULL,
+    1946717763886243659ULL, 3893435527772487318ULL, 7786871055544974637ULL,
+    15573742111089949274ULL, 3114748422217989854ULL, 6229496844435979709ULL,
+    12458993688871959419ULL, 2491798737774391883ULL, 4983597475548783767ULL,
+    9967194951097567535ULL, 1993438990219513507ULL, 3986877980439027014ULL,
+    7973755960878054028ULL, 15947511921756108056ULL, 3189502384351221611ULL,
+    6379004768702443222ULL, 12758009537404886445ULL, 2551601907480977289ULL,
+    5103203814961954578ULL, 10206407629923909156ULL, 2041281525984781831ULL,
+    4082563051969563662ULL, 8165126103939127325ULL, 16330252207878254650ULL,
+    3266050441575650930ULL, 6532100883151301860ULL, 13064201766302603720ULL,
+    2612840353260520744ULL, 5225680706521041488ULL, 10451361413042082976ULL,
+    2090272282608416595ULL, 4180544565216833190ULL, 8361089130433666380ULL,
+    16722178260867332761ULL, 3344435652173466552ULL, 6688871304346933104ULL,
+    13377742608693866209ULL, 2675548521738773241ULL, 5351097043477546483ULL,
+    10702194086955092967ULL, 2140438817391018593ULL, 4280877634782037187ULL,
+    8561755269564074374ULL, 17123510539128148748ULL, 3424702107825629749ULL,
+    6849404215651259499ULL, 13698808431302518998ULL, 2739761686260503799ULL,
+    5479523372521007599ULL, 10959046745042015198ULL, 2191809349008403039ULL,
+    4383618698016806079ULL, 8767237396033612159ULL, 17534474792067224318ULL,
+    3506894958413444863ULL, 7013789916826889727ULL, 14027579833653779454ULL,
+    2805515966730755890ULL, 5611031933461511781ULL, 11222063866923023563ULL,
+    2244412773384604712ULL, 4488825546769209425ULL, 8977651093538418850ULL,
+    17955302187076837701ULL, 3591060437415367540ULL, 7182120874830735080ULL,
+    14364241749661470161ULL, 2872848349932294032ULL, 5745696699864588064ULL,
+    11491393399729176129ULL, 2298278679945835225ULL, 4596557359891670451ULL,
+    9193114719783340903ULL, 1838622943956668180ULL, 3677245887913336361ULL,
+    7354491775826672722ULL, 14708983551653345445ULL, 2941796710330669089ULL,
+    5883593420661338178ULL, 11767186841322676356ULL, 2353437368264535271ULL,
+    4706874736529070542ULL, 9413749473058141084ULL, 1882749894611628216ULL,
+    3765499789223256433ULL, 7530999578446512867ULL, 15061999156893025735ULL,
+    3012399831378605147ULL, 6024799662757210294ULL, 12049599325514420588ULL,
+    2409919865102884117ULL, 4819839730205768235ULL, 9639679460411536470ULL,
+    1927935892082307294ULL, 3855871784164614588ULL, 7711743568329229176ULL,
+    15423487136658458353ULL, 3084697427331691670ULL, 6169394854663383341ULL,
+    12338789709326766682ULL, 2467757941865353336ULL, 4935515883730706673ULL,
+    9871031767461413346ULL, 1974206353492282669ULL, 3948412706984565338ULL,
+    7896825413969130677ULL, 15793650827938261354ULL, 3158730165587652270ULL,
+    6317460331175304541ULL, 12634920662350609083ULL, 2526984132470121816ULL,
+    5053968264940243633ULL, 10107936529880487266ULL, 2021587305976097453ULL,
+    4043174611952194906ULL, 8086349223904389813ULL, 16172698447808779626ULL,
+    3234539689561755925ULL, 6469079379123511850ULL, 12938158758247023701ULL,
+    2587631751649404740ULL, 5175263503298809480ULL, 10350527006597618960ULL,
+    2070105401319523792ULL, 4140210802639047584ULL, 8280421605278095168ULL,
+    16560843210556190337ULL, 3312168642111238067ULL, 6624337284222476135ULL,
+    13248674568444952270ULL, 2649734913688990454ULL, 5299469827377980908ULL,
+    10598939654755961816ULL, 2119787930951192363ULL, 4239575861902384726ULL,
+    8479151723804769452ULL, 16958303447609538905ULL, 3391660689521907781ULL,
+    6783321379043815562ULL, 13566642758087631124ULL, 2713328551617526224ULL,
+    5426657103235052449ULL, 10853314206470104899ULL, 2170662841294020979ULL,
+    4341325682588041959ULL, 8682651365176083919ULL, 17365302730352167839ULL,
+    3473060546070433567ULL, 6946121092140867135ULL, 13892242184281734271ULL,
+    2778448436856346854ULL, 5556896873712693708ULL, 11113793747425387417ULL,
+    2222758749485077483ULL, 4445517498970154966ULL, 8891034997940309933ULL,
+    17782069995880619867ULL, 3556413999176123973ULL, 7112827998352247947ULL,
+    14225655996704495894ULL, 2845131199340899178ULL, 5690262398681798357ULL,
+    11380524797363596715ULL, 2276104959472719343ULL, 4552209918945438686ULL,
+    9104419837890877372ULL, 1820883967578175474ULL, 3641767935156350948ULL,
+    7283535870312701897ULL, 14567071740625403795ULL, 2913414348125080759ULL,
+    5826828696250161518ULL, 11653657392500323036ULL, 2330731478500064607ULL,
+    4661462957000129214ULL, 9322925914000258429ULL, 1864585182800051685ULL,
+    3729170365600103371ULL, 7458340731200206743ULL, 14916681462400413486ULL,
+    2983336292480082697ULL, 5966672584960165394ULL, 11933345169920330789ULL,
+    2386669033984066157ULL, 4773338067968132315ULL, 9546676135936264631ULL,
+    1909335227187252926ULL, 3818670454374505852ULL, 7637340908749011705ULL,
+    15274681817498023410ULL, 3054936363499604682ULL, 6109872726999209364ULL,
+    12219745453998418728ULL, 2443949090799683745ULL, 4887898181599367491ULL,
+    9775796363198734982ULL, 1955159272639746996ULL, 3910318545279493993ULL,
+    7820637090558987986ULL, 15641274181117975972ULL, 3128254836223595194ULL,
+    6256509672447190388ULL, 12513019344894380777ULL, 2502603868978876155ULL,
+    5005207737957752311ULL, 10010415475915504622ULL, 2002083095183100924ULL,
+    4004166190366201848ULL, 8008332380732403697ULL, 16016664761464807395ULL,
+    3203332952292961479ULL, 6406665904585922958ULL, 12813331809171845916ULL,
+    2562666361834369183ULL, 5125332723668738366ULL, 10250665447337476733ULL,
+    2050133089467495346ULL, 4100266178934990693ULL, 8200532357869981386ULL,
+    16401064715739962772ULL, 3280212943147992554ULL, 6560425886295985109ULL,
+    13120851772591970218ULL, 2624170354518394043ULL, 5248340709036788087ULL,
+    10496681418073576174ULL, 2099336283614715234ULL, 4198672567229430469ULL,
+    8397345134458860939ULL, 16794690268917721879ULL, 3358938053783544375ULL,
+    6717876107567088751ULL, 13435752215134177503ULL, 2687150443026835500ULL,
+    5374300886053671001ULL, 10748601772107342002ULL, 2149720354421468400ULL,
+    4299440708842936801ULL, 8598881417685873602ULL, 17197762835371747204ULL,
+    3439552567074349440ULL, 6879105134148698881ULL, 13758210268297397763ULL,
+    2751642053659479552ULL, 5503284107318959105ULL, 11006568214637918210ULL,
+    2201313642927583642ULL, 4402627285855167284ULL, 8805254571710334568ULL,
+    17610509143420669137ULL, 3522101828684133827ULL, 7044203657368267654ULL,
+    14088407314736535309ULL, 2817681462947307061ULL, 5635362925894614123ULL,
+    11270725851789228247ULL, 2254145170357845649ULL, 4508290340715691299ULL,
+    9016580681431382598ULL, 18033161362862765196ULL, 3606632272572553039ULL,
+    7213264545145106078ULL, 14426529090290212157ULL, 2885305818058042431ULL,
+    5770611636116084862ULL, 11541223272232169725ULL, 2308244654446433945ULL,
+    4616489308892867890ULL, 9232978617785735780ULL, 1846595723557147156ULL,
+    3693191447114294312ULL, 7386382894228588624ULL, 14772765788457177249ULL,
+    2954553157691435449ULL, 5909106315382870899ULL, 11818212630765741799ULL,
+    2363642526153148359ULL, 4727285052306296719ULL, 9454570104612593439ULL,
+    1890914020922518687ULL, 3781828041845037375ULL, 7563656083690074751ULL,
+    15127312167380149503ULL, 3025462433476029900ULL, 6050924866952059801ULL,
+    12101849733904119602ULL, 2420369946780823920ULL, 4840739893561647841ULL,
+    9681479787123295682ULL, 1936295957424659136ULL, 3872591914849318272ULL,
+    7745183829698636545ULL, 15490367659397273091ULL, 3098073531879454618ULL,
+    6196147063758909236ULL, 12392294127517818473ULL, 2478458825503563694ULL,
+    4956917651007127389ULL, 9913835302014254778ULL, 1982767060402850955ULL,
+    3965534120805701911ULL, 7931068241611403822ULL, 15862136483222807645ULL,
+    3172427296644561529ULL, 6344854593289123058ULL, 12689709186578246116ULL,
+    2537941837315649223ULL, 5075883674631298446ULL, 10151767349262596893ULL,
+    2030353469852519378ULL, 4060706939705038757ULL, 8121413879410077514ULL,
+    16242827758820155028ULL, 3248565551764031005ULL, 6497131103528062011ULL,
+    12994262207056124023ULL, 2598852441411224804ULL, 5197704882822449609ULL,
+    10395409765644899218ULL, 2079081953128979843ULL, 4158163906257959687ULL,
+    8316327812515919374ULL, 16632655625031838749ULL, 3326531125006367749ULL,
+    6653062250012735499ULL, 13306124500025470999ULL, 2661224900005094199ULL,
+    5322449800010188399ULL, 10644899600020376799ULL, 2128979920004075359ULL,
+    4257959840008150719ULL, 8515919680016301439ULL, 17031839360032602879ULL,
+    3406367872006520575ULL, 6812735744013041151ULL, 13625471488026082303ULL,
+    2725094297605216460ULL, 5450188595210432921ULL, 10900377190420865842ULL,
+    2180075438084173168ULL, 4360150876168346337ULL, 8720301752336692674ULL,
+    17440603504673385348ULL, 3488120700934677069ULL, 6976241401869354139ULL,
+    13952482803738708279ULL, 2790496560747741655ULL, 5580993121495483311ULL,
+    11161986242990966623ULL, 2232397248598193324ULL, 4464794497196386649ULL,
+    8929588994392773298ULL, 17859177988785546597ULL, 3571835597757109319ULL,
+    7143671195514218638ULL, 14287342391028437277ULL, 2857468478205687455ULL,
+    5714936956411374911ULL, 11429873912822749822ULL, 2285974782564549964ULL,
+    4571949565129099928ULL, 9143899130258199857ULL, 1828779826051639971ULL,
+    3657559652103279943ULL, 7315119304206559886ULL, 14630238608413119772ULL,
+    2926047721682623954ULL, 5852095443365247908ULL, 11704190886730495817ULL,
+    2340838177346099163ULL, 4681676354692198327ULL, 9363352709384396654ULL,
+    1872670541876879330ULL, 3745341083753758661ULL, 7490682167507517323ULL,
+    14981364335015034646ULL, 2996272867003006929ULL, 5992545734006013858ULL,
+    11985091468012027717ULL, 2397018293602405543ULL, 4794036587204811087ULL,
+    9588073174409622174ULL, 1917614634881924434ULL, 3835229269763848869ULL,
+    7670458539527697739ULL, 15340917079055395478ULL, 3068183415811079095ULL,
+    6136366831622158191ULL, 12272733663244316382ULL, 2454546732648863276ULL,
+    4909093465297726553ULL, 9818186930595453106ULL, 1963637386119090621ULL,
+    3927274772238181242ULL, 7854549544476362484ULL, 15709099088952724969ULL,
+    3141819817790544993ULL, 6283639635581089987ULL, 12567279271162179975ULL,
+    2513455854232435995ULL, 5026911708464871990ULL, 10053823416929743980ULL,
+    2010764683385948796ULL, 4021529366771897592ULL, 8043058733543795184ULL,
+    16086117467087590369ULL, 3217223493417518073ULL, 6434446986835036147ULL,
+    12868893973670072295ULL, 2573778794734014459ULL, 5147557589468028918ULL,
+    10295115178936057836ULL, 2059023035787211567ULL, 4118046071574423134ULL,
+    8236092143148846269ULL, 16472184286297692538ULL, 3294436857259538507ULL,
+    6588873714519077015ULL, 13177747429038154030ULL, 2635549485807630806ULL,
+    5271098971615261612ULL, 10542197943230523224ULL, 2108439588646104644ULL,
+    4216879177292209289ULL, 8433758354584418579ULL, 16867516709168837158ULL,
+    3373503341833767431ULL, 6747006683667534863ULL, 13494013367335069727ULL,
+    2698802673467013945ULL, 5397605346934027890ULL, 10795210693868055781ULL,
+    2159042138773611156ULL, 4318084277547222312ULL, 8636168555094444625ULL,
+    17272337110188889250ULL, 3454467422037777850ULL, 6908934844075555700ULL,
+    13817869688151111400ULL, 2763573937630222280ULL, 5527147875260444560ULL,
+    11054295750520889120ULL, 2210859150104177824ULL, 4421718300208355648ULL,
+    8843436600416711296ULL, 17686873200833422592ULL, 3537374640166684518ULL,
+    7074749280333369037ULL, 14149498560666738074ULL, 2829899712133347614ULL,
+    5659799424266695229ULL, 11319598848533390459ULL, 2263919769706678091ULL,
+    4527839539413356183ULL, 9055679078826712367ULL, 1811135815765342473ULL,
+    3622271631530684947ULL, 7244543263061369894ULL, 14489086526122739788ULL,
+    2897817305224547957ULL, 5795634610449095915ULL, 11591269220898191830ULL,
+    2318253844179638366ULL, 4636507688359276732ULL, 9273015376718553464ULL,
+    1854603075343710692ULL, 3709206150687421385ULL, 7418412301374842771ULL,
+    14836824602749685542ULL, 2967364920549937108ULL, 5934729841099874217ULL,
+    11869459682199748434ULL, 2373891936439949686ULL, 4747783872879899373ULL,
+    9495567745759798747ULL, 1899113549151959749ULL, 3798227098303919498ULL,
+    7596454196607838997ULL, 15192908393215677995ULL, 3038581678643135599ULL,
+    6077163357286271198ULL, 12154326714572542396ULL, 2430865342914508479ULL,
+    4861730685829016958ULL, 9723461371658033917ULL, 1944692274331606783ULL,
+    3889384548663213566ULL, 7778769097326427133ULL, 15557538194652854267ULL,
+    3111507638930570853ULL, 6223015277861141707ULL, 12446030555722283414ULL,
+    2489206111144456682ULL, 4978412222288913365ULL, 9956824444577826731ULL,
+    1991364888915565346ULL, 3982729777831130692ULL, 7965459555662261385ULL,
+    15930919111324522770ULL, 3186183822264904554ULL, 6372367644529809108ULL,
+    12744735289059618216ULL, 2548947057811923643ULL, 5097894115623847286ULL,
+    10195788231247694572ULL, 2039157646249538914ULL, 4078315292499077829ULL,
+    8156630584998155658ULL, 16313261169996311316ULL, 3262652233999262263ULL,
+    6525304467998524526ULL, 13050608935997049053ULL, 2610121787199409810ULL,
+    5220243574398819621ULL, 10440487148797639242ULL, 2088097429759527848ULL,
+    4176194859519055697ULL, 8352389719038111394ULL, 16704779438076222788ULL,
+    3340955887615244557ULL, 6681911775230489115ULL, 13363823550460978230ULL,
+    2672764710092195646ULL, 5345529420184391292ULL, 10691058840368782584ULL,
+    2138211768073756516ULL, 4276423536147513033ULL, 8552847072295026067ULL,
+    17105694144590052135ULL, 3421138828918010427ULL, 6842277657836020854ULL,
+    13684555315672041708ULL, 2736911063134408341ULL, 5473822126268816683ULL,
+    10947644252537633366ULL, 2189528850507526673ULL, 4379057701015053346ULL,
+    8758115402030106693ULL, 17516230804060213386ULL, 3503246160812042677ULL,
+    7006492321624085354ULL, 14012984643248170709ULL, 2802596928649634141ULL,
+    5605193857299268283ULL, 11210387714598536567ULL, 2242077542919707313ULL,
+    4484155085839414626ULL, 8968310171678829253ULL, 17936620343357658507ULL,
+    3587324068671531701ULL, 7174648137343063403ULL, 14349296274686126806ULL,
+    2869859254937225361ULL, 5739718509874450722ULL, 11479437019748901445ULL,
+    2295887403949780289ULL, 4591774807899560578ULL, 9183549615799121156ULL,
+    1836709923159824231ULL, 3673419846319648462ULL, 7346839692639296924ULL,
+    14693679385278593849ULL, 2938735877055718769ULL, 5877471754111437539ULL,
+    11754943508222875079ULL, 2350988701644575015ULL, 4701977403289150031ULL,
+    9403954806578300063ULL, 1880790961315660012ULL, 3761581922631320025ULL,
+    7523163845262640050ULL, 15046327690525280101ULL, 3009265538105056020ULL,
+    6018531076210112040ULL, 12037062152420224081ULL, 2407412430484044816ULL,
+    4814824860968089632ULL, 9629649721936179265ULL, 1925929944387235853ULL,
+    3851859888774471706ULL, 7703719777548943412ULL, 15407439555097886824ULL,
+    3081487911019577364ULL, 6162975822039154729ULL, 12325951644078309459ULL,
+    2465190328815661891ULL, 4930380657631323783ULL, 9860761315262647567ULL,
+    1972152263052529513ULL, 3944304526105059027ULL, 7888609052210118054ULL,
+    15777218104420236108ULL, 3155443620884047221ULL, 6310887241768094443ULL,
+    12621774483536188886ULL, 2524354896707237777ULL, 5048709793414475554ULL,
+    10097419586828951109ULL, 2019483917365790221ULL, 4038967834731580443ULL,
+    8077935669463160887ULL, 16155871338926321774ULL, 3231174267785264354ULL,
+    6462348535570528709ULL, 12924697071141057419ULL, 2584939414228211483ULL,
+    5169878828456422967ULL, 10339757656912845935ULL, 2067951531382569187ULL,
+    4135903062765138374ULL, 8271806125530276748ULL, 16543612251060553497ULL,
+    3308722450212110699ULL, 6617444900424221398ULL, 13234889800848442797ULL,
+    2646977960169688559ULL, 5293955920339377119ULL, 10587911840678754238ULL,
+    2117582368135750847ULL, 4235164736271501695ULL, 8470329472543003390ULL,
+    16940658945086006781ULL, 3388131789017201356ULL, 6776263578034402712ULL,
+    13552527156068805425ULL, 2710505431213761085ULL, 5421010862427522170ULL,
+    10842021724855044340ULL, 2168404344971008868ULL, 4336808689942017736ULL,
+    8673617379884035472ULL, 17347234759768070944ULL, 3469446951953614188ULL,
+    6938893903907228377ULL, 13877787807814456755ULL, 2775557561562891351ULL,
+    5551115123125782702ULL, 11102230246251565404ULL, 2220446049250313080ULL,
+    4440892098500626161ULL, 8881784197001252323ULL, 17763568394002504646ULL,
+    3552713678800500929ULL, 7105427357601001858ULL, 14210854715202003717ULL,
+    2842170943040400743ULL, 5684341886080801486ULL, 11368683772161602973ULL,
+    2273736754432320594ULL, 4547473508864641189ULL, 9094947017729282379ULL,
+    1818989403545856475ULL, 3637978807091712951ULL, 7275957614183425903ULL,
+    14551915228366851806ULL, 2910383045673370361ULL, 5820766091346740722ULL,
+    11641532182693481445ULL, 2328306436538696289ULL, 4656612873077392578ULL,
+    9313225746154785156ULL, 1862645149230957031ULL, 3725290298461914062ULL,
+    7450580596923828125ULL, 14901161193847656250ULL, 2980232238769531250ULL,
+    5960464477539062500ULL, 11920928955078125000ULL, 2384185791015625000ULL,
+    4768371582031250000ULL, 9536743164062500000ULL, 1907348632812500000ULL,
+    3814697265625000000ULL, 7629394531250000000ULL, 15258789062500000000ULL,
+    3051757812500000000ULL, 6103515625000000000ULL, 12207031250000000000ULL,
+    2441406250000000000ULL, 4882812500000000000ULL, 9765625000000000000ULL,
+    1953125000000000000ULL, 3906250000000000000ULL, 7812500000000000000ULL,
+    15625000000000000000ULL, 3125000000000000000ULL, 6250000000000000000ULL,
+    12500000000000000000ULL, 2500000000000000000ULL, 5000000000000000000ULL,
+    10000000000000000000ULL, 2000000000000000000ULL, 4000000000000000000ULL,
+    8000000000000000000ULL, 16000000000000000000ULL, 3200000000000000000ULL,
+    6400000000000000000ULL, 12800000000000000000ULL, 2560000000000000000ULL,
+    5120000000000000000ULL, 10240000000000000000ULL, 2048000000000000000ULL,
+    4096000000000000000ULL, 8192000000000000000ULL, 16384000000000000000ULL,
+    3276800000000000000ULL, 6553600000000000000ULL, 13107200000000000000ULL,
+    2621440000000000000ULL, 5242880000000000000ULL, 10485760000000000000ULL,
+    2097152000000000000ULL, 4194304000000000000ULL, 8388608000000000000ULL,
+    16777216000000000000ULL, 3355443200000000000ULL, 6710886400000000000ULL,
+    13421772800000000000ULL, 2684354560000000000ULL, 5368709120000000000ULL,
+    10737418240000000000ULL, 2147483648000000000ULL, 4294967296000000000ULL,
+    8589934592000000000ULL, 17179869184000000000ULL, 3435973836800000000ULL,
+    6871947673600000000ULL, 13743895347200000000ULL, 2748779069440000000ULL,
+    5497558138880000000ULL, 10995116277760000000ULL, 2199023255552000000ULL,
+    4398046511104000000ULL, 8796093022208000000ULL, 17592186044416000000ULL,
+    3518437208883200000ULL, 7036874417766400000ULL, 14073748835532800000ULL,
+    2814749767106560000ULL, 5629499534213120000ULL, 11258999068426240000ULL,
+    2251799813685248000ULL, 4503599627370496000ULL, 9007199254740992000ULL,
+    18014398509481984000ULL, 3602879701896396800ULL, 7205759403792793600ULL,
+    14411518807585587200ULL, 2882303761517117440ULL, 5764607523034234880ULL,
+    11529215046068469760ULL, 2305843009213693952ULL, 4611686018427387904ULL,
+    9223372036854775808ULL, 1844674407370955161ULL, 3689348814741910323ULL,
+    7378697629483820646ULL, 14757395258967641292ULL, 2951479051793528258ULL,
+    5902958103587056517ULL, 11805916207174113034ULL, 2361183241434822606ULL,
+    4722366482869645213ULL, 9444732965739290427ULL, 1888946593147858085ULL,
+    3777893186295716170ULL, 7555786372591432341ULL, 15111572745182864683ULL,
+    3022314549036572936ULL, 6044629098073145873ULL, 12089258196146291747ULL,
+    2417851639229258349ULL, 4835703278458516698ULL, 9671406556917033397ULL,
+    1934281311383406679ULL, 3868562622766813359ULL, 7737125245533626718ULL,
+    15474250491067253436ULL, 3094850098213450687ULL, 6189700196426901374ULL,
+    12379400392853802748ULL, 2475880078570760549ULL, 4951760157141521099ULL,
+    9903520314283042199ULL, 1980704062856608439ULL, 3961408125713216879ULL,
+    7922816251426433759ULL, 15845632502852867518ULL, 3169126500570573503ULL,
+    6338253001141147007ULL, 12676506002282294014ULL, 2535301200456458802ULL,
+    5070602400912917605ULL, 10141204801825835211ULL, 2028240960365167042ULL,
+    4056481920730334084ULL, 8112963841460668169ULL, 16225927682921336339ULL,
+    3245185536584267267ULL, 6490371073168534535ULL, 12980742146337069071ULL,
+    2596148429267413814ULL, 5192296858534827628ULL, 10384593717069655257ULL,
+    2076918743413931051ULL, 4153837486827862102ULL, 8307674973655724205ULL,
+    16615349947311448411ULL, 3323069989462289682ULL, 6646139978924579364ULL,
+    13292279957849158729ULL, 2658455991569831745ULL, 5316911983139663491ULL,
+    10633823966279326983ULL, 2126764793255865396ULL, 4253529586511730793ULL,
+    8507059173023461586ULL, 17014118346046923173ULL, 3402823669209384634ULL,
+    6805647338418769269ULL, 13611294676837538538ULL, 2722258935367507707ULL,
+    5444517870735015415ULL, 10889035741470030830ULL, 2177807148294006166ULL,
+    4355614296588012332ULL, 8711228593176024664ULL, 17422457186352049329ULL,
+    3484491437270409865ULL, 6968982874540819731ULL, 13937965749081639463ULL,
+    2787593149816327892ULL, 5575186299632655785ULL, 11150372599265311570ULL,
+    2230074519853062314ULL, 4460149039706124628ULL, 8920298079412249256ULL,
+    17840596158824498513ULL, 3568119231764899702ULL, 7136238463529799405ULL,
+    14272476927059598810ULL, 2854495385411919762ULL, 5708990770823839524ULL,
+    11417981541647679048ULL, 2283596308329535809ULL, 4567192616659071619ULL,
+    9134385233318143238ULL, 1826877046663628647ULL, 3653754093327257295ULL,
+    7307508186654514591ULL, 14615016373309029182ULL, 2923003274661805836ULL,
+    5846006549323611672ULL, 11692013098647223345ULL, 2338402619729444669ULL,
+    4676805239458889338ULL, 9353610478917778676ULL, 1870722095783555735ULL,
+    3741444191567111470ULL, 7482888383134222941ULL, 14965776766268445882ULL,
+    2993155353253689176ULL, 5986310706507378352ULL, 11972621413014756705ULL,
+    2394524282602951341ULL, 4789048565205902682ULL, 9578097130411805364ULL,
+    1915619426082361072ULL, 3831238852164722145ULL, 7662477704329444291ULL,
+    15324955408658888583ULL, 3064991081731777716ULL, 6129982163463555433ULL,
+    12259964326927110866ULL, 2451992865385422173ULL, 4903985730770844346ULL,
+    9807971461541688693ULL, 1961594292308337738ULL, 3923188584616675477ULL,
+    7846377169233350954ULL, 15692754338466701909ULL, 3138550867693340381ULL,
+    6277101735386680763ULL, 12554203470773361527ULL, 2510840694154672305ULL,
+    5021681388309344611ULL, 10043362776618689222ULL, 2008672555323737844ULL,
+    4017345110647475688ULL, 8034690221294951377ULL, 16069380442589902755ULL,
+    3213876088517980551ULL, 6427752177035961102ULL, 12855504354071922204ULL,
+    2571100870814384440ULL, 5142201741628768881ULL, 10284403483257537763ULL,
+    2056880696651507552ULL, 4113761393303015105ULL, 8227522786606030210ULL,
+    16455045573212060421ULL, 3291009114642412084ULL, 6582018229284824168ULL,
+    13164036458569648337ULL, 2632807291713929667ULL, 5265614583427859334ULL,
+    10531229166855718669ULL, 2106245833371143733ULL, 4212491666742287467ULL,
+    8424983333484574935ULL, 16849966666969149871ULL, 3369993333393829974ULL,
+    6739986666787659948ULL, 13479973333575319897ULL, 2695994666715063979ULL,
+    5391989333430127958ULL, 10783978666860255917ULL, 2156795733372051183ULL,
+    4313591466744102367ULL, 8627182933488204734ULL, 17254365866976409468ULL,
+    3450873173395281893ULL, 6901746346790563787ULL, 13803492693581127574ULL,
+    2760698538716225514ULL, 5521397077432451029ULL, 11042794154864902059ULL,
+    2208558830972980411ULL, 4417117661945960823ULL, 8834235323891921647ULL,
+    17668470647783843295ULL, 3533694129556768659ULL, 7067388259113537318ULL,
+    14134776518227074636ULL, 2826955303645414927ULL, 5653910607290829854ULL,
+    11307821214581659709ULL, 2261564242916331941ULL, 4523128485832663883ULL,
+    9046256971665327767ULL, 18092513943330655534ULL, 3618502788666131106ULL,
+    7237005577332262213ULL, 14474011154664524427ULL, 2894802230932904885ULL,
+    5789604461865809771ULL, 11579208923731619542ULL, 2315841784746323908ULL,
+    4631683569492647816ULL, 9263367138985295633ULL, 1852673427797059126ULL,
+    3705346855594118253ULL, 7410693711188236507ULL, 14821387422376473014ULL,
+    2964277484475294602ULL, 5928554968950589205ULL, 11857109937901178411ULL,
+    2371421987580235682ULL, 4742843975160471364ULL, 9485687950320942729ULL,
+    1897137590064188545ULL, 3794275180128377091ULL, 7588550360256754183ULL,
+    15177100720513508366ULL, 3035420144102701673ULL, 6070840288205403346ULL,
+    12141680576410806693ULL, 2428336115282161338ULL, 4856672230564322677ULL,
+    9713344461128645354ULL, 1942668892225729070ULL, 3885337784451458141ULL,
+    7770675568902916283ULL, 15541351137805832567ULL, 3108270227561166513ULL,
+    6216540455122333026ULL, 12433080910244666053ULL, 2486616182048933210ULL,
+    4973232364097866421ULL, 9946464728195732843ULL, 1989292945639146568ULL,
+    3978585891278293137ULL, 7957171782556586274ULL, 15914343565113172548ULL,
+    3182868713022634509ULL, 6365737426045269019ULL, 12731474852090538039ULL,
+    2546294970418107607ULL, 5092589940836215215ULL, 10185179881672430431ULL,
+    2037035976334486086ULL, 4074071952668972172ULL, 8148143905337944345ULL,
+    16296287810675888690ULL, 3259257562135177738ULL, 6518515124270355476ULL,
+    13037030248540710952ULL, 2607406049708142190ULL, 5214812099416284380ULL,
+    10429624198832568761ULL, 2085924839766513752ULL, 4171849679533027504ULL,
+    8343699359066055009ULL, 16687398718132110018ULL, 3337479743626422003ULL,
+    6674959487252844007ULL, 13349918974505688014ULL, 2669983794901137602ULL,
+    5339967589802275205ULL, 10679935179604550411ULL, 2135987035920910082ULL,
+    4271974071841820164ULL, 8543948143683640329ULL, 17087896287367280659ULL,
+    3417579257473456131ULL, 6835158514946912263ULL, 13670317029893824527ULL,
+    2734063405978764905ULL, 5468126811957529810ULL, 10936253623915059621ULL,
+    2187250724783011924ULL, 4374501449566023848ULL, 8749002899132047697ULL,
+    17498005798264095394ULL, 3499601159652819078ULL, 6999202319305638157ULL,
+    13998404638611276315ULL, 2799680927722255263ULL, 5599361855444510526ULL,
+    11198723710889021052ULL, 2239744742177804210ULL, 4479489484355608421ULL,
+    8958978968711216842ULL, 17917957937422433684ULL, 3583591587484486736ULL,
+    7167183174968973473ULL, 14334366349937946947ULL, 2866873269987589389ULL,
+    5733746539975178779ULL, 11467493079950357558ULL, 2293498615990071511ULL,
+    4586997231980143023ULL, 9173994463960286046ULL, 1834798892792057209ULL,
+    3669597785584114418ULL, 7339195571168228837ULL, 14678391142336457674ULL,
+    2935678228467291534ULL, 5871356456934583069ULL, 11742712913869166139ULL,
+    2348542582773833227ULL, 4697085165547666455ULL, 9394170331095332911ULL,
+    1878834066219066582ULL, 3757668132438133164ULL, 7515336264876266329ULL,
+    15030672529752532658ULL, 3006134505950506531ULL, 6012269011901013063ULL,
+    12024538023802026126ULL, 2404907604760405225ULL, 4809815209520810450ULL,
+    9619630419041620901ULL, 1923926083808324180ULL, 3847852167616648360ULL,
+    7695704335233296721ULL, 15391408670466593442ULL, 3078281734093318688ULL,
+    6156563468186637376ULL, 12313126936373274753ULL, 2462625387274654950ULL,
+    4925250774549309901ULL, 9850501549098619803ULL, 1970100309819723960ULL,
+    3940200619639447921ULL, 7880401239278895842ULL, 15760802478557791684ULL,
+    3152160495711558336ULL, 6304320991423116673ULL, 12608641982846233347ULL,
+    2521728396569246669ULL, 5043456793138493339ULL, 10086913586276986678ULL,
+    2017382717255397335ULL, 4034765434510794671ULL, 8069530869021589342ULL,
+    16139061738043178685ULL, 3227812347608635737ULL, 6455624695217271474ULL,
+    12911249390434542948ULL, 2582249878086908589ULL, 5164499756173817179ULL,
+    10328999512347634358ULL, 2065799902469526871ULL, 4131599804939053743ULL,
+    8263199609878107486ULL, 16526399219756214973ULL, 3305279843951242994ULL,
+    6610559687902485989ULL, 13221119375804971979ULL, 2644223875160994395ULL,
+    5288447750321988791ULL, 10576895500643977583ULL, 2115379100128795516ULL,
+    4230758200257591033ULL, 8461516400515182066ULL, 16923032801030364133ULL,
+    3384606560206072826ULL, 6769213120412145653ULL, 13538426240824291306ULL,
+    2707685248164858261ULL, 5415370496329716522ULL, 10830740992659433045ULL,
+    2166148198531886609ULL, 4332296397063773218ULL, 8664592794127546436ULL,
+    17329185588255092872ULL, 3465837117651018574ULL, 6931674235302037148ULL,
+    13863348470604074297ULL, 2772669694120814859ULL, 5545339388241629719ULL,
+    11090678776483259438ULL, 2218135755296651887ULL, 4436271510593303775ULL,
+    8872543021186607550ULL, 17745086042373215101ULL, 3549017208474643020ULL,
+    7098034416949286040ULL, 14196068833898572081ULL, 2839213766779714416ULL,
+    5678427533559428832ULL, 11356855067118857664ULL, 2271371013423771532ULL,
+    4542742026847543065ULL, 9085484053695086131ULL, 1817096810739017226ULL,
+    3634193621478034452ULL, 7268387242956068905ULL, 14536774485912137810ULL,
+    2907354897182427562ULL, 5814709794364855124ULL, 11629419588729710248ULL,
+    2325883917745942049ULL, 4651767835491884099ULL, 9303535670983768199ULL,
+    1860707134196753639ULL, 3721414268393507279ULL, 7442828536787014559ULL,
+    14885657073574029118ULL, 2977131414714805823ULL, 5954262829429611647ULL,
+    11908525658859223294ULL, 2381705131771844658ULL, 4763410263543689317ULL,
+    9526820527087378635ULL, 1905364105417475727ULL, 3810728210834951454ULL,
+    7621456421669902908ULL, 15242912843339805817ULL, 3048582568667961163ULL,
+    6097165137335922326ULL, 12194330274671844653ULL, 2438866054934368930ULL,
+    4877732109868737861ULL, 9755464219737475723ULL, 1951092843947495144ULL,
+    3902185687894990289ULL, 7804371375789980578ULL, 15608742751579961156ULL,
+    3121748550315992231ULL, 6243497100631984462ULL, 12486994201263968925ULL,
+    2497398840252793785ULL, 4994797680505587570ULL, 9989595361011175140ULL,
+    1997919072202235028ULL, 3995838144404470056ULL, 7991676288808940112ULL,
+    15983352577617880224ULL, 3196670515523576044ULL, 6393341031047152089ULL,
+    12786682062094304179ULL, 2557336412418860835ULL, 5114672824837721671ULL,
+    10229345649675443343ULL, 2045869129935088668ULL, 4091738259870177337ULL,
+    8183476519740354675ULL, 16366953039480709350ULL, 3273390607896141870ULL,
+    6546781215792283740ULL, 13093562431584567480ULL, 2618712486316913496ULL,
+    5237424972633826992ULL, 10474849945267653984ULL, 2094969989053530796ULL,
+    4189939978107061593ULL, 8379879956214123187ULL, 16759759912428246374ULL,
+    3351951982485649274ULL, 6703903964971298549ULL, 13407807929942597099ULL,
+    2681561585988519419ULL, 5363123171977038839ULL, 10726246343954077679ULL,
+    2145249268790815535ULL, 4290498537581631071ULL, 8580997075163262143ULL,
+    17161994150326524287ULL, 3432398830065304857ULL, 6864797660130609714ULL,
+    13729595320261219429ULL, 2745919064052243885ULL, 5491838128104487771ULL,
+    10983676256208975543ULL, 2196735251241795108ULL, 4393470502483590217ULL,
+    8786941004967180435ULL, 17573882009934360870ULL, 3514776401986872174ULL,
+    7029552803973744348ULL, 14059105607947488696ULL, 2811821121589497739ULL,
+    5623642243178995478ULL, 11247284486357990957ULL, 2249456897271598191ULL,
+    4498913794543196382ULL, 8997827589086392765ULL, 17995655178172785531ULL,
+    3599131035634557106ULL, 7198262071269114212ULL, 14396524142538228424ULL,
+    2879304828507645684ULL, 5758609657015291369ULL, 11517219314030582739ULL,
+    2303443862806116547ULL, 4606887725612233095ULL, 9213775451224466191ULL,
+    1842755090244893238ULL, 3685510180489786476ULL, 7371020360979572953ULL,
+    14742040721959145907ULL, 2948408144391829181ULL, 5896816288783658362ULL,
+    11793632577567316725ULL, 2358726515513463345ULL, 4717453031026926690ULL,
+    9434906062053853380ULL, 1886981212410770676ULL, 3773962424821541352ULL,
+    7547924849643082704ULL, 15095849699286165408ULL, 3019169939857233081ULL,
+    6038339879714466163ULL, 12076679759428932327ULL, 2415335951885786465ULL,
+    4830671903771572930ULL, 9661343807543145861ULL, 1932268761508629172ULL,
+    3864537523017258344ULL, 7729075046034516689ULL, 15458150092069033378ULL,
+    3091630018413806675ULL, 6183260036827613351ULL, 12366520073655226703ULL,
+    2473304014731045340ULL, 4946608029462090681ULL, 9893216058924181362ULL,
+    1978643211784836272ULL, 3957286423569672544ULL, 7914572847139345089ULL,
+    15829145694278690179ULL, 3165829138855738035ULL, 6331658277711476071ULL,
+    12663316555422952143ULL, 2532663311084590428ULL, 5065326622169180857ULL,
+    10130653244338361715ULL, 2026130648867672343ULL, 4052261297735344686ULL,
+    8104522595470689372ULL, 16209045190941378744ULL, 3241809038188275748ULL,
+    6483618076376551497ULL, 12967236152753102995ULL, 2593447230550620599ULL,
+    5186894461101241198ULL, 10373788922202482396ULL, 2074757784440496479ULL,
+    4149515568880992958ULL, 8299031137761985917ULL, 16598062275523971834ULL,
+    3319612455104794366ULL, 6639224910209588733ULL, 13278449820419177467ULL,
+    2655689964083835493ULL, 5311379928167670986ULL, 10622759856335341973ULL,
+    2124551971267068394ULL, 4249103942534136789ULL, 8498207885068273579ULL,
+    16996415770136547158ULL, 3399283154027309431ULL, 6798566308054618863ULL,
+    13597132616109237726ULL, 2719426523221847545ULL, 5438853046443695090ULL,
+    10877706092887390181ULL, 2175541218577478036ULL, 4351082437154956072ULL,
+    8702164874309912144ULL, 17404329748619824289ULL, 3480865949723964857ULL,
+    6961731899447929715ULL, 13923463798895859431ULL, 2784692759779171886ULL,
+    5569385519558343772ULL, 11138771039116687545ULL, 2227754207823337509ULL,
+    4455508415646675018ULL, 8911016831293350036ULL, 17822033662586700072ULL,
+    3564406732517340014ULL, 7128813465034680029ULL, 14257626930069360058ULL,
+    2851525386013872011ULL, 5703050772027744023ULL, 11406101544055488046ULL,
+    2281220308811097609ULL, 4562440617622195218ULL, 9124881235244390437ULL,
+    1824976247048878087ULL, 3649952494097756174ULL, 7299904988195512349ULL,
+    14599809976391024699ULL, 2919961995278204939ULL, 5839923990556409879ULL,
+    11679847981112819759ULL, 2335969596222563951ULL, 4671939192445127903ULL,
+    9343878384890255807ULL, 1868775676978051161ULL, 3737551353956102323ULL,
+    7475102707912204646ULL, 14950205415824409292ULL, 2990041083164881858ULL,
+    5980082166329763716ULL, 11960164332659527433ULL, 2392032866531905486ULL,
+    4784065733063810973ULL, 9568131466127621947ULL, 1913626293225524389ULL,
+    3827252586451048778ULL, 7654505172902097557ULL, 15309010345804195115ULL,
+    3061802069160839023ULL, 6123604138321678046ULL, 12247208276643356092ULL,
+    2449441655328671218ULL, 4898883310657342436ULL, 9797766621314684873ULL,
+    1959553324262936974ULL, 3919106648525873949ULL, 7838213297051747899ULL,
+    15676426594103495798ULL, 3135285318820699159ULL, 6270570637641398319ULL,
+    12541141275282796638ULL, 2508228255056559327ULL, 5016456510113118655ULL,
+    10032913020226237310ULL, 2006582604045247462ULL, 4013165208090494924ULL,
+    8026330416180989848ULL, 16052660832361979697ULL, 3210532166472395939ULL,
+    6421064332944791878ULL, 12842128665889583757ULL, 2568425733177916751ULL,
+    5136851466355833503ULL, 10273702932711667006ULL, 2054740586542333401ULL,
+    4109481173084666802ULL, 8218962346169333605ULL, 16437924692338667210ULL,
+    3287584938467733442ULL, 6575169876935466884ULL, 13150339753870933768ULL,
+    2630067950774186753ULL, 5260135901548373507ULL, 10520271803096747014ULL,
+    2104054360619349402ULL, 4208108721238698805ULL, 8416217442477397611ULL,
+    16832434884954795223ULL, 3366486976990959044ULL, 6732973953981918089ULL,
+    13465947907963836178ULL, 2693189581592767235ULL, 5386379163185534471ULL,
+    10772758326371068942ULL, 2154551665274213788ULL, 4309103330548427577ULL,
+    8618206661096855154ULL, 17236413322193710308ULL, 3447282664438742061ULL,
+    6894565328877484123ULL, 13789130657754968246ULL, 2757826131550993649ULL,
+    5515652263101987298ULL, 11031304526203974597ULL, 2206260905240794919ULL,
+    4412521810481589838ULL, 8825043620963179677ULL, 17650087241926359355ULL,
+    3530017448385271871ULL, 7060034896770543742ULL, 14120069793541087484ULL,
+    2824013958708217496ULL, 5648027917416434993ULL, 11296055834832869987ULL,
+    2259211166966573997ULL, 4518422333933147995ULL, 9036844667866295990ULL,
+    18073689335732591980ULL, 3614737867146518396ULL, 7229475734293036792ULL,
+    14458951468586073584ULL, 2891790293717214716ULL, 5783580587434429433ULL,
+    11567161174868858867ULL, 2313432234973771773ULL, 4626864469947543547ULL,
+    9253728939895087094ULL, 1850745787979017418ULL, 3701491575958034837ULL,
+    7402983151916069675ULL, 14805966303832139350ULL, 2961193260766427870ULL,
+    5922386521532855740ULL, 11844773043065711480ULL, 2368954608613142296ULL,
+    4737909217226284592ULL, 9475818434452569184ULL, 1895163686890513836ULL,
+    3790327373781027673ULL, 7580654747562055347ULL, 15161309495124110694ULL,
+    3032261899024822138ULL, 6064523798049644277ULL, 12129047596099288555ULL,
+    2425809519219857711ULL, 4851619038439715422ULL, 9703238076879430844ULL,
+    1940647615375886168ULL, 3881295230751772337ULL, 7762590461503544675ULL,
+    15525180923007089351ULL, 3105036184601417870ULL, 6210072369202835740ULL,
+    12420144738405671481ULL, 2484028947681134296ULL, 4968057895362268592ULL,
+    9936115790724537184ULL, 1987223158144907436ULL, 3974446316289814873ULL,
+    7948892632579629747ULL, 15897785265159259495ULL, 3179557053031851899ULL,
+    6359114106063703798ULL, 12718228212127407596ULL, 2543645642425481519ULL,
+    5087291284850963038ULL, 10174582569701926077ULL, 2034916513940385215ULL,
+    4069833027880770430ULL, 8139666055761540861ULL, 16279332111523081723ULL,
+    3255866422304616344ULL, 6511732844609232689ULL, 13023465689218465379ULL,
+    2604693137843693075ULL, 5209386275687386151ULL, 10418772551374772303ULL,
+    2083754510274954460ULL, 4167509020549908921ULL, 8335018041099817842ULL,
+    16670036082199635685ULL, 3334007216439927137ULL, 6668014432879854274ULL,
+    13336028865759708548ULL, 2667205773151941709ULL, 5334411546303883419ULL,
+    10668823092607766838ULL, 2133764618521553367ULL, 4267529237043106735ULL,
+    8535058474086213470ULL, 17070116948172426941ULL, 3414023389634485388ULL,
+    6828046779268970776ULL, 13656093558537941553ULL, 2731218711707588310ULL,
+    5462437423415176621ULL, 10924874846830353242ULL, 2184974969366070648ULL,
+    4369949938732141297ULL, 8739899877464282594ULL, 17479799754928565188ULL,
+    3495959950985713037ULL, 6991919901971426075ULL, 13983839803942852150ULL,
+    2796767960788570430ULL, 5593535921577140860ULL, 11187071843154281720ULL,
+    2237414368630856344ULL, 4474828737261712688ULL, 8949657474523425376ULL,
+    17899314949046850752ULL, 3579862989809370150ULL, 7159725979618740301ULL,
+    14319451959237480602ULL, 2863890391847496120ULL, 5727780783694992240ULL,
+    11455561567389984481ULL, 2291112313477996896ULL, 4582224626955993792ULL,
+    9164449253911987585ULL, 1832889850782397517ULL, 3665779701564795034ULL,
+    7331559403129590068ULL, 14663118806259180136ULL, 2932623761251836027ULL,
+    5865247522503672054ULL, 11730495045007344109ULL, 2346099009001468821ULL,
+    4692198018002937643ULL, 9384396036005875287ULL, 1876879207201175057ULL,
+    3753758414402350114ULL, 7507516828804700229ULL, 15015033657609400459ULL,
+    3003006731521880091ULL, 6006013463043760183ULL, 12012026926087520367ULL,
+    2402405385217504073ULL, 4804810770435008147ULL, 9609621540870016294ULL,
+    1921924308174003258ULL, 3843848616348006517ULL, 7687697232696013035ULL,
+    15375394465392026070ULL, 3075078893078405214ULL, 6150157786156810428ULL,
+    12300315572313620856ULL, 2460063114462724171ULL, 4920126228925448342ULL,
+    9840252457850896685ULL, 1968050491570179337ULL, 3936100983140358674ULL,
+    7872201966280717348ULL, 15744403932561434696ULL, 3148880786512286939ULL,
+    6297761573024573878ULL, 12595523146049147757ULL, 2519104629209829551ULL,
+    5038209258419659102ULL, 10076418516839318205ULL, 2015283703367863641ULL,
+    4030567406735727282ULL, 8061134813471454564ULL, 16122269626942909129ULL,
+    3224453925388581825ULL, 6448907850777163651ULL, 12897815701554327303ULL,
+    2579563140310865460ULL, 5159126280621730921ULL, 10318252561243461842ULL,
+    2063650512248692368ULL, 4127301024497384737ULL, 8254602048994769474ULL,
+    16509204097989538948ULL, 3301840819597907789ULL, 6603681639195815579ULL,
+    13207363278391631158ULL, 2641472655678326231ULL, 5282945311356652463ULL,
+    10565890622713304927ULL, 2113178124542660985ULL, 4226356249085321970ULL,
+    8452712498170643941ULL, 16905424996341287883ULL, 3381084999268257576ULL,
+    6762169998536515153ULL, 13524339997073030306ULL, 2704867999414606061ULL,
+    5409735998829212122ULL, 10819471997658424245ULL, 2163894399531684849ULL,
+    4327788799063369698ULL, 8655577598126739396ULL, 17311155196253478792ULL,
+    3462231039250695758ULL, 6924462078501391516ULL, 13848924157002783033ULL,
+    2769784831400556606ULL, 5539569662801113213ULL, 11079139325602226427ULL,
+    2215827865120445285ULL, 4431655730240890570ULL, 8863311460481781141ULL,
+    17726622920963562283ULL, 3545324584192712456ULL, 7090649168385424913ULL,
+    14181298336770849826ULL, 2836259667354169965ULL, 5672519334708339930ULL,
+    11345038669416679861ULL, 2269007733883335972ULL, 4538015467766671944ULL,
+    9076030935533343889ULL, 18152061871066687778ULL, 3630412374213337555ULL,
+    7260824748426675111ULL, 14521649496853350222ULL, 2904329899370670044ULL,
+    5808659798741340089ULL, 11617319597482680178ULL, 2323463919496536035ULL,
+    4646927838993072071ULL, 9293855677986144142ULL, 1858771135597228828ULL,
+    3717542271194457656ULL, 7435084542388915313ULL, 14870169084777830627ULL,
+    2974033816955566125ULL, 5948067633911132251ULL, 11896135267822264502ULL,
+    2379227053564452900ULL, 4758454107128905800ULL, 9516908214257811601ULL,
+    1903381642851562320ULL, 3806763285703124640ULL, 7613526571406249281ULL,
+    15227053142812498563ULL, 3045410628562499712ULL, 6090821257124999425ULL,
+    12181642514249998850ULL, 2436328502849999770ULL, 4872657005699999540ULL,
+    9745314011399999080ULL, 1949062802279999816ULL, 3898125604559999632ULL,
+    7796251209119999264ULL, 15592502418239998528ULL, 3118500483647999705ULL,
+    6237000967295999411ULL, 12474001934591998822ULL, 2494800386918399764ULL,
+    4989600773836799529ULL, 9979201547673599058ULL, 1995840309534719811ULL,
+    3991680619069439623ULL, 7983361238138879246ULL, 15966722476277758493ULL,
+    3193344495255551698ULL, 6386688990511103397ULL, 12773377981022206794ULL,
+    2554675596204441358ULL, 5109351192408882717ULL, 10218702384817765435ULL,
+    2043740476963553087ULL, 4087480953927106174ULL, 8174961907854212348ULL,
+    16349923815708424697ULL, 3269984763141684939ULL, 6539969526283369878ULL,
+    13079939052566739757ULL, 2615987810513347951ULL, 5231975621026695903ULL,
+    10463951242053391806ULL, 2092790248410678361ULL, 4185580496821356722ULL,
+    8371160993642713444ULL, 16742321987285426889ULL, 3348464397457085377ULL,
+    6696928794914170755ULL, 13393857589828341511ULL, 2678771517965668302ULL,
+    5357543035931336604ULL, 10715086071862673209ULL, 2143017214372534641ULL,
+    4286034428745069283ULL, 8572068857490138567ULL, 17144137714980277135ULL,
+    3428827542996055427ULL, 6857655085992110854ULL, 13715310171984221708ULL,
+    2743062034396844341ULL, 5486124068793688683ULL, 10972248137587377366ULL,
+    2194449627517475473ULL, 4388899255034950946ULL, 8777798510069901893ULL,
+    17555597020139803786ULL, 3511119404027960757ULL, 7022238808055921514ULL,
+    14044477616111843029ULL, 2808895523222368605ULL, 5617791046444737211ULL,
+    11235582092889474423ULL, 2247116418577894884ULL, 4494232837155789769ULL,
+    8988465674311579538ULL, 17976931348623159077ULL, 3595386269724631815ULL,
+    7190772539449263630ULL, 14381545078898527261ULL, 2876309015779705452ULL,
+    5752618031559410904ULL, 11505236063118821809ULL, 2301047212623764361ULL,
+    4602094425247528723ULL, 9204188850495057447ULL, 1840837770099011489ULL,
+    3681675540198022979ULL, 7363351080396045958ULL,
+};
+
+static const int32_t Formatter_TensExponentTable[] =
+{
+    -323, -323, -322, -322, -322, -322, -321, -321, -321, -320, -320, -320,
+    -319, -319, -319, -319, -318, -318, -318, -317, -317, -317, -316, -316,
+    -316, -316, -315, -315, -315, -314, -314, -314, -313, -313, -313, -313,
+    -312, -312, -312, -311, -311, -311, -310, -310, -310, -310, -309, -309,
+    -309, -308, -308, -308, -307, -307, -307, -307, -306, -306, -306, -305,
+    -305, -305, -304, -304, -304, -304, -303, -303, -303, -302, -302, -302,
+    -301, -301, -301, -301, -300, -300, -300, -299, -299, -299, -298, -298,
+    -298, -298, -297, -297, -297, -296, -296, -296, -295, -295, -295, -295,
+    -294, -294, -294, -293, -293, -293, -292, -292, -292, -291, -291, -291,
+    -291, -290, -290, -290, -289, -289, -289, -288, -288, -288, -288, -287,
+    -287, -287, -286, -286, -286, -285, -285, -285, -285, -284, -284, -284,
+    -283, -283, -283, -282, -282, -282, -282, -281, -281, -281, -280, -280,
+    -280, -279, -279, -279, -279, -278, -278, -278, -277, -277, -277, -276,
+    -276, -276, -276, -275, -275, -275, -274, -274, -274, -273, -273, -273,
+    -273, -272, -272, -272, -271, -271, -271, -270, -270, -270, -270, -269,
+    -269, -269, -268, -268, -268, -267, -267, -267, -267, -266, -266, -266,
+    -265, -265, -265, -264, -264, -264, -263, -263, -263, -263, -262, -262,
+    -262, -261, -261, -261, -260, -260, -260, -260, -259, -259, -259, -258,
+    -258, -258, -257, -257, -257, -257, -256, -256, -256, -255, -255, -255,
+    -254, -254, -254, -254, -253, -253, -253, -252, -252, -252, -251, -251,
+    -251, -251, -250, -250, -250, -249, -249, -249, -248, -248, -248, -248,
+    -247, -247, -247, -246, -246, -246, -245, -245, -245, -245, -244, -244,
+    -244, -243, -243, -243, -242, -242, -242, -242, -241, -241, -241, -240,
+    -240, -240, -239, -239, -239, -239, -238, -238, -238, -237, -237, -237,
+    -236, -236, -236, -235, -235, -235, -235, -234, -234, -234, -233, -233,
+    -233, -232, -232, -232, -232, -231, -231, -231, -230, -230, -230, -229,
+    -229, -229, -229, -228, -228, -228, -227, -227, -227, -226, -226, -226,
+    -226, -225, -225, -225, -224, -224, -224, -223, -223, -223, -223, -222,
+    -222, -222, -221, -221, -221, -220, -220, -220, -220, -219, -219, -219,
+    -218, -218, -218, -217, -217, -217, -217, -216, -216, -216, -215, -215,
+    -215, -214, -214, -214, -214, -213, -213, -213, -212, -212, -212, -211,
+    -211, -211, -211, -210, -210, -210, -209, -209, -209, -208, -208, -208,
+    -208, -207, -207, -207, -206, -206, -206, -205, -205, -205, -204, -204,
+    -204, -204, -203, -203, -203, -202, -202, -202, -201, -201, -201, -201,
+    -200, -200, -200, -199, -199, -199, -198, -198, -198, -198, -197, -197,
+    -197, -196, -196, -196, -195, -195, -195, -195, -194, -194, -194, -193,
+    -193, -193, -192, -192, -192, -192, -191, -191, -191, -190, -190, -190,
+    -189, -189, -189, -189, -188, -188, -188, -187, -187, -187, -186, -186,
+    -186, -186, -185, -185, -185, -184, -184, -184, -183, -183, -183, -183,
+    -182, -182, -182, -181, -181, -181, -180, -180, -180, -180, -179, -179,
+    -179, -178, -178, -178, -177, -177, -177, -176, -176, -176, -176, -175,
+    -175, -175, -174, -174, -174, -173, -173, -173, -173, -172, -172, -172,
+    -171, -171, -171, -170, -170, -170, -170, -169, -169, -169, -168, -168,
+    -168, -167, -167, -167, -167, -166, -166, -166, -165, -165, -165, -164,
+    -164, -164, -164, -163, -163, -163, -162, -162, -162, -161, -161, -161,
+    -161, -160, -160, -160, -159, -159, -159, -158, -158, -158, -158, -157,
+    -157, -157, -156, -156, -156, -155, -155, -155, -155, -154, -154, -154,
+    -153, -153, -153, -152, -152, -152, -152, -151, -151, -151, -150, -150,
+    -150, -149, -149, -149, -149, -148, -148, -148, -147, -147, -147, -146,
+    -146, -146, -145, -145, -145, -145, -144, -144, -144, -143, -143, -143,
+    -142, -142, -142, -142, -141, -141, -141, -140, -140, -140, -139, -139,
+    -139, -139, -138, -138, -138, -137, -137, -137, -136, -136, -136, -136,
+    -135, -135, -135, -134, -134, -134, -133, -133, -133, -133, -132, -132,
+    -132, -131, -131, -131, -130, -130, -130, -130, -129, -129, -129, -128,
+    -128, -128, -127, -127, -127, -127, -126, -126, -126, -125, -125, -125,
+    -124, -124, -124, -124, -123, -123, -123, -122, -122, -122, -121, -121,
+    -121, -121, -120, -120, -120, -119, -119, -119, -118, -118, -118, -117,
+    -117, -117, -117, -116, -116, -116, -115, -115, -115, -114, -114, -114,
+    -114, -113, -113, -113, -112, -112, -112, -111, -111, -111, -111, -110,
+    -110, -110, -109, -109, -109, -108, -108, -108, -108, -107, -107, -107,
+    -106, -106, -106, -105, -105, -105, -105, -104, -104, -104, -103, -103,
+    -103, -102, -102, -102, -102, -101, -101, -101, -100, -100, -100, -99,
+    -99, -99, -99, -98, -98, -98, -97, -97, -97, -96, -96, -96,
+    -96, -95, -95, -95, -94, -94, -94, -93, -93, -93, -93, -92,
+    -92, -92, -91, -91, -91, -90, -90, -90, -89, -89, -89, -89,
+    -88, -88, -88, -87, -87, -87, -86, -86, -86, -86, -85, -85,
+    -85, -84, -84, -84, -83, -83, -83, -83, -82, -82, -82, -81,
+    -81, -81, -80, -80, -80, -80, -79, -79, -79, -78, -78, -78,
+    -77, -77, -77, -77, -76, -76, -76, -75, -75, -75, -74, -74,
+    -74, -74, -73, -73, -73, -72, -72, -72, -71, -71, -71, -71,
+    -70, -70, -70, -69, -69, -69, -68, -68, -68, -68, -67, -67,
+    -67, -66, -66, -66, -65, -65, -65, -65, -64, -64, -64, -63,
+    -63, -63, -62, -62, -62, -62, -61, -61, -61, -60, -60, -60,
+    -59, -59, -59, -58, -58, -58, -58, -57, -57, -57, -56, -56,
+    -56, -55, -55, -55, -55, -54, -54, -54, -53, -53, -53, -52,
+    -52, -52, -52, -51, -51, -51, -50, -50, -50, -49, -49, -49,
+    -49, -48, -48, -48, -47, -47, -47, -46, -46, -46, -46, -45,
+    -45, -45, -44, -44, -44, -43, -43, -43, -43, -42, -42, -42,
+    -41, -41, -41, -40, -40, -40, -40, -39, -39, -39, -38, -38,
+    -38, -37, -37, -37, -37, -36, -36, -36, -35, -35, -35, -34,
+    -34, -34, -34, -33, -33, -33, -32, -32, -32, -31, -31, -31,
+    -30, -30, -30, -30, -29, -29, -29, -28, -28, -28, -27, -27,
+    -27, -27, -26, -26, -26, -25, -25, -25, -24, -24, -24, -24,
+    -23, -23, -23, -22, -22, -22, -21, -21, -21, -21, -20, -20,
+    -20, -19, -19, -19, -18, -18, -18, -18, -17, -17, -17, -16,
+    -16, -16, -15, -15, -15, -15, -14, -14, -14, -13, -13, -13,
+    -12, -12, -12, -12, -11, -11, -11, -10, -10, -10, -9, -9,
+    -9, -9, -8, -8, -8, -7, -7, -7, -6, -6, -6, -6,
+    -5, -5, -5, -4, -4, -4, -3, -3, -3, -3, -2, -2,
+    -2, -1, -1, -1, 0, 0, 0, 1, 1, 1, 1, 2,
+    2, 2, 3, 3, 3, 4, 4, 4, 4, 5, 5, 5,
+    6, 6, 6, 7, 7, 7, 7, 8, 8, 8, 9, 9,
+    9, 10, 10, 10, 10, 11, 11, 11, 12, 12, 12, 13,
+    13, 13, 13, 14, 14, 14, 15, 15, 15, 16, 16, 16,
+    16, 17, 17, 17, 18, 18, 18, 19, 19, 19, 19, 20,
+    20, 20, 21, 21, 21, 22, 22, 22, 22, 23, 23, 23,
+    24, 24, 24, 25, 25, 25, 25, 26, 26, 26, 27, 27,
+    27, 28, 28, 28, 29, 29, 29, 29, 30, 30, 30, 31,
+    31, 31, 32, 32, 32, 32, 33, 33, 33, 34, 34, 34,
+    35, 35, 35, 35, 36, 36, 36, 37, 37, 37, 38, 38,
+    38, 38, 39, 39, 39, 40, 40, 40, 41, 41, 41, 41,
+    42, 42, 42, 43, 43, 43, 44, 44, 44, 44, 45, 45,
+    45, 46, 46, 46, 47, 47, 47, 47, 48, 48, 48, 49,
+    49, 49, 50, 50, 50, 50, 51, 51, 51, 52, 52, 52,
+    53, 53, 53, 53, 54, 54, 54, 55, 55, 55, 56, 56,
+    56, 56, 57, 57, 57, 58, 58, 58, 59, 59, 59, 60,
+    60, 60, 60, 61, 61, 61, 62, 62, 62, 63, 63, 63,
+    63, 64, 64, 64, 65, 65, 65, 66, 66, 66, 66, 67,
+    67, 67, 68, 68, 68, 69, 69, 69, 69, 70, 70, 70,
+    71, 71, 71, 72, 72, 72, 72, 73, 73, 73, 74, 74,
+    74, 75, 75, 75, 75, 76, 76, 76, 77, 77, 77, 78,
+    78, 78, 78, 79, 79, 79, 80, 80, 80, 81, 81, 81,
+    81, 82, 82, 82, 83, 83, 83, 84, 84, 84, 84, 85,
+    85, 85, 86, 86, 86, 87, 87, 87, 88, 88, 88, 88,
+    89, 89, 89, 90, 90, 90, 91, 91, 91, 91, 92, 92,
+    92, 93, 93, 93, 94, 94, 94, 94, 95, 95, 95, 96,
+    96, 96, 97, 97, 97, 97, 98, 98, 98, 99, 99, 99,
+    100, 100, 100, 100, 101, 101, 101, 102, 102, 102, 103, 103,
+    103, 103, 104, 104, 104, 105, 105, 105, 106, 106, 106, 106,
+    107, 107, 107, 108, 108, 108, 109, 109, 109, 109, 110, 110,
+    110, 111, 111, 111, 112, 112, 112, 112, 113, 113, 113, 114,
+    114, 114, 115, 115, 115, 116, 116, 116, 116, 117, 117, 117,
+    118, 118, 118, 119, 119, 119, 119, 120, 120, 120, 121, 121,
+    121, 122, 122, 122, 122, 123, 123, 123, 124, 124, 124, 125,
+    125, 125, 125, 126, 126, 126, 127, 127, 127, 128, 128, 128,
+    128, 129, 129, 129, 130, 130, 130, 131, 131, 131, 131, 132,
+    132, 132, 133, 133, 133, 134, 134, 134, 134, 135, 135, 135,
+    136, 136, 136, 137, 137, 137, 137, 138, 138, 138, 139, 139,
+    139, 140, 140, 140, 140, 141, 141, 141, 142, 142, 142, 143,
+    143, 143, 143, 144, 144, 144, 145, 145, 145, 146, 146, 146,
+    147, 147, 147, 147, 148, 148, 148, 149, 149, 149, 150, 150,
+    150, 150, 151, 151, 151, 152, 152, 152, 153, 153, 153, 153,
+    154, 154, 154, 155, 155, 155, 156, 156, 156, 156, 157, 157,
+    157, 158, 158, 158, 159, 159, 159, 159, 160, 160, 160, 161,
+    161, 161, 162, 162, 162, 162, 163, 163, 163, 164, 164, 164,
+    165, 165, 165, 165, 166, 166, 166, 167, 167, 167, 168, 168,
+    168, 168, 169, 169, 169, 170, 170, 170, 171, 171, 171, 171,
+    172, 172, 172, 173, 173, 173, 174, 174, 174, 175, 175, 175,
+    175, 176, 176, 176, 177, 177, 177, 178, 178, 178, 178, 179,
+    179, 179, 180, 180, 180, 181, 181, 181, 181, 182, 182, 182,
+    183, 183, 183, 184, 184, 184, 184, 185, 185, 185, 186, 186,
+    186, 187, 187, 187, 187, 188, 188, 188, 189, 189, 189, 190,
+    190, 190, 190, 191, 191, 191, 192, 192, 192, 193, 193, 193,
+    193, 194, 194, 194, 195, 195, 195, 196, 196, 196, 196, 197,
+    197, 197, 198, 198, 198, 199, 199, 199, 199, 200, 200, 200,
+    201, 201, 201, 202, 202, 202, 202, 203, 203, 203, 204, 204,
+    204, 205, 205, 205, 206, 206, 206, 206, 207, 207, 207, 208,
+    208, 208, 209, 209, 209, 209, 210, 210, 210, 211, 211, 211,
+    212, 212, 212, 212, 213, 213, 213, 214, 214, 214, 215, 215,
+    215, 215, 216, 216, 216, 217, 217, 217, 218, 218, 218, 218,
+    219, 219, 219, 220, 220, 220, 221, 221, 221, 221, 222, 222,
+    222, 223, 223, 223, 224, 224, 224, 224, 225, 225, 225, 226,
+    226, 226, 227, 227, 227, 227, 228, 228, 228, 229, 229, 229,
+    230, 230, 230, 230, 231, 231, 231, 232, 232, 232, 233, 233,
+    233, 234, 234, 234, 234, 235, 235, 235, 236, 236, 236, 237,
+    237, 237, 237, 238, 238, 238, 239, 239, 239, 240, 240, 240,
+    240, 241, 241, 241, 242, 242, 242, 243, 243, 243, 243, 244,
+    244, 244, 245, 245, 245, 246, 246, 246, 246, 247, 247, 247,
+    248, 248, 248, 249, 249, 249, 249, 250, 250, 250, 251, 251,
+    251, 252, 252, 252, 252, 253, 253, 253, 254, 254, 254, 255,
+    255, 255, 255, 256, 256, 256, 257, 257, 257, 258, 258, 258,
+    258, 259, 259, 259, 260, 260, 260, 261, 261, 261, 261, 262,
+    262, 262, 263, 263, 263, 264, 264, 264, 265, 265, 265, 265,
+    266, 266, 266, 267, 267, 267, 268, 268, 268, 268, 269, 269,
+    269, 270, 270, 270, 271, 271, 271, 271, 272, 272, 272, 273,
+    273, 273, 274, 274, 274, 274, 275, 275, 275, 276, 276, 276,
+    277, 277, 277, 277, 278, 278, 278, 279, 279, 279, 280, 280,
+    280, 280, 281, 281, 281, 282, 282, 282, 283, 283, 283, 283,
+    284, 284, 284, 285, 285, 285, 286, 286, 286, 286, 287, 287,
+    287, 288, 288, 288, 289, 289, 289, 289, 290, 290, 290, 291,
+    291, 291, 292, 292, 292, 293, 293, 293,
+};
+
+static const int16_t Formatter_DigitLowerTable[] =
+{
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'a', 'b', 'c', 'd', 'e', 'f'
+};
+
+static const int16_t Formatter_DigitUpperTable[] =
+{
+    '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F'
+};
+
+static const int64_t Formatter_TenPowersList[] =
+{
+    1LL,
+    10LL,
+    100LL,
+    1000LL,
+    10000LL,
+    100000LL,
+    1000000LL,
+    10000000LL,
+    100000000LL,
+    1000000000LL,
+    10000000000LL,
+    100000000000LL,
+    1000000000000LL,
+    10000000000000LL,
+    100000000000000LL,
+    1000000000000000LL,
+    10000000000000000LL,
+    100000000000000000LL,
+    1000000000000000000LL,
+};
+
+// DecHexDigits s a translation table from a decimal number to its
+// digits hexadecimal representation (e.g. DecHexDigits [34] = 0x34).
+static const int32_t Formatter_DecHexDigits[] =
+{
+    0x00, 0x01, 0x02, 0x03, 0x04, 0x05, 0x06, 0x07, 0x08, 0x09,
+    0x10, 0x11, 0x12, 0x13, 0x14, 0x15, 0x16, 0x17, 0x18, 0x19,
+    0x20, 0x21, 0x22, 0x23, 0x24, 0x25, 0x26, 0x27, 0x28, 0x29,
+    0x30, 0x31, 0x32, 0x33, 0x34, 0x35, 0x36, 0x37, 0x38, 0x39,
+    0x40, 0x41, 0x42, 0x43, 0x44, 0x45, 0x46, 0x47, 0x48, 0x49,
+    0x50, 0x51, 0x52, 0x53, 0x54, 0x55, 0x56, 0x57, 0x58, 0x59,
+    0x60, 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69,
+    0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79,
+    0x80, 0x81, 0x82, 0x83, 0x84, 0x85, 0x86, 0x87, 0x88, 0x89,
+    0x90, 0x91, 0x92, 0x93, 0x94, 0x95, 0x96, 0x97, 0x98, 0x99,
+};
+
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/il2cpp-runtime-metadata.h

@@ -0,0 +1,105 @@
+#pragma once
+
+#include <stdint.h>
+#include "il2cpp-blob.h"
+#include "il2cpp-metadata.h"
+
+struct Il2CppClass;
+struct MethodInfo;
+struct Il2CppType;
+
+typedef struct Il2CppArrayType
+{
+    const Il2CppType* etype;
+    uint8_t rank;
+    uint8_t numsizes;
+    uint8_t numlobounds;
+    int *sizes;
+    int *lobounds;
+} Il2CppArrayType;
+
+typedef struct Il2CppGenericInst
+{
+    uint32_t type_argc;
+    const Il2CppType **type_argv;
+} Il2CppGenericInst;
+
+typedef struct Il2CppGenericContext
+{
+    /* The instantiation corresponding to the class generic parameters */
+    const Il2CppGenericInst *class_inst;
+    /* The instantiation corresponding to the method generic parameters */
+    const Il2CppGenericInst *method_inst;
+} Il2CppGenericContext;
+
+typedef struct Il2CppGenericParameter
+{
+    GenericContainerIndex ownerIndex;  /* Type or method this parameter was defined in. */
+    StringIndex nameIndex;
+    GenericParameterConstraintIndex constraintsStart;
+    int16_t constraintsCount;
+    uint16_t num;
+    uint16_t flags;
+} Il2CppGenericParameter;
+
+typedef struct Il2CppGenericContainer
+{
+    /* index of the generic type definition or the generic method definition corresponding to this container */
+    int32_t ownerIndex; // either index into Il2CppClass metadata array or Il2CppMethodDefinition array
+    int32_t type_argc;
+    /* If true, we're a generic method, otherwise a generic type definition. */
+    int32_t is_method;
+    /* Our type parameters. */
+    GenericParameterIndex genericParameterStart;
+} Il2CppGenericContainer;
+
+typedef struct Il2CppGenericClass
+{
+    TypeDefinitionIndex typeDefinitionIndex;    /* the generic type definition */
+    Il2CppGenericContext context;   /* a context that contains the type instantiation doesn't contain any method instantiation */
+    Il2CppClass *cached_class;  /* if present, the Il2CppClass corresponding to the instantiation.  */
+} Il2CppGenericClass;
+
+typedef struct Il2CppGenericMethod
+{
+    const MethodInfo* methodDefinition;
+    Il2CppGenericContext context;
+} Il2CppGenericMethod;
+
+typedef struct Il2CppType
+{
+    union
+    {
+        // We have this dummy field first because pre C99 compilers (MSVC) can only initializer the first value in a union.
+        void* dummy;
+        TypeDefinitionIndex klassIndex; /* for VALUETYPE and CLASS */
+        const Il2CppType *type;   /* for PTR and SZARRAY */
+        Il2CppArrayType *array; /* for ARRAY */
+        //MonoMethodSignature *method;
+        GenericParameterIndex genericParameterIndex; /* for VAR and MVAR */
+        Il2CppGenericClass *generic_class; /* for GENERICINST */
+    } data;
+    unsigned int attrs    : 16; /* param attributes or field flags */
+    Il2CppTypeEnum type     : 8;
+    unsigned int num_mods : 6;  /* max 64 modifiers follow at the end */
+    unsigned int byref    : 1;
+    unsigned int pinned   : 1;  /* valid when included in a local var signature */
+    //MonoCustomMod modifiers [MONO_ZERO_LEN_ARRAY]; /* this may grow */
+} Il2CppType;
+
+typedef enum Il2CppCallConvention
+{
+    IL2CPP_CALL_DEFAULT,
+    IL2CPP_CALL_C,
+    IL2CPP_CALL_STDCALL,
+    IL2CPP_CALL_THISCALL,
+    IL2CPP_CALL_FASTCALL,
+    IL2CPP_CALL_VARARG
+} Il2CppCallConvention;
+
+typedef enum Il2CppCharSet
+{
+    CHARSET_ANSI,
+    CHARSET_UNICODE,
+    CHARSET_NOT_SPECIFIED
+} Il2CppCharSet;

App/LearnWithTouch_ios/Libraries/libil2cpp/include/il2cpp-string-types.h

@@ -0,0 +1,6 @@
+#pragma once
+#include "il2cpp-config.h"
+#include <string>
+
+typedef std::basic_string<Il2CppChar> UTF16String;
+typedef std::basic_string<Il2CppNativeChar> Il2CppNativeString;

App/LearnWithTouch_ios/Libraries/libil2cpp/include/il2cpp-tabledefs.h

@@ -0,0 +1,152 @@
+#pragma once
+
+/*
+ * Field Attributes (21.1.5).
+ */
+
+#define FIELD_ATTRIBUTE_FIELD_ACCESS_MASK     0x0007
+#define FIELD_ATTRIBUTE_COMPILER_CONTROLLED   0x0000
+#define FIELD_ATTRIBUTE_PRIVATE               0x0001
+#define FIELD_ATTRIBUTE_FAM_AND_ASSEM         0x0002
+#define FIELD_ATTRIBUTE_ASSEMBLY              0x0003
+#define FIELD_ATTRIBUTE_FAMILY                0x0004
+#define FIELD_ATTRIBUTE_FAM_OR_ASSEM          0x0005
+#define FIELD_ATTRIBUTE_PUBLIC                0x0006
+
+#define FIELD_ATTRIBUTE_STATIC                0x0010
+#define FIELD_ATTRIBUTE_INIT_ONLY             0x0020
+#define FIELD_ATTRIBUTE_LITERAL               0x0040
+#define FIELD_ATTRIBUTE_NOT_SERIALIZED        0x0080
+#define FIELD_ATTRIBUTE_SPECIAL_NAME          0x0200
+#define FIELD_ATTRIBUTE_PINVOKE_IMPL          0x2000
+
+/* For runtime use only */
+#define FIELD_ATTRIBUTE_RESERVED_MASK         0x9500
+#define FIELD_ATTRIBUTE_RT_SPECIAL_NAME       0x0400
+#define FIELD_ATTRIBUTE_HAS_FIELD_MARSHAL     0x1000
+#define FIELD_ATTRIBUTE_HAS_DEFAULT           0x8000
+#define FIELD_ATTRIBUTE_HAS_FIELD_RVA         0x0100
+
+/*
+ * Method Attributes (22.1.9)
+ */
+
+#define METHOD_IMPL_ATTRIBUTE_CODE_TYPE_MASK       0x0003
+#define METHOD_IMPL_ATTRIBUTE_IL                   0x0000
+#define METHOD_IMPL_ATTRIBUTE_NATIVE               0x0001
+#define METHOD_IMPL_ATTRIBUTE_OPTIL                0x0002
+#define METHOD_IMPL_ATTRIBUTE_RUNTIME              0x0003
+
+#define METHOD_IMPL_ATTRIBUTE_MANAGED_MASK         0x0004
+#define METHOD_IMPL_ATTRIBUTE_UNMANAGED            0x0004
+#define METHOD_IMPL_ATTRIBUTE_MANAGED              0x0000
+
+#define METHOD_IMPL_ATTRIBUTE_FORWARD_REF          0x0010
+#define METHOD_IMPL_ATTRIBUTE_PRESERVE_SIG         0x0080
+#define METHOD_IMPL_ATTRIBUTE_INTERNAL_CALL        0x1000
+#define METHOD_IMPL_ATTRIBUTE_SYNCHRONIZED         0x0020
+#define METHOD_IMPL_ATTRIBUTE_NOINLINING           0x0008
+#define METHOD_IMPL_ATTRIBUTE_MAX_METHOD_IMPL_VAL  0xffff
+
+#define METHOD_ATTRIBUTE_MEMBER_ACCESS_MASK        0x0007
+#define METHOD_ATTRIBUTE_COMPILER_CONTROLLED       0x0000
+#define METHOD_ATTRIBUTE_PRIVATE                   0x0001
+#define METHOD_ATTRIBUTE_FAM_AND_ASSEM             0x0002
+#define METHOD_ATTRIBUTE_ASSEM                     0x0003
+#define METHOD_ATTRIBUTE_FAMILY                    0x0004
+#define METHOD_ATTRIBUTE_FAM_OR_ASSEM              0x0005
+#define METHOD_ATTRIBUTE_PUBLIC                    0x0006
+
+#define METHOD_ATTRIBUTE_STATIC                    0x0010
+#define METHOD_ATTRIBUTE_FINAL                     0x0020
+#define METHOD_ATTRIBUTE_VIRTUAL                   0x0040
+#define METHOD_ATTRIBUTE_HIDE_BY_SIG               0x0080
+
+#define METHOD_ATTRIBUTE_VTABLE_LAYOUT_MASK        0x0100
+#define METHOD_ATTRIBUTE_REUSE_SLOT                0x0000
+#define METHOD_ATTRIBUTE_NEW_SLOT                  0x0100
+
+#define METHOD_ATTRIBUTE_STRICT                    0x0200
+#define METHOD_ATTRIBUTE_ABSTRACT                  0x0400
+#define METHOD_ATTRIBUTE_SPECIAL_NAME              0x0800
+
+#define METHOD_ATTRIBUTE_PINVOKE_IMPL              0x2000
+#define METHOD_ATTRIBUTE_UNMANAGED_EXPORT          0x0008
+
+/*
+ * For runtime use only
+ */
+#define METHOD_ATTRIBUTE_RESERVED_MASK             0xd000
+#define METHOD_ATTRIBUTE_RT_SPECIAL_NAME           0x1000
+#define METHOD_ATTRIBUTE_HAS_SECURITY              0x4000
+#define METHOD_ATTRIBUTE_REQUIRE_SEC_OBJECT        0x8000
+
+/*
+* Type Attributes (21.1.13).
+*/
+#define TYPE_ATTRIBUTE_VISIBILITY_MASK       0x00000007
+#define TYPE_ATTRIBUTE_NOT_PUBLIC            0x00000000
+#define TYPE_ATTRIBUTE_PUBLIC                0x00000001
+#define TYPE_ATTRIBUTE_NESTED_PUBLIC         0x00000002
+#define TYPE_ATTRIBUTE_NESTED_PRIVATE        0x00000003
+#define TYPE_ATTRIBUTE_NESTED_FAMILY         0x00000004
+#define TYPE_ATTRIBUTE_NESTED_ASSEMBLY       0x00000005
+#define TYPE_ATTRIBUTE_NESTED_FAM_AND_ASSEM  0x00000006
+#define TYPE_ATTRIBUTE_NESTED_FAM_OR_ASSEM   0x00000007
+
+#define TYPE_ATTRIBUTE_LAYOUT_MASK           0x00000018
+#define TYPE_ATTRIBUTE_AUTO_LAYOUT           0x00000000
+#define TYPE_ATTRIBUTE_SEQUENTIAL_LAYOUT     0x00000008
+#define TYPE_ATTRIBUTE_EXPLICIT_LAYOUT       0x00000010
+
+#define TYPE_ATTRIBUTE_CLASS_SEMANTIC_MASK   0x00000020
+#define TYPE_ATTRIBUTE_CLASS                 0x00000000
+#define TYPE_ATTRIBUTE_INTERFACE             0x00000020
+
+#define TYPE_ATTRIBUTE_ABSTRACT              0x00000080
+#define TYPE_ATTRIBUTE_SEALED                0x00000100
+#define TYPE_ATTRIBUTE_SPECIAL_NAME          0x00000400
+
+#define TYPE_ATTRIBUTE_IMPORT                0x00001000
+#define TYPE_ATTRIBUTE_SERIALIZABLE          0x00002000
+
+#define TYPE_ATTRIBUTE_STRING_FORMAT_MASK    0x00030000
+#define TYPE_ATTRIBUTE_ANSI_CLASS            0x00000000
+#define TYPE_ATTRIBUTE_UNICODE_CLASS         0x00010000
+#define TYPE_ATTRIBUTE_AUTO_CLASS            0x00020000
+
+#define TYPE_ATTRIBUTE_BEFORE_FIELD_INIT     0x00100000
+#define TYPE_ATTRIBUTE_FORWARDER             0x00200000
+
+#define TYPE_ATTRIBUTE_RESERVED_MASK         0x00040800
+#define TYPE_ATTRIBUTE_RT_SPECIAL_NAME       0x00000800
+#define TYPE_ATTRIBUTE_HAS_SECURITY          0x00040000
+
+/*
+* Flags for Params (22.1.12)
+*/
+#define PARAM_ATTRIBUTE_IN                 0x0001
+#define PARAM_ATTRIBUTE_OUT                0x0002
+#define PARAM_ATTRIBUTE_OPTIONAL           0x0010
+#define PARAM_ATTRIBUTE_RESERVED_MASK      0xf000
+#define PARAM_ATTRIBUTE_HAS_DEFAULT        0x1000
+#define PARAM_ATTRIBUTE_HAS_FIELD_MARSHAL  0x2000
+#define PARAM_ATTRIBUTE_UNUSED             0xcfe0
+
+// Flags for Generic Parameters (II.23.1.7)
+#define IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_NON_VARIANT                           0x00
+#define IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_COVARIANT                             0x01
+#define IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_CONTRAVARIANT                         0x02
+#define IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_VARIANCE_MASK                         0x03
+#define IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_REFERENCE_TYPE_CONSTRAINT             0x04
+#define IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_NOT_NULLABLE_VALUE_TYPE_CONSTRAINT    0x08
+#define IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_DEFAULT_CONSTRUCTOR_CONSTRAINT        0x10
+#define IL2CPP_GENERIC_PARAMETER_ATTRIBUTE_SPECIAL_CONSTRAINT_MASK               0x1C
+
+/**
+ * 21.5 AssemblyRefs
+ */
+#define ASSEMBLYREF_FULL_PUBLIC_KEY_FLAG      0x00000001
+#define ASSEMBLYREF_RETARGETABLE_FLAG         0x00000100
+#define ASSEMBLYREF_ENABLEJITCOMPILE_TRACKING_FLAG 0x00008000
+#define ASSEMBLYREF_DISABLEJITCOMPILE_OPTIMIZER_FLAG 0x00004000

App/LearnWithTouch_ios/Libraries/libil2cpp/include/il2cpp-vm-support.h

@@ -0,0 +1,69 @@
+#pragma once
+
+#include "il2cpp-config.h"
+
+// This file is a compile-time abstraction for VM support needed by code in the os and utils namespaces that is used by both the
+// libil2cpp and the libmono runtimes. Code in those namespaces should never depend up on the vm namespace directly.
+
+#if defined(RUNTIME_MONO)
+    #include "mono-api.h"
+    #include "il2cpp-mono-support.h"
+    #include <cassert>
+    #define IL2CPP_VM_RAISE_EXCEPTION(exception) mono_raise_exception(exception)
+    #define IL2CPP_VM_RAISE_COM_EXCEPTION(hresult, defaultToCOMException) assert(false && "COM exceptions are not implemented yet.")
+    #define IL2CPP_VM_RAISE_UNAUTHORIZED_ACCESS_EXCEPTION(message) mono_raise_exception(mono_exception_from_name_msg(mono_get_corlib (), "System.Security", "UnauthorizedAccessException", message))
+    #define IL2CPP_VM_RAISE_PLATFORM_NOT_SUPPORTED_EXCEPTION(message) mono_raise_exception(mono_exception_from_name_msg(mono_get_corlib (), "System.Security", "PlatformNotSupportedException", message))
+    #define IL2CPP_VM_RAISE_IF_FAILED(hresult, defaultToCOMException) assert(false && "COM exceptions are not implemented yet.")
+    #define IL2CPP_VM_STRING_EMPTY() mono_string_empty(g_MonoDomain)
+    #define IL2CPP_VM_STRING_NEW_UTF16(value, length) mono_string_new_utf16(g_MonoDomain, value, length)
+    #define IL2CPP_VM_STRING_NEW_LEN(value, length) mono_string_new_len(g_MonoDomain, value, length);
+    #define IL2CPP_VM_NOT_SUPPORTED(func, reason) mono_raise_exception(mono_get_exception_not_supported(NOTSUPPORTEDICALLMESSAGE ("IL2CPP", #func, #reason)))
+    #define IL2CPP_VM_NOT_IMPLEMENTED(func) mono_raise_exception(mono_get_exception_not_supported(NOTSUPPORTEDICALLMESSAGE ("IL2CPP", #func)))
+    #define IL2CPP_VM_METHOD_METADATA_FROM_INDEX(isGeneric, methodIndex) isGeneric ? GenericMethodFromIndex(methodIndex) : MethodFromIndex(methodIndex)
+    #define IL2CPP_VM_SHUTDOWN() do { if (mono_runtime_try_shutdown()) mono_runtime_quit(); } while(0)
+    #define IL2CPP_VM_GET_CREATE_CCW_EXCEPTION(ex) NULL
+//    #define IL2CPP_VM_PROFILE_FILEIO(kind, count) if (mono_profiler_get_events () & MONO_PROFILE_FILEIO) mono_profiler_fileio (kind, count);
+// FIXME fix profiler under mono
+    #define IL2CPP_VM_PROFILE_FILEIO(kind, count)
+
+typedef MonoString VmString;
+typedef MonoMethod VmMethod;
+#elif RUNTIME_NONE // OS layer compiled with no runtime
+    #define IL2CPP_VM_RAISE_EXCEPTION(exception) IL2CPP_ASSERT(0 && "This is not implemented without a VM runtime backend.")
+    #define IL2CPP_VM_RAISE_COM_EXCEPTION(hresult, defaultToCOMException) IL2CPP_ASSERT(0 && "This is not implemented without a VM runtime backend.")
+    #define IL2CPP_VM_RAISE_UNAUTHORIZED_ACCESS_EXCEPTION(message) IL2CPP_ASSERT(0 && message)
+    #define IL2CPP_VM_RAISE_PLATFORM_NOT_SUPPORTED_EXCEPTION(message) IL2CPP_ASSERT(0 && message)
+    #define IL2CPP_VM_RAISE_IF_FAILED(hresult, defaultToCOMException) IL2CPP_ASSERT(0 && "This is not implemented without a VM runtime backend.")
+    #define IL2CPP_VM_STRING_EMPTY() NULL
+    #define IL2CPP_VM_STRING_NEW_UTF16(value, length) NULL
+    #define IL2CPP_VM_STRING_NEW_LEN(value, length) NULL
+    #define IL2CPP_VM_NOT_SUPPORTED(func, reason) IL2CPP_ASSERT(0 && "This is not implemented without a VM runtime backend.")
+    #define IL2CPP_VM_NOT_IMPLEMENTED(func) IL2CPP_ASSERT(0 && "This is not implemented without a VM runtime backend.")
+    #define IL2CPP_VM_METHOD_METADATA_FROM_INDEX(isGeneric, methodIndex) IL2CPP_ASSERT(0 && "This is not implemented wihout a VM runtime backend.")
+    #define IL2CPP_VM_SHUTDOWN() IL2CPP_ASSERT(0 && "This is not implemented without a VM runtime backend.")
+    #define IL2CPP_VM_GET_CREATE_CCW_EXCEPTION(ex) NULL
+    #define IL2CPP_VM_PROFILE_FILEIO(kind, count) NULL
+#else // Assume the libil2cpp runtime
+    #include "vm/Exception.h"
+    #include "vm/MetadataCache.h"
+    #include "vm/StackTrace.h"
+    #include "vm/String.h"
+    #include "vm/Profiler.h"
+    #define IL2CPP_VM_RAISE_EXCEPTION(exception) il2cpp::vm::Exception::Raise(exception)
+    #define IL2CPP_VM_RAISE_COM_EXCEPTION(hresult, defaultToCOMException) il2cpp::vm::Exception::Raise(hresult, defaultToCOMException)
+    #define IL2CPP_VM_RAISE_UNAUTHORIZED_ACCESS_EXCEPTION(message) il2cpp::vm::Exception::Raise(il2cpp::vm::Exception::GetUnauthorizedAccessException(message))
+    #define IL2CPP_VM_RAISE_PLATFORM_NOT_SUPPORTED_EXCEPTION(message) il2cpp::vm::Exception::Raise(il2cpp::vm::Exception::GetPlatformNotSupportedException(message))
+    #define IL2CPP_VM_RAISE_IF_FAILED(hresult, defaultToCOMException) il2cpp::vm::Exception::RaiseIfFailed(hresult, defaultToCOMException)
+    #define IL2CPP_VM_STRING_EMPTY() il2cpp::vm::String::Empty()
+    #define IL2CPP_VM_STRING_NEW_UTF16(value, length) il2cpp::vm::String::NewUtf16(value, length)
+    #define IL2CPP_VM_STRING_NEW_LEN(value, length) il2cpp::vm::String::NewLen(value, length)
+    #define IL2CPP_VM_NOT_SUPPORTED(func, reason) NOT_SUPPORTED_IL2CPP(func, reason)
+    #define IL2CPP_VM_NOT_IMPLEMENTED(func) IL2CPP_NOT_IMPLEMENTED_ICALL(func)
+    #define IL2CPP_VM_METHOD_METADATA_FROM_INDEX(isGeneric, methodIndex) il2cpp::vm::MetadataCache::GetMethodInfoFromMethodDefinitionIndex (methodIndex)
+    #define IL2CPP_VM_SHUTDOWN() il2cpp_shutdown()
+    #define IL2CPP_VM_GET_CREATE_CCW_EXCEPTION(ex) vm::CCW::GetOrCreate(reinterpret_cast<Il2CppObject*>(ex), Il2CppIUnknown::IID)
+    #define IL2CPP_VM_PROFILE_FILEIO(kind, count) if (il2cpp::vm::Profiler::ProfileFileIO()) il2cpp::vm::Profiler::FileIO(kind, count);
+
+typedef Il2CppString VmString;
+typedef MethodInfo VmMethod;
+#endif

App/LearnWithTouch_ios/Libraries/libil2cpp/include/libil2cpp.def

@@ -0,0 +1,158 @@
+LIBRARY libil2cpp.dll
+EXPORTS
+
+il2cpp_init
+il2cpp_shutdown
+il2cpp_set_config_dir
+il2cpp_set_data_dir
+il2cpp_set_temp_dir
+il2cpp_set_commandline_arguments
+il2cpp_set_memory_callbacks
+il2cpp_get_corlib
+il2cpp_add_internal_call
+il2cpp_resolve_icall
+
+il2cpp_alloc
+il2cpp_free
+
+il2cpp_array_class_get
+il2cpp_array_length
+il2cpp_array_get_byte_length
+il2cpp_array_new
+il2cpp_array_new_specific
+il2cpp_array_new_full
+il2cpp_bounded_array_class_get
+il2cpp_array_element_size
+
+il2cpp_assembly_get_image
+
+il2cpp_class_enum_basetype
+il2cpp_class_is_generic
+il2cpp_class_is_assignable_from
+il2cpp_class_is_subclass_of
+il2cpp_class_from_il2cpp_type
+il2cpp_class_from_name
+il2cpp_class_from_system_type
+il2cpp_class_get_declaring_type
+il2cpp_class_get_element_class
+il2cpp_class_get_fields
+il2cpp_class_get_nested_types
+il2cpp_class_get_field_from_name
+il2cpp_class_get_interfaces
+il2cpp_class_get_methods
+il2cpp_class_get_method_from_name
+il2cpp_class_get_name
+il2cpp_class_get_namespace
+il2cpp_class_get_parent
+il2cpp_class_get_properties
+il2cpp_class_get_property_from_name
+il2cpp_class_instance_size
+il2cpp_class_num_fields
+il2cpp_class_is_valuetype
+il2cpp_class_is_blittable
+il2cpp_class_value_size
+il2cpp_class_get_flags
+il2cpp_class_is_abstract
+il2cpp_class_is_interface
+il2cpp_class_array_element_size
+il2cpp_class_from_type
+il2cpp_class_get_type
+il2cpp_class_has_attribute
+il2cpp_class_has_references
+il2cpp_class_is_enum
+il2cpp_class_get_image
+il2cpp_class_get_assemblyname
+
+il2cpp_domain_get
+il2cpp_domain_assembly_open
+
+il2cpp_raise_exception
+il2cpp_exception_from_name_msg
+il2cpp_get_exception_argument_null
+
+il2cpp_field_get_flags
+il2cpp_field_get_name
+il2cpp_field_get_parent
+il2cpp_field_get_offset
+il2cpp_field_get_type
+il2cpp_field_get_value
+il2cpp_field_get_value_object
+il2cpp_field_has_attribute
+il2cpp_field_set_value
+il2cpp_field_static_get_value
+il2cpp_field_static_set_value
+il2cpp_field_set_value_object
+
+il2cpp_gc_collect
+il2cpp_gc_collect_a_little
+il2cpp_gc_disable
+il2cpp_gc_enable
+il2cpp_gc_get_used_size
+il2cpp_gc_get_heap_size
+
+il2cpp_gchandle_new
+il2cpp_gchandle_new_weakref
+il2cpp_gchandle_get_target
+il2cpp_gchandle_free
+
+il2cpp_unity_liveness_calculation_begin
+il2cpp_unity_liveness_calculation_end
+il2cpp_unity_liveness_calculation_from_root
+il2cpp_unity_liveness_calculation_from_statics
+
+il2cpp_method_get_return_type
+il2cpp_method_get_name
+il2cpp_method_get_object
+il2cpp_method_is_instance
+il2cpp_method_get_param_count
+il2cpp_method_get_param
+il2cpp_method_get_class
+il2cpp_method_has_attribute
+
+il2cpp_profiler_install
+il2cpp_profiler_set_events
+il2cpp_profiler_install_enter_leave
+il2cpp_profiler_install_allocation
+il2cpp_profiler_install_gc
+
+il2cpp_property_get_flags
+il2cpp_property_get_get_method
+il2cpp_property_get_set_method
+il2cpp_property_get_name
+il2cpp_property_get_parent
+
+il2cpp_object_get_class
+il2cpp_object_get_size
+il2cpp_object_get_virtual_method
+il2cpp_object_new
+il2cpp_object_unbox
+
+il2cpp_value_box
+
+il2cpp_runtime_invoke
+il2cpp_runtime_invoke_convert_args
+il2cpp_runtime_class_init
+il2cpp_runtime_object_init
+il2cpp_runtime_object_init_exception
+il2cpp_runtime_unhandled_exception_policy_set
+
+il2cpp_string_length
+il2cpp_string_chars
+il2cpp_string_new
+il2cpp_string_new_len
+il2cpp_string_new_utf16
+il2cpp_string_new_wrapper
+
+il2cpp_thread_current
+il2cpp_thread_attach
+il2cpp_thread_detach
+
+il2cpp_type_get_object
+il2cpp_type_get_type
+il2cpp_type_get_class_or_element_class
+il2cpp_type_get_name
+il2cpp_type_equals
+
+il2cpp_unity_install_unitytls_interface
+
+____visualizerHelpersPreventLinkerStripping @65535 NONAME DATA

App/LearnWithTouch_ios/Libraries/libil2cpp/include/metadata/ArrayMetadata.h

@@ -0,0 +1,25 @@
+#pragma once
+
+#include <stdint.h>
+#include "os/Mutex.h"
+struct Il2CppClass;
+
+namespace il2cpp
+{
+namespace metadata
+{
+    class ArrayMetadata
+    {
+    public:
+        static Il2CppClass* GetBoundedArrayClass(Il2CppClass* elementClass, uint32_t rank, bool bounded);
+
+        typedef void(*ArrayTypeWalkCallback)(Il2CppClass* type, void* context);
+        static void WalkSZArrays(ArrayTypeWalkCallback callback, void* context);
+        static void WalkArrays(ArrayTypeWalkCallback callback, void* context);
+
+        // called as part of Class::Init with lock held
+        static void SetupArrayInterfaces(Il2CppClass* klass, const il2cpp::os::FastAutoLock& lock);
+        static void SetupArrayVTable(Il2CppClass* klass, const il2cpp::os::FastAutoLock& lock);
+    };
+} /* namespace vm */
+} /* namespace il2cpp */