Initial commit.

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 */