#pragma clang diagnostic ignored "-Wdeprecated-declarations"
#pragma clang diagnostic ignored "-Wtypedef-redefinition"
#pragma clang diagnostic ignored "-Wobjc-designated-initializers"
#include <stdarg.h>
#include <xamarin/xamarin.h>
#include <objc/objc.h>
#include <objc/runtime.h>
#include <objc/message.h>
#import <Foundation/Foundation.h>
#import <UIKit/UIKit.h>
#import <Photos/Photos.h>
#import <QuartzCore/QuartzCore.h>
#import <QuartzCore/CAEmitterBehavior.h>
#import <AssetsLibrary/AssetsLibrary.h>
#import <AVFoundation/AVFoundation.h>
#import <CoreGraphics/CoreGraphics.h>


static void native_to_managed_trampoline_1 (id self, SEL _cmd, MonoMethod **managed_method_ptr, const char *r0, const char *r1)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [0];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r0, r1, 0, NULL));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static BOOL native_to_managed_trampoline_2 (id self, SEL _cmd, MonoMethod **managed_method_ptr, void * p0, const char *r0, const char *r1, const char *r2)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [1];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[1] = { r0 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r1, r2, 1, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    void * a0 = p0;
    arg_ptrs [0] = &a0;

    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    BOOL res;
    res = *(BOOL *) mono_object_unbox ((MonoObject *) retval);

    return res;
}


static void native_to_managed_trampoline_3 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UIImage * p0, NSError * p1, void * p2, const char *r0, const char *r1, const char *r2, const char *r3, const char *r4)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [3];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[3] = { r0, r1, r2 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r3, r4, 3, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    NSObject *nsobj1 = (NSObject *) p1;
    MonoObject *mobj1 = NULL;
    int32_t created1 = false;
    if (nsobj1) {
        MonoType *paramtype1 = xamarin_get_parameter_type (managed_method, 1);
        mobj1 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj1, false, paramtype1, &created1);
    }
    arg_ptrs [1] = mobj1;
    void * a2 = p2;
    arg_ptrs [2] = &a2;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static UIWindow * native_to_managed_trampoline_4 (id self, SEL _cmd, MonoMethod **managed_method_ptr, const char *r0, const char *r1)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [0];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r0, r1, 0, NULL));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    UIWindow * res;
    if (!retval) {
        res = NULL;
    } else {
        id retobj;
        retobj = xamarin_get_nsobject_handle (retval);
        xamarin_framework_peer_lock ();
        [retobj retain];
        xamarin_framework_peer_unlock ();
        [retobj autorelease];
        mt_dummy_use (retval);
        res = retobj;
    }

    return res;
}


static void native_to_managed_trampoline_5 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UIWindow * p0, const char *r0, const char *r1, const char *r2)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [1];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[1] = { r0 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r1, r2, 1, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static BOOL native_to_managed_trampoline_6 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UIApplication * p0, NSDictionary * p1, const char *r0, const char *r1, const char *r2, const char *r3)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    NSObject *nsobj1 = (NSObject *) p1;
    MonoObject *mobj1 = NULL;
    int32_t created1 = false;
    if (nsobj1) {
        MonoType *paramtype1 = xamarin_get_parameter_type (managed_method, 1);
        mobj1 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj1, false, paramtype1, &created1);
    }
    arg_ptrs [1] = mobj1;

    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    BOOL res;
    res = *(BOOL *) mono_object_unbox ((MonoObject *) retval);

    return res;
}


static void native_to_managed_trampoline_7 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UIApplication * p0, const char *r0, const char *r1, const char *r2)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [1];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[1] = { r0 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r1, r2, 1, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static id native_to_managed_trampoline_8 (id self, SEL _cmd, MonoMethod **managed_method_ptr, const char *r0, const char *r1, bool* call_super)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [0];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    if (xamarin_try_get_nsobject (self)) {
        *call_super = true;
        return self;
    }
    if (!managed_method) {
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r0, r1, 0, NULL));
        *managed_method_ptr = managed_method;
    }
    mthis = mono_object_new (mono_domain_get (), mono_method_get_class (managed_method));
    uint8_t flags = NSObjectFlagsNativeRef;
    xamarin_set_nsobject_handle (mthis, self);
    xamarin_set_nsobject_flags (mthis, flags);
    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);
    xamarin_create_managed_ref (self, mthis, true);

    return self;
}


static void native_to_managed_trampoline_9 (id self, SEL _cmd, MonoMethod **managed_method_ptr, BOOL p0, const char *r0, const char *r1, const char *r2)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [1];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[1] = { r0 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r1, r2, 1, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    arg_ptrs [0] = &p0;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static void native_to_managed_trampoline_10 (id self, SEL _cmd, MonoMethod **managed_method_ptr, NSObject * p0, const char *r0, const char *r1, const char *r2)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [1];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[1] = { r0 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r1, r2, 1, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static void native_to_managed_trampoline_11 (id self, SEL _cmd, MonoMethod **managed_method_ptr, NSObject * p0, const char *r0, const char *r1, const char *r2)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [1];
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    if (!managed_method) {
        const char *paramptr[1] = { r0 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r1, r2, 1, paramptr));
        *managed_method_ptr = managed_method;
    }
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;

    mono_runtime_invoke (managed_method, NULL, arg_ptrs, NULL);

    return;
}


static void native_to_managed_trampoline_12 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UIScrollView * p0, const char *r0, const char *r1, const char *r2)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [1];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[1] = { r0 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r1, r2, 1, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static void native_to_managed_trampoline_13 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UIScrollView * p0, BOOL p1, const char *r0, const char *r1, const char *r2, const char *r3)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    arg_ptrs [1] = &p1;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static BOOL native_to_managed_trampoline_14 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UIScrollView * p0, const char *r0, const char *r1, const char *r2)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [1];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[1] = { r0 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r1, r2, 1, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;

    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    BOOL res;
    res = *(BOOL *) mono_object_unbox ((MonoObject *) retval);

    return res;
}


static UIView * native_to_managed_trampoline_15 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UIScrollView * p0, const char *r0, const char *r1, const char *r2)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [1];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[1] = { r0 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r1, r2, 1, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;

    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    UIView * res;
    if (!retval) {
        res = NULL;
    } else {
        id retobj;
        retobj = xamarin_get_nsobject_handle (retval);
        xamarin_framework_peer_lock ();
        [retobj retain];
        xamarin_framework_peer_unlock ();
        [retobj autorelease];
        mt_dummy_use (retval);
        res = retobj;
    }

    return res;
}


static void native_to_managed_trampoline_16 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UIScrollView * p0, CGPoint p1, CGPoint* p2, const char *r0, const char *r1, const char *r2, const char *r3, const char *r4)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [3];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[3] = { r0, r1, r2 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r3, r4, 3, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    arg_ptrs [1] = &p1;
    arg_ptrs [2] = p2;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static void native_to_managed_trampoline_17 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UIScrollView * p0, UIView * p1, CGFloat p2, const char *r0, const char *r1, const char *r2, const char *r3, const char *r4)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [3];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[3] = { r0, r1, r2 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r3, r4, 3, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    NSObject *nsobj1 = (NSObject *) p1;
    MonoObject *mobj1 = NULL;
    int32_t created1 = false;
    if (nsobj1) {
        MonoType *paramtype1 = xamarin_get_parameter_type (managed_method, 1);
        mobj1 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj1, false, paramtype1, &created1);
    }
    arg_ptrs [1] = mobj1;
    arg_ptrs [2] = &p2;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static void native_to_managed_trampoline_18 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UIScrollView * p0, UIView * p1, const char *r0, const char *r1, const char *r2, const char *r3)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    NSObject *nsobj1 = (NSObject *) p1;
    MonoObject *mobj1 = NULL;
    int32_t created1 = false;
    if (nsobj1) {
        MonoType *paramtype1 = xamarin_get_parameter_type (managed_method, 1);
        mobj1 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj1, false, paramtype1, &created1);
    }
    arg_ptrs [1] = mobj1;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static void native_to_managed_trampoline_19 (id self, SEL _cmd, MonoMethod **managed_method_ptr, BOOL p0, BOOL p1, const char *r0, const char *r1, const char *r2, const char *r3)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    arg_ptrs [0] = &p0;
    arg_ptrs [1] = &p1;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static id native_to_managed_trampoline_20 (id self, SEL _cmd, MonoMethod **managed_method_ptr, NSInteger p0, NSString * p1, const char *r0, const char *r1, const char *r2, const char *r3, bool* call_super)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    if (xamarin_try_get_nsobject (self)) {
        *call_super = true;
        return self;
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    long long nativeEnum0 = p0;
    arg_ptrs [0] = &nativeEnum0;
    arg_ptrs [1] = p1 ? mono_string_new (mono_domain_get (), [p1 UTF8String]) : NULL;

    mthis = mono_object_new (mono_domain_get (), mono_method_get_class (managed_method));
    uint8_t flags = NSObjectFlagsNativeRef;
    xamarin_set_nsobject_handle (mthis, self);
    xamarin_set_nsobject_flags (mthis, flags);
    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);
    xamarin_create_managed_ref (self, mthis, true);

    return self;
}


static BOOL native_to_managed_trampoline_21 (id self, SEL _cmd, MonoMethod **managed_method_ptr, const char *r0, const char *r1)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [0];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r0, r1, 0, NULL));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    BOOL res;
    res = *(BOOL *) mono_object_unbox ((MonoObject *) retval);

    return res;
}


static id native_to_managed_trampoline_22 (id self, SEL _cmd, MonoMethod **managed_method_ptr, CGRect p0, const char *r0, const char *r1, const char *r2, bool* call_super)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [1];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    if (xamarin_try_get_nsobject (self)) {
        *call_super = true;
        return self;
    }
    if (!managed_method) {
        const char *paramptr[1] = { r0 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r1, r2, 1, paramptr));
        *managed_method_ptr = managed_method;
    }
    arg_ptrs [0] = &p0;

    mthis = mono_object_new (mono_domain_get (), mono_method_get_class (managed_method));
    uint8_t flags = NSObjectFlagsNativeRef;
    xamarin_set_nsobject_handle (mthis, self);
    xamarin_set_nsobject_flags (mthis, flags);
    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);
    xamarin_create_managed_ref (self, mthis, true);

    return self;
}


static void native_to_managed_trampoline_23 (id self, SEL _cmd, MonoMethod **managed_method_ptr, PHChange * p0, const char *r0, const char *r1, const char *r2)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [1];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[1] = { r0 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r1, r2, 1, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static NSInteger native_to_managed_trampoline_24 (id self, SEL _cmd, MonoMethod **managed_method_ptr, const char *r0, const char *r1)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [0];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r0, r1, 0, NULL));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    NSInteger res;
    res = *(NSInteger *) mono_object_unbox ((MonoObject *) retval);

    return res;
}


static void native_to_managed_trampoline_25 (id self, SEL _cmd, MonoMethod **managed_method_ptr, NSInteger p0, double p1, const char *r0, const char *r1, const char *r2, const char *r3)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    long long nativeEnum0 = p0;
    arg_ptrs [0] = &nativeEnum0;
    arg_ptrs [1] = &p1;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static NSUInteger native_to_managed_trampoline_26 (id self, SEL _cmd, MonoMethod **managed_method_ptr, const char *r0, const char *r1)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [0];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r0, r1, 0, NULL));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    NSUInteger res;
    res = *(NSUInteger *) mono_object_unbox ((MonoObject *) retval);

    return res;
}


static NSInteger native_to_managed_trampoline_27 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UICollectionView * p0, const char *r0, const char *r1, const char *r2)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [1];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[1] = { r0 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r1, r2, 1, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;

    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    NSInteger res;
    res = *(NSInteger *) mono_object_unbox ((MonoObject *) retval);

    return res;
}


static UICollectionViewCell * native_to_managed_trampoline_28 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UICollectionView * p0, NSIndexPath * p1, const char *r0, const char *r1, const char *r2, const char *r3)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    NSObject *nsobj1 = (NSObject *) p1;
    MonoObject *mobj1 = NULL;
    int32_t created1 = false;
    if (nsobj1) {
        MonoType *paramtype1 = xamarin_get_parameter_type (managed_method, 1);
        mobj1 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj1, false, paramtype1, &created1);
    }
    arg_ptrs [1] = mobj1;

    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    UICollectionViewCell * res;
    if (!retval) {
        res = NULL;
    } else {
        id retobj;
        retobj = xamarin_get_nsobject_handle (retval);
        xamarin_framework_peer_lock ();
        [retobj retain];
        xamarin_framework_peer_unlock ();
        [retobj autorelease];
        mt_dummy_use (retval);
        res = retobj;
    }

    return res;
}


static NSInteger native_to_managed_trampoline_29 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UICollectionView * p0, NSInteger p1, const char *r0, const char *r1, const char *r2, const char *r3)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    arg_ptrs [1] = &p1;

    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    NSInteger res;
    res = *(NSInteger *) mono_object_unbox ((MonoObject *) retval);

    return res;
}


static void native_to_managed_trampoline_30 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UICollectionView * p0, NSIndexPath * p1, const char *r0, const char *r1, const char *r2, const char *r3)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    NSObject *nsobj1 = (NSObject *) p1;
    MonoObject *mobj1 = NULL;
    int32_t created1 = false;
    if (nsobj1) {
        MonoType *paramtype1 = xamarin_get_parameter_type (managed_method, 1);
        mobj1 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj1, false, paramtype1, &created1);
    }
    arg_ptrs [1] = mobj1;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static BOOL native_to_managed_trampoline_31 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UICollectionView * p0, NSIndexPath * p1, const char *r0, const char *r1, const char *r2, const char *r3)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    NSObject *nsobj1 = (NSObject *) p1;
    MonoObject *mobj1 = NULL;
    int32_t created1 = false;
    if (nsobj1) {
        MonoType *paramtype1 = xamarin_get_parameter_type (managed_method, 1);
        mobj1 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj1, false, paramtype1, &created1);
    }
    arg_ptrs [1] = mobj1;

    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    BOOL res;
    res = *(BOOL *) mono_object_unbox ((MonoObject *) retval);

    return res;
}


static void native_to_managed_trampoline_32 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UIImagePickerController * p0, NSDictionary * p1, const char *r0, const char *r1, const char *r2, const char *r3)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    NSObject *nsobj1 = (NSObject *) p1;
    MonoObject *mobj1 = NULL;
    int32_t created1 = false;
    if (nsobj1) {
        MonoType *paramtype1 = xamarin_get_parameter_type (managed_method, 1);
        mobj1 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj1, false, paramtype1, &created1);
    }
    arg_ptrs [1] = mobj1;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static void native_to_managed_trampoline_33 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UIImagePickerController * p0, const char *r0, const char *r1, const char *r2)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [1];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[1] = { r0 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r1, r2, 1, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static NSInteger native_to_managed_trampoline_34 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UITableView * p0, const char *r0, const char *r1, const char *r2)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [1];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[1] = { r0 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r1, r2, 1, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;

    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    NSInteger res;
    res = *(NSInteger *) mono_object_unbox ((MonoObject *) retval);

    return res;
}


static NSInteger native_to_managed_trampoline_35 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UITableView * p0, NSInteger p1, const char *r0, const char *r1, const char *r2, const char *r3)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    arg_ptrs [1] = &p1;

    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    NSInteger res;
    res = *(NSInteger *) mono_object_unbox ((MonoObject *) retval);

    return res;
}


static UITableViewCell * native_to_managed_trampoline_36 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UITableView * p0, NSIndexPath * p1, const char *r0, const char *r1, const char *r2, const char *r3)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    NSObject *nsobj1 = (NSObject *) p1;
    MonoObject *mobj1 = NULL;
    int32_t created1 = false;
    if (nsobj1) {
        MonoType *paramtype1 = xamarin_get_parameter_type (managed_method, 1);
        mobj1 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj1, false, paramtype1, &created1);
    }
    arg_ptrs [1] = mobj1;

    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    UITableViewCell * res;
    if (!retval) {
        res = NULL;
    } else {
        id retobj;
        retobj = xamarin_get_nsobject_handle (retval);
        xamarin_framework_peer_lock ();
        [retobj retain];
        xamarin_framework_peer_unlock ();
        [retobj autorelease];
        mt_dummy_use (retval);
        res = retobj;
    }

    return res;
}


static void native_to_managed_trampoline_37 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UITableView * p0, NSIndexPath * p1, const char *r0, const char *r1, const char *r2, const char *r3)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    NSObject *nsobj1 = (NSObject *) p1;
    MonoObject *mobj1 = NULL;
    int32_t created1 = false;
    if (nsobj1) {
        MonoType *paramtype1 = xamarin_get_parameter_type (managed_method, 1);
        mobj1 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj1, false, paramtype1, &created1);
    }
    arg_ptrs [1] = mobj1;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static void native_to_managed_trampoline_38 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UITableView * p0, UIView * p1, NSInteger p2, const char *r0, const char *r1, const char *r2, const char *r3, const char *r4)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [3];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[3] = { r0, r1, r2 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r3, r4, 3, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    NSObject *nsobj1 = (NSObject *) p1;
    MonoObject *mobj1 = NULL;
    int32_t created1 = false;
    if (nsobj1) {
        MonoType *paramtype1 = xamarin_get_parameter_type (managed_method, 1);
        mobj1 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj1, false, paramtype1, &created1);
    }
    arg_ptrs [1] = mobj1;
    arg_ptrs [2] = &p2;

    mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    return;
}


static NSString * native_to_managed_trampoline_39 (id self, SEL _cmd, MonoMethod **managed_method_ptr, UITableView * p0, NSInteger p1, const char *r0, const char *r1, const char *r2, const char *r3)
{
    MonoMethod *managed_method = *managed_method_ptr;
    void *arg_ptrs [2];
    MonoObject *mthis;
    if (mono_domain_get () == NULL)
        mono_jit_thread_attach (NULL);
    mthis = NULL;
    if (self) {
        mthis = xamarin_get_managed_object_for_ptr_fast (self);
    }
    if (!managed_method) {
        const char *paramptr[2] = { r0, r1 };
        managed_method = xamarin_get_reflection_method_method (xamarin_get_method_direct(r2, r3, 2, paramptr));
        *managed_method_ptr = managed_method;
    }
    xamarin_check_for_gced_object (mthis, _cmd, self, managed_method);
    NSObject *nsobj0 = (NSObject *) p0;
    MonoObject *mobj0 = NULL;
    int32_t created0 = false;
    if (nsobj0) {
        MonoType *paramtype0 = xamarin_get_parameter_type (managed_method, 0);
        mobj0 = xamarin_get_nsobject_with_type_for_ptr_created (nsobj0, false, paramtype0, &created0);
    }
    arg_ptrs [0] = mobj0;
    arg_ptrs [1] = &p1;

    MonoObject * retval = mono_runtime_invoke (managed_method, mthis, arg_ptrs, NULL);

    NSString * res;
    if (!retval) {
        res = NULL;
    } else {
        char *str = mono_string_to_utf8 ((MonoString *) retval);
        NSString *nsstr = [[NSString alloc] initWithUTF8String:str];
        [nsstr autorelease];
        mono_free (str);
        res = nsstr;
    }

    return res;
}



@interface UIKit_UIControlEventProxy : NSObject {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(void) BridgeSelector;
    -(BOOL) conformsToProtocol:(void *)p0;
@end
@implementation UIKit_UIControlEventProxy { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(void) BridgeSelector
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_1 (self, _cmd, &managed_method, "UIKit.UIControlEventProxy, Xamarin.iOS", "Activated");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }
@end

@interface __MonoTouch_UIImageStatusDispatcher : NSObject {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(void) Xamarin_Internal__image:(UIImage *)p0 didFinishSavingWithError:(NSError *)p1 contextInfo:(void *)p2;
    -(BOOL) conformsToProtocol:(void *)p0;
@end
@implementation __MonoTouch_UIImageStatusDispatcher { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(void) Xamarin_Internal__image:(UIImage *)p0 didFinishSavingWithError:(NSError *)p1 contextInfo:(void *)p2
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_3 (self, _cmd, &managed_method, p0, p1, p2, "UIKit.UIImage, Xamarin.iOS", "Foundation.NSError, Xamarin.iOS", "System.IntPtr, mscorlib", "UIKit.UIImageStatusDispatcher, Xamarin.iOS", "Callback");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }
@end

@interface __MonoMac_NSActionDispatcher : NSObject {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(void) xamarinApplySelector;
    -(BOOL) conformsToProtocol:(void *)p0;
@end
@implementation __MonoMac_NSActionDispatcher { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(void) xamarinApplySelector
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_1 (self, _cmd, &managed_method, "Foundation.NSActionDispatcher, Xamarin.iOS", "Apply");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }
@end

@interface __MonoMac_NSAsyncActionDispatcher : NSObject {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(void) xamarinApplySelector;
    -(BOOL) conformsToProtocol:(void *)p0;
@end
@implementation __MonoMac_NSAsyncActionDispatcher { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(void) xamarinApplySelector
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_1 (self, _cmd, &managed_method, "Foundation.NSAsyncActionDispatcher, Xamarin.iOS", "Apply");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }
@end

@protocol CALayerDelegate
@end

@protocol UICollectionViewSource<UICollectionViewDataSource, UICollectionViewDelegate>
@end

@interface AppDelegate : NSObject<UIApplicationDelegate> {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(UIWindow *) window;
    -(void) setWindow:(UIWindow *)p0;
    -(BOOL) application:(UIApplication *)p0 didFinishLaunchingWithOptions:(NSDictionary *)p1;
    -(void) applicationWillResignActive:(UIApplication *)p0;
    -(void) applicationDidEnterBackground:(UIApplication *)p0;
    -(void) applicationWillEnterForeground:(UIApplication *)p0;
    -(void) applicationDidBecomeActive:(UIApplication *)p0;
    -(void) applicationWillTerminate:(UIApplication *)p0;
    -(BOOL) conformsToProtocol:(void *)p0;
    -(id) init;
@end
@implementation AppDelegate { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(UIWindow *) window
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_4 (self, _cmd, &managed_method, "GMPickerTest.AppDelegate, GMPickerTest", "get_Window");
    }

    -(void) setWindow:(UIWindow *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_5 (self, _cmd, &managed_method, p0, "UIKit.UIWindow, Xamarin.iOS", "GMPickerTest.AppDelegate, GMPickerTest", "set_Window");
    }

    -(BOOL) application:(UIApplication *)p0 didFinishLaunchingWithOptions:(NSDictionary *)p1
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_6 (self, _cmd, &managed_method, p0, p1, "UIKit.UIApplication, Xamarin.iOS", "Foundation.NSDictionary, Xamarin.iOS", "GMPickerTest.AppDelegate, GMPickerTest", "FinishedLaunching");
    }

    -(void) applicationWillResignActive:(UIApplication *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_7 (self, _cmd, &managed_method, p0, "UIKit.UIApplication, Xamarin.iOS", "GMPickerTest.AppDelegate, GMPickerTest", "OnResignActivation");
    }

    -(void) applicationDidEnterBackground:(UIApplication *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_7 (self, _cmd, &managed_method, p0, "UIKit.UIApplication, Xamarin.iOS", "GMPickerTest.AppDelegate, GMPickerTest", "DidEnterBackground");
    }

    -(void) applicationWillEnterForeground:(UIApplication *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_7 (self, _cmd, &managed_method, p0, "UIKit.UIApplication, Xamarin.iOS", "GMPickerTest.AppDelegate, GMPickerTest", "WillEnterForeground");
    }

    -(void) applicationDidBecomeActive:(UIApplication *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_7 (self, _cmd, &managed_method, p0, "UIKit.UIApplication, Xamarin.iOS", "GMPickerTest.AppDelegate, GMPickerTest", "OnActivated");
    }

    -(void) applicationWillTerminate:(UIApplication *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_7 (self, _cmd, &managed_method, p0, "UIKit.UIApplication, Xamarin.iOS", "GMPickerTest.AppDelegate, GMPickerTest", "WillTerminate");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }

    -(id) init
    {
        static MonoMethod *managed_method = NULL;
        bool call_super = false;
        id rv = native_to_managed_trampoline_8 (self, _cmd, &managed_method, "GMPickerTest.AppDelegate, GMPickerTest", ".ctor", &call_super);
        if (call_super && rv) {
            struct objc_super super = {  rv, [NSObject class] };
            rv = ((id (*)(objc_super*, SEL)) objc_msgSendSuper) (&super, @selector (init));
        }
        return rv;
    }
@end

@interface ViewController : UIViewController {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(void) viewDidLoad;
    -(void) viewDidAppear:(BOOL)p0;
    -(void) didReceiveMemoryWarning;
    -(BOOL) conformsToProtocol:(void *)p0;
@end
@implementation ViewController { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(void) viewDidLoad
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_1 (self, _cmd, &managed_method, "GMPickerTest.ViewController, GMPickerTest", "ViewDidLoad");
    }

    -(void) viewDidAppear:(BOOL)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_9 (self, _cmd, &managed_method, p0, "System.Boolean, mscorlib", "GMPickerTest.ViewController, GMPickerTest", "ViewDidAppear");
    }

    -(void) didReceiveMemoryWarning
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_1 (self, _cmd, &managed_method, "GMPickerTest.ViewController, GMPickerTest", "DidReceiveMemoryWarning");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }
@end

@interface __UIGestureRecognizerToken : NSObject {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(BOOL) conformsToProtocol:(void *)p0;
@end
@implementation __UIGestureRecognizerToken { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }
@end

@interface __UIGestureRecognizerParameterlessToken : __UIGestureRecognizerToken {
}
@end
@implementation __UIGestureRecognizerParameterlessToken { }
@end

@interface __UIGestureRecognizerParametrizedToken : __UIGestureRecognizerToken {
}
@end
@implementation __UIGestureRecognizerParametrizedToken { }
@end

@interface UIKit_UIBarButtonItem_Callback : NSObject {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(void) InvokeAction:(NSObject *)p0;
    -(BOOL) conformsToProtocol:(void *)p0;
    -(id) init;
@end
@implementation UIKit_UIBarButtonItem_Callback { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(void) InvokeAction:(NSObject *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_10 (self, _cmd, &managed_method, p0, "Foundation.NSObject, Xamarin.iOS", "UIKit.UIBarButtonItem+Callback, Xamarin.iOS", "Call");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }

    -(id) init
    {
        static MonoMethod *managed_method = NULL;
        bool call_super = false;
        id rv = native_to_managed_trampoline_8 (self, _cmd, &managed_method, "UIKit.UIBarButtonItem+Callback, Xamarin.iOS", ".ctor", &call_super);
        if (call_super && rv) {
            struct objc_super super = {  rv, [NSObject class] };
            rv = ((id (*)(objc_super*, SEL)) objc_msgSendSuper) (&super, @selector (init));
        }
        return rv;
    }
@end

@interface __NSObject_Disposer : NSObject {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    +(void) drain:(NSObject *)p0;
    -(BOOL) conformsToProtocol:(void *)p0;
    -(id) init;
@end
@implementation __NSObject_Disposer { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    +(void) drain:(NSObject *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_11 (self, _cmd, &managed_method, p0, "Foundation.NSObject, Xamarin.iOS", "Foundation.NSObject+NSObject_Disposer, Xamarin.iOS", "Drain");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }

    -(id) init
    {
        static MonoMethod *managed_method = NULL;
        bool call_super = false;
        id rv = native_to_managed_trampoline_8 (self, _cmd, &managed_method, "Foundation.NSObject+NSObject_Disposer, Xamarin.iOS", ".ctor", &call_super);
        if (call_super && rv) {
            struct objc_super super = {  rv, [NSObject class] };
            rv = ((id (*)(objc_super*, SEL)) objc_msgSendSuper) (&super, @selector (init));
        }
        return rv;
    }
@end

@interface UIKit_UIScrollView__UIScrollViewDelegate : NSObject<UIScrollViewDelegate> {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(void) scrollViewDidEndDecelerating:(UIScrollView *)p0;
    -(void) scrollViewWillBeginDecelerating:(UIScrollView *)p0;
    -(void) scrollViewDidZoom:(UIScrollView *)p0;
    -(void) scrollViewDidEndDragging:(UIScrollView *)p0 willDecelerate:(BOOL)p1;
    -(void) scrollViewWillBeginDragging:(UIScrollView *)p0;
    -(void) scrollViewDidEndScrollingAnimation:(UIScrollView *)p0;
    -(void) scrollViewDidScroll:(UIScrollView *)p0;
    -(void) scrollViewDidScrollToTop:(UIScrollView *)p0;
    -(BOOL) scrollViewShouldScrollToTop:(UIScrollView *)p0;
    -(UIView *) viewForZoomingInScrollView:(UIScrollView *)p0;
    -(void) scrollViewWillEndDragging:(UIScrollView *)p0 withVelocity:(CGPoint)p1 targetContentOffset:(CGPoint*)p2;
    -(void) scrollViewDidEndZooming:(UIScrollView *)p0 withView:(UIView *)p1 atScale:(CGFloat)p2;
    -(void) scrollViewWillBeginZooming:(UIScrollView *)p0 withView:(UIView *)p1;
    -(BOOL) conformsToProtocol:(void *)p0;
@end
@implementation UIKit_UIScrollView__UIScrollViewDelegate { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(void) scrollViewDidEndDecelerating:(UIScrollView *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_12 (self, _cmd, &managed_method, p0, "UIKit.UIScrollView, Xamarin.iOS", "UIKit.UIScrollView+_UIScrollViewDelegate, Xamarin.iOS", "DecelerationEnded");
    }

    -(void) scrollViewWillBeginDecelerating:(UIScrollView *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_12 (self, _cmd, &managed_method, p0, "UIKit.UIScrollView, Xamarin.iOS", "UIKit.UIScrollView+_UIScrollViewDelegate, Xamarin.iOS", "DecelerationStarted");
    }

    -(void) scrollViewDidZoom:(UIScrollView *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_12 (self, _cmd, &managed_method, p0, "UIKit.UIScrollView, Xamarin.iOS", "UIKit.UIScrollView+_UIScrollViewDelegate, Xamarin.iOS", "DidZoom");
    }

    -(void) scrollViewDidEndDragging:(UIScrollView *)p0 willDecelerate:(BOOL)p1
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_13 (self, _cmd, &managed_method, p0, p1, "UIKit.UIScrollView, Xamarin.iOS", "System.Boolean, mscorlib", "UIKit.UIScrollView+_UIScrollViewDelegate, Xamarin.iOS", "DraggingEnded");
    }

    -(void) scrollViewWillBeginDragging:(UIScrollView *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_12 (self, _cmd, &managed_method, p0, "UIKit.UIScrollView, Xamarin.iOS", "UIKit.UIScrollView+_UIScrollViewDelegate, Xamarin.iOS", "DraggingStarted");
    }

    -(void) scrollViewDidEndScrollingAnimation:(UIScrollView *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_12 (self, _cmd, &managed_method, p0, "UIKit.UIScrollView, Xamarin.iOS", "UIKit.UIScrollView+_UIScrollViewDelegate, Xamarin.iOS", "ScrollAnimationEnded");
    }

    -(void) scrollViewDidScroll:(UIScrollView *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_12 (self, _cmd, &managed_method, p0, "UIKit.UIScrollView, Xamarin.iOS", "UIKit.UIScrollView+_UIScrollViewDelegate, Xamarin.iOS", "Scrolled");
    }

    -(void) scrollViewDidScrollToTop:(UIScrollView *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_12 (self, _cmd, &managed_method, p0, "UIKit.UIScrollView, Xamarin.iOS", "UIKit.UIScrollView+_UIScrollViewDelegate, Xamarin.iOS", "ScrolledToTop");
    }

    -(BOOL) scrollViewShouldScrollToTop:(UIScrollView *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_14 (self, _cmd, &managed_method, p0, "UIKit.UIScrollView, Xamarin.iOS", "UIKit.UIScrollView+_UIScrollViewDelegate, Xamarin.iOS", "ShouldScrollToTop");
    }

    -(UIView *) viewForZoomingInScrollView:(UIScrollView *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_15 (self, _cmd, &managed_method, p0, "UIKit.UIScrollView, Xamarin.iOS", "UIKit.UIScrollView+_UIScrollViewDelegate, Xamarin.iOS", "ViewForZoomingInScrollView");
    }

    -(void) scrollViewWillEndDragging:(UIScrollView *)p0 withVelocity:(CGPoint)p1 targetContentOffset:(CGPoint*)p2
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_16 (self, _cmd, &managed_method, p0, p1, p2, "UIKit.UIScrollView, Xamarin.iOS", "CoreGraphics.CGPoint, Xamarin.iOS", "CoreGraphics.CGPoint&, Xamarin.iOS", "UIKit.UIScrollView+_UIScrollViewDelegate, Xamarin.iOS", "WillEndDragging");
    }

    -(void) scrollViewDidEndZooming:(UIScrollView *)p0 withView:(UIView *)p1 atScale:(CGFloat)p2
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_17 (self, _cmd, &managed_method, p0, p1, p2, "UIKit.UIScrollView, Xamarin.iOS", "UIKit.UIView, Xamarin.iOS", "System.nfloat, Xamarin.iOS", "UIKit.UIScrollView+_UIScrollViewDelegate, Xamarin.iOS", "ZoomingEnded");
    }

    -(void) scrollViewWillBeginZooming:(UIScrollView *)p0 withView:(UIView *)p1
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_18 (self, _cmd, &managed_method, p0, p1, "UIKit.UIScrollView, Xamarin.iOS", "UIKit.UIView, Xamarin.iOS", "UIKit.UIScrollView+_UIScrollViewDelegate, Xamarin.iOS", "ZoomingStarted");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }
@end

@interface GMImagePicker_GMAlbumsViewCell : UITableViewCell {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(void) awakeFromNib;
    -(void) setSelected:(BOOL)p0 animated:(BOOL)p1;
    -(BOOL) conformsToProtocol:(void *)p0;
    -(id) initWithStyle:(NSInteger)p0 reuseIdentifier:(NSString *)p1;
@end
@implementation GMImagePicker_GMAlbumsViewCell { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(void) awakeFromNib
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_1 (self, _cmd, &managed_method, "GMImagePicker.GMAlbumsViewCell, GMImagePicker.Xamarin", "AwakeFromNib");
    }

    -(void) setSelected:(BOOL)p0 animated:(BOOL)p1
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_19 (self, _cmd, &managed_method, p0, p1, "System.Boolean, mscorlib", "System.Boolean, mscorlib", "GMImagePicker.GMAlbumsViewCell, GMImagePicker.Xamarin", "SetSelected");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }

    -(id) initWithStyle:(NSInteger)p0 reuseIdentifier:(NSString *)p1
    {
        static MonoMethod *managed_method = NULL;
        bool call_super = false;
        id rv = native_to_managed_trampoline_20 (self, _cmd, &managed_method, p0, p1, "UIKit.UITableViewCellStyle, Xamarin.iOS", "System.String, mscorlib", "GMImagePicker.GMAlbumsViewCell, GMImagePicker.Xamarin", ".ctor", &call_super);
        if (call_super && rv) {
            struct objc_super super = {  rv, [UITableViewCell class] };
            rv = ((id (*)(objc_super*, SEL, NSInteger, NSString *)) objc_msgSendSuper) (&super, @selector (initWithStyle:reuseIdentifier:), p0, p1);
        }
        return rv;
    }
@end

@interface GMImagePicker_GMGridViewCell : UICollectionViewCell {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(void) awakeFromNib;
    -(void) layoutSubviews;
    -(BOOL) isSelected;
    -(void) setSelected:(BOOL)p0;
    -(BOOL) conformsToProtocol:(void *)p0;
    -(id) initWithFrame:(CGRect)p0;
@end
@implementation GMImagePicker_GMGridViewCell { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(void) awakeFromNib
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_1 (self, _cmd, &managed_method, "GMImagePicker.GMGridViewCell, GMImagePicker.Xamarin", "AwakeFromNib");
    }

    -(void) layoutSubviews
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_1 (self, _cmd, &managed_method, "GMImagePicker.GMGridViewCell, GMImagePicker.Xamarin", "LayoutSubviews");
    }

    -(BOOL) isSelected
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_21 (self, _cmd, &managed_method, "GMImagePicker.GMGridViewCell, GMImagePicker.Xamarin", "get_Selected");
    }

    -(void) setSelected:(BOOL)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_9 (self, _cmd, &managed_method, p0, "System.Boolean, mscorlib", "GMImagePicker.GMGridViewCell, GMImagePicker.Xamarin", "set_Selected");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }

    -(id) initWithFrame:(CGRect)p0
    {
        static MonoMethod *managed_method = NULL;
        bool call_super = false;
        id rv = native_to_managed_trampoline_22 (self, _cmd, &managed_method, p0, "CoreGraphics.CGRect, Xamarin.iOS", "GMImagePicker.GMGridViewCell, GMImagePicker.Xamarin", ".ctor", &call_super);
        if (call_super && rv) {
            struct objc_super super = {  rv, [UICollectionViewCell class] };
            rv = ((id (*)(objc_super*, SEL, CGRect)) objc_msgSendSuper) (&super, @selector (initWithFrame:frame), p0);
        }
        return rv;
    }
@end

@interface DummyClass : NSObject {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(BOOL) conformsToProtocol:(void *)p0;
    -(id) init;
@end
@implementation DummyClass { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }

    -(id) init
    {
        static MonoMethod *managed_method = NULL;
        bool call_super = false;
        id rv = native_to_managed_trampoline_8 (self, _cmd, &managed_method, "GMImagePicker.DummyClass, GMImagePicker.Xamarin", ".ctor", &call_super);
        if (call_super && rv) {
            struct objc_super super = {  rv, [NSObject class] };
            rv = ((id (*)(objc_super*, SEL)) objc_msgSendSuper) (&super, @selector (init));
        }
        return rv;
    }
@end

@interface GMImagePicker_GMGridViewController : UICollectionViewController<PHPhotoLibraryChangeObserver> {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(void) viewDidLoad;
    -(void) viewWillAppear:(BOOL)p0;
    -(void) viewDidAppear:(BOOL)p0;
    -(void) viewWillDisappear:(BOOL)p0;
    -(void) photoLibraryDidChange:(PHChange *)p0;
    -(NSInteger) preferredStatusBarStyle;
    -(void) scrollViewDidScroll:(UIScrollView *)p0;
    -(void) willAnimateRotationToInterfaceOrientation:(NSInteger)p0 duration:(double)p1;
    -(BOOL) conformsToProtocol:(void *)p0;
@end
@implementation GMImagePicker_GMGridViewController { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(void) viewDidLoad
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_1 (self, _cmd, &managed_method, "GMImagePicker.GMGridViewController, GMImagePicker.Xamarin", "ViewDidLoad");
    }

    -(void) viewWillAppear:(BOOL)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_9 (self, _cmd, &managed_method, p0, "System.Boolean, mscorlib", "GMImagePicker.GMGridViewController, GMImagePicker.Xamarin", "ViewWillAppear");
    }

    -(void) viewDidAppear:(BOOL)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_9 (self, _cmd, &managed_method, p0, "System.Boolean, mscorlib", "GMImagePicker.GMGridViewController, GMImagePicker.Xamarin", "ViewDidAppear");
    }

    -(void) viewWillDisappear:(BOOL)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_9 (self, _cmd, &managed_method, p0, "System.Boolean, mscorlib", "GMImagePicker.GMGridViewController, GMImagePicker.Xamarin", "ViewWillDisappear");
    }

    -(void) photoLibraryDidChange:(PHChange *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_23 (self, _cmd, &managed_method, p0, "Photos.PHChange, Xamarin.iOS", "GMImagePicker.GMGridViewController, GMImagePicker.Xamarin", "PhotoLibraryDidChange");
    }

    -(NSInteger) preferredStatusBarStyle
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_24 (self, _cmd, &managed_method, "GMImagePicker.GMGridViewController, GMImagePicker.Xamarin", "PreferredStatusBarStyle");
    }

    -(void) scrollViewDidScroll:(UIScrollView *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_12 (self, _cmd, &managed_method, p0, "UIKit.UIScrollView, Xamarin.iOS", "GMImagePicker.GMGridViewController, GMImagePicker.Xamarin", "Scrolled");
    }

    -(void) willAnimateRotationToInterfaceOrientation:(NSInteger)p0 duration:(double)p1
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_25 (self, _cmd, &managed_method, p0, p1, "UIKit.UIInterfaceOrientation, Xamarin.iOS", "System.Double, mscorlib", "GMImagePicker.GMGridViewController, GMImagePicker.Xamarin", "WillAnimateRotation");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }
@end

@interface GMImagePicker_GMImagePickerController_GMNavigationControllerDelegate : NSObject<UINavigationControllerDelegate> {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(BOOL) conformsToProtocol:(void *)p0;
    -(id) init;
@end
@implementation GMImagePicker_GMImagePickerController_GMNavigationControllerDelegate { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }

    -(id) init
    {
        static MonoMethod *managed_method = NULL;
        bool call_super = false;
        id rv = native_to_managed_trampoline_8 (self, _cmd, &managed_method, "GMImagePicker.GMImagePickerController+GMNavigationControllerDelegate, GMImagePicker.Xamarin", ".ctor", &call_super);
        if (call_super && rv) {
            struct objc_super super = {  rv, [NSObject class] };
            rv = ((id (*)(objc_super*, SEL)) objc_msgSendSuper) (&super, @selector (init));
        }
        return rv;
    }
@end

@interface GMImagePicker_GMImagePickerController : UIViewController {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(void) viewWillAppear:(BOOL)p0;
    -(NSInteger) preferredStatusBarStyle;
    -(BOOL) conformsToProtocol:(void *)p0;
    -(id) init;
@end
@implementation GMImagePicker_GMImagePickerController { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(void) viewWillAppear:(BOOL)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_9 (self, _cmd, &managed_method, p0, "System.Boolean, mscorlib", "GMImagePicker.GMImagePickerController, GMImagePicker.Xamarin", "ViewWillAppear");
    }

    -(NSInteger) preferredStatusBarStyle
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_24 (self, _cmd, &managed_method, "GMImagePicker.GMImagePickerController, GMImagePicker.Xamarin", "PreferredStatusBarStyle");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }

    -(id) init
    {
        static MonoMethod *managed_method = NULL;
        bool call_super = false;
        id rv = native_to_managed_trampoline_8 (self, _cmd, &managed_method, "GMImagePicker.GMImagePickerController, GMImagePicker.Xamarin", ".ctor", &call_super);
        if (call_super && rv) {
            struct objc_super super = {  rv, [UIViewController class] };
            rv = ((id (*)(objc_super*, SEL)) objc_msgSendSuper) (&super, @selector (init));
        }
        return rv;
    }
@end

@interface GMImagePicker_GMAlbumsViewController : UITableViewController<PHPhotoLibraryChangeObserver> {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(void) photoLibraryDidChange:(PHChange *)p0;
    -(void) viewDidLoad;
    -(NSInteger) preferredStatusBarStyle;
    -(BOOL) shouldAutorotate;
    -(NSUInteger) supportedInterfaceOrientations;
    -(BOOL) conformsToProtocol:(void *)p0;
    -(id) init;
@end
@implementation GMImagePicker_GMAlbumsViewController { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(void) photoLibraryDidChange:(PHChange *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_23 (self, _cmd, &managed_method, p0, "Photos.PHChange, Xamarin.iOS", "GMImagePicker.GMAlbumsViewController, GMImagePicker.Xamarin", "PhotoLibraryDidChange");
    }

    -(void) viewDidLoad
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_1 (self, _cmd, &managed_method, "GMImagePicker.GMAlbumsViewController, GMImagePicker.Xamarin", "ViewDidLoad");
    }

    -(NSInteger) preferredStatusBarStyle
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_24 (self, _cmd, &managed_method, "GMImagePicker.GMAlbumsViewController, GMImagePicker.Xamarin", "PreferredStatusBarStyle");
    }

    -(BOOL) shouldAutorotate
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_21 (self, _cmd, &managed_method, "GMImagePicker.GMAlbumsViewController, GMImagePicker.Xamarin", "ShouldAutorotate");
    }

    -(NSUInteger) supportedInterfaceOrientations
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_26 (self, _cmd, &managed_method, "GMImagePicker.GMAlbumsViewController, GMImagePicker.Xamarin", "GetSupportedInterfaceOrientations");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }

    -(id) init
    {
        static MonoMethod *managed_method = NULL;
        bool call_super = false;
        id rv = native_to_managed_trampoline_8 (self, _cmd, &managed_method, "GMImagePicker.GMAlbumsViewController, GMImagePicker.Xamarin", ".ctor", &call_super);
        if (call_super && rv) {
            struct objc_super super = {  rv, [UITableViewController class] };
            rv = ((id (*)(objc_super*, SEL)) objc_msgSendSuper) (&super, @selector (init));
        }
        return rv;
    }
@end

@interface GMImagePicker_GMGridViewController_GMGridViewCollectionViewSource : NSObject<UICollectionViewSource> {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(NSInteger) numberOfSectionsInCollectionView:(UICollectionView *)p0;
    -(UICollectionViewCell *) collectionView:(UICollectionView *)p0 cellForItemAtIndexPath:(NSIndexPath *)p1;
    -(NSInteger) collectionView:(UICollectionView *)p0 numberOfItemsInSection:(NSInteger)p1;
    -(void) collectionView:(UICollectionView *)p0 didSelectItemAtIndexPath:(NSIndexPath *)p1;
    -(BOOL) collectionView:(UICollectionView *)p0 shouldDeselectItemAtIndexPath:(NSIndexPath *)p1;
    -(BOOL) collectionView:(UICollectionView *)p0 shouldHighlightItemAtIndexPath:(NSIndexPath *)p1;
    -(void) collectionView:(UICollectionView *)p0 didHighlightItemAtIndexPath:(NSIndexPath *)p1;
    -(void) collectionView:(UICollectionView *)p0 didUnhighlightItemAtIndexPath:(NSIndexPath *)p1;
    -(BOOL) collectionView:(UICollectionView *)p0 shouldSelectItemAtIndexPath:(NSIndexPath *)p1;
    -(void) collectionView:(UICollectionView *)p0 didDeselectItemAtIndexPath:(NSIndexPath *)p1;
    -(BOOL) conformsToProtocol:(void *)p0;
@end
@implementation GMImagePicker_GMGridViewController_GMGridViewCollectionViewSource { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(NSInteger) numberOfSectionsInCollectionView:(UICollectionView *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_27 (self, _cmd, &managed_method, p0, "UIKit.UICollectionView, Xamarin.iOS", "GMImagePicker.GMGridViewController+GMGridViewCollectionViewSource, GMImagePicker.Xamarin", "NumberOfSections");
    }

    -(UICollectionViewCell *) collectionView:(UICollectionView *)p0 cellForItemAtIndexPath:(NSIndexPath *)p1
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_28 (self, _cmd, &managed_method, p0, p1, "UIKit.UICollectionView, Xamarin.iOS", "Foundation.NSIndexPath, Xamarin.iOS", "GMImagePicker.GMGridViewController+GMGridViewCollectionViewSource, GMImagePicker.Xamarin", "GetCell");
    }

    -(NSInteger) collectionView:(UICollectionView *)p0 numberOfItemsInSection:(NSInteger)p1
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_29 (self, _cmd, &managed_method, p0, p1, "UIKit.UICollectionView, Xamarin.iOS", "System.nint, Xamarin.iOS", "GMImagePicker.GMGridViewController+GMGridViewCollectionViewSource, GMImagePicker.Xamarin", "GetItemsCount");
    }

    -(void) collectionView:(UICollectionView *)p0 didSelectItemAtIndexPath:(NSIndexPath *)p1
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_30 (self, _cmd, &managed_method, p0, p1, "UIKit.UICollectionView, Xamarin.iOS", "Foundation.NSIndexPath, Xamarin.iOS", "GMImagePicker.GMGridViewController+GMGridViewCollectionViewSource, GMImagePicker.Xamarin", "ItemSelected");
    }

    -(BOOL) collectionView:(UICollectionView *)p0 shouldDeselectItemAtIndexPath:(NSIndexPath *)p1
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_31 (self, _cmd, &managed_method, p0, p1, "UIKit.UICollectionView, Xamarin.iOS", "Foundation.NSIndexPath, Xamarin.iOS", "GMImagePicker.GMGridViewController+GMGridViewCollectionViewSource, GMImagePicker.Xamarin", "ShouldDeselectItem");
    }

    -(BOOL) collectionView:(UICollectionView *)p0 shouldHighlightItemAtIndexPath:(NSIndexPath *)p1
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_31 (self, _cmd, &managed_method, p0, p1, "UIKit.UICollectionView, Xamarin.iOS", "Foundation.NSIndexPath, Xamarin.iOS", "GMImagePicker.GMGridViewController+GMGridViewCollectionViewSource, GMImagePicker.Xamarin", "ShouldHighlightItem");
    }

    -(void) collectionView:(UICollectionView *)p0 didHighlightItemAtIndexPath:(NSIndexPath *)p1
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_30 (self, _cmd, &managed_method, p0, p1, "UIKit.UICollectionView, Xamarin.iOS", "Foundation.NSIndexPath, Xamarin.iOS", "GMImagePicker.GMGridViewController+GMGridViewCollectionViewSource, GMImagePicker.Xamarin", "ItemHighlighted");
    }

    -(void) collectionView:(UICollectionView *)p0 didUnhighlightItemAtIndexPath:(NSIndexPath *)p1
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_30 (self, _cmd, &managed_method, p0, p1, "UIKit.UICollectionView, Xamarin.iOS", "Foundation.NSIndexPath, Xamarin.iOS", "GMImagePicker.GMGridViewController+GMGridViewCollectionViewSource, GMImagePicker.Xamarin", "ItemUnhighlighted");
    }

    -(BOOL) collectionView:(UICollectionView *)p0 shouldSelectItemAtIndexPath:(NSIndexPath *)p1
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_31 (self, _cmd, &managed_method, p0, p1, "UIKit.UICollectionView, Xamarin.iOS", "Foundation.NSIndexPath, Xamarin.iOS", "GMImagePicker.GMGridViewController+GMGridViewCollectionViewSource, GMImagePicker.Xamarin", "ShouldSelectItem");
    }

    -(void) collectionView:(UICollectionView *)p0 didDeselectItemAtIndexPath:(NSIndexPath *)p1
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_30 (self, _cmd, &managed_method, p0, p1, "UIKit.UICollectionView, Xamarin.iOS", "Foundation.NSIndexPath, Xamarin.iOS", "GMImagePicker.GMGridViewController+GMGridViewCollectionViewSource, GMImagePicker.Xamarin", "ItemDeselected");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }
@end

@interface GMImagePicker_GMImagePickerController_GMImagePickerDelegate : NSObject<UIImagePickerControllerDelegate, UINavigationControllerDelegate> {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(void) imagePickerController:(UIImagePickerController *)p0 didFinishPickingMediaWithInfo:(NSDictionary *)p1;
    -(void) imagePickerControllerDidCancel:(UIImagePickerController *)p0;
    -(BOOL) conformsToProtocol:(void *)p0;
@end
@implementation GMImagePicker_GMImagePickerController_GMImagePickerDelegate { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(void) imagePickerController:(UIImagePickerController *)p0 didFinishPickingMediaWithInfo:(NSDictionary *)p1
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_32 (self, _cmd, &managed_method, p0, p1, "UIKit.UIImagePickerController, Xamarin.iOS", "Foundation.NSDictionary, Xamarin.iOS", "GMImagePicker.GMImagePickerController+GMImagePickerDelegate, GMImagePicker.Xamarin", "FinishedPickingMedia");
    }

    -(void) imagePickerControllerDidCancel:(UIImagePickerController *)p0
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_33 (self, _cmd, &managed_method, p0, "UIKit.UIImagePickerController, Xamarin.iOS", "GMImagePicker.GMImagePickerController+GMImagePickerDelegate, GMImagePicker.Xamarin", "Canceled");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }
@end

@interface GMImagePicker_GMAlbumsViewController_GMAlbumsViewTableViewSource : NSObject<UIScrollViewDelegate> {
    XamarinObject __monoObjectGCHandle;
}
    -(void) release;
    -(id) retain;
    -(int) xamarinGetGCHandle;
    -(void) xamarinSetGCHandle: (int) gchandle;
    -(NSInteger) numberOfSectionsInTableView:(UITableView *)p0;
    -(NSInteger) tableView:(UITableView *)p0 numberOfRowsInSection:(NSInteger)p1;
    -(UITableViewCell *) tableView:(UITableView *)p0 cellForRowAtIndexPath:(NSIndexPath *)p1;
    -(void) tableView:(UITableView *)p0 didSelectRowAtIndexPath:(NSIndexPath *)p1;
    -(void) tableView:(UITableView *)p0 willDisplayHeaderView:(UIView *)p1 forSection:(NSInteger)p2;
    -(NSString *) tableView:(UITableView *)p0 titleForHeaderInSection:(NSInteger)p1;
    -(BOOL) conformsToProtocol:(void *)p0;
@end
@implementation GMImagePicker_GMAlbumsViewController_GMAlbumsViewTableViewSource { }
    -(void) release
    {
        xamarin_release_trampoline (self, _cmd);
    }

    -(id) retain
    {
        return xamarin_retain_trampoline (self, _cmd);
    }

    -(int) xamarinGetGCHandle
    {
        return __monoObjectGCHandle.gc_handle;
    }

    -(void) xamarinSetGCHandle: (int) gc_handle
    {
        __monoObjectGCHandle.gc_handle = gc_handle;
        __monoObjectGCHandle.native_object = self;
    }


    -(NSInteger) numberOfSectionsInTableView:(UITableView *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_34 (self, _cmd, &managed_method, p0, "UIKit.UITableView, Xamarin.iOS", "GMImagePicker.GMAlbumsViewController+GMAlbumsViewTableViewSource, GMImagePicker.Xamarin", "NumberOfSections");
    }

    -(NSInteger) tableView:(UITableView *)p0 numberOfRowsInSection:(NSInteger)p1
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_35 (self, _cmd, &managed_method, p0, p1, "UIKit.UITableView, Xamarin.iOS", "System.nint, Xamarin.iOS", "GMImagePicker.GMAlbumsViewController+GMAlbumsViewTableViewSource, GMImagePicker.Xamarin", "RowsInSection");
    }

    -(UITableViewCell *) tableView:(UITableView *)p0 cellForRowAtIndexPath:(NSIndexPath *)p1
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_36 (self, _cmd, &managed_method, p0, p1, "UIKit.UITableView, Xamarin.iOS", "Foundation.NSIndexPath, Xamarin.iOS", "GMImagePicker.GMAlbumsViewController+GMAlbumsViewTableViewSource, GMImagePicker.Xamarin", "GetCell");
    }

    -(void) tableView:(UITableView *)p0 didSelectRowAtIndexPath:(NSIndexPath *)p1
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_37 (self, _cmd, &managed_method, p0, p1, "UIKit.UITableView, Xamarin.iOS", "Foundation.NSIndexPath, Xamarin.iOS", "GMImagePicker.GMAlbumsViewController+GMAlbumsViewTableViewSource, GMImagePicker.Xamarin", "RowSelected");
    }

    -(void) tableView:(UITableView *)p0 willDisplayHeaderView:(UIView *)p1 forSection:(NSInteger)p2
    {
        static MonoMethod *managed_method = NULL;
        native_to_managed_trampoline_38 (self, _cmd, &managed_method, p0, p1, p2, "UIKit.UITableView, Xamarin.iOS", "UIKit.UIView, Xamarin.iOS", "System.nint, Xamarin.iOS", "GMImagePicker.GMAlbumsViewController+GMAlbumsViewTableViewSource, GMImagePicker.Xamarin", "WillDisplayHeaderView");
    }

    -(NSString *) tableView:(UITableView *)p0 titleForHeaderInSection:(NSInteger)p1
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_39 (self, _cmd, &managed_method, p0, p1, "UIKit.UITableView, Xamarin.iOS", "System.nint, Xamarin.iOS", "GMImagePicker.GMAlbumsViewController+GMAlbumsViewTableViewSource, GMImagePicker.Xamarin", "TitleForHeader");
    }

    -(BOOL) conformsToProtocol:(void *)p0
    {
        static MonoMethod *managed_method = NULL;
        return native_to_managed_trampoline_2 (self, _cmd, &managed_method, p0, "System.IntPtr, mscorlib", "Foundation.NSObject, Xamarin.iOS", "InvokeConformsToProtocol");
    }
@end

    static MTClassMap __xamarin_class_map [] = {
        {"NSObject", "Foundation.NSObject, Xamarin.iOS", NULL },
        {"UIResponder", "UIKit.UIResponder, Xamarin.iOS", NULL },
        {"UIViewController", "UIKit.UIViewController, Xamarin.iOS", NULL },
        {"NSIndexPath", "Foundation.NSIndexPath, Xamarin.iOS", NULL },
        {"PHFetchOptions", "Photos.PHFetchOptions, Xamarin.iOS", NULL },
        {"NSIndexSet", "Foundation.NSIndexSet, Xamarin.iOS", NULL },
        {"PHFetchResultChangeDetails", "Photos.PHFetchResultChangeDetails, Xamarin.iOS", NULL },
        {"PHImageManager", "Photos.PHImageManager, Xamarin.iOS", NULL },
        {"UIFocusAnimationCoordinator", "UIKit.UIFocusAnimationCoordinator, Xamarin.iOS", NULL },
        {"UIFocusUpdateContext", "UIKit.UIFocusUpdateContext, Xamarin.iOS", NULL },
        {"PHImageRequestOptions", "Photos.PHImageRequestOptions, Xamarin.iOS", NULL },
        {"NSLayoutConstraint", "UIKit.NSLayoutConstraint, Xamarin.iOS", NULL },
        {"PHObject", "Photos.PHObject, Xamarin.iOS", NULL },
        {"PHPhotoLibrary", "Photos.PHPhotoLibrary, Xamarin.iOS", NULL },
        {"UIFont", "UIKit.UIFont, Xamarin.iOS", NULL },
        {"NSArray", "Foundation.NSArray, Xamarin.iOS", NULL },
        {"NSMutableArray", "Foundation.NSMutableArray, Xamarin.iOS", NULL },
        {"UIApplication", "UIKit.UIApplication, Xamarin.iOS", NULL },
        {"NSBundle", "Foundation.NSBundle, Xamarin.iOS", NULL },
        {"UIBarItem", "UIKit.UIBarItem, Xamarin.iOS", NULL },
        {"UIBezierPath", "UIKit.UIBezierPath, Xamarin.iOS", NULL },
        {"UIView", "UIKit.UIView, Xamarin.iOS", NULL },
        {"UIControl", "UIKit.UIControl, Xamarin.iOS", NULL },
        {"UIButton", "UIKit.UIButton, Xamarin.iOS", NULL },
        {"NSCoder", "Foundation.NSCoder, Xamarin.iOS", NULL },
        {"UIScrollView", "UIKit.UIScrollView, Xamarin.iOS", NULL },
        {"UICollectionView", "UIKit.UICollectionView, Xamarin.iOS", NULL },
        {"UICollectionViewLayout", "UIKit.UICollectionViewLayout, Xamarin.iOS", NULL },
        {"UICollectionViewLayoutAttributes", "UIKit.UICollectionViewLayoutAttributes, Xamarin.iOS", NULL },
        {"UICollectionViewTransitionLayout", "UIKit.UICollectionViewTransitionLayout, Xamarin.iOS", NULL },
        {"UIColor", "UIKit.UIColor, Xamarin.iOS", NULL },
        {"UINavigationController", "UIKit.UINavigationController, Xamarin.iOS", NULL },
        {"UIImagePickerController", "UIKit.UIImagePickerController, Xamarin.iOS", NULL },
        {"UIKit_UIControlEventProxy", "UIKit.UIControlEventProxy, Xamarin.iOS", NULL },
        {"UIDevice", "UIKit.UIDevice, Xamarin.iOS", NULL },
        {"NSNull", "Foundation.NSNull, Xamarin.iOS", NULL },
        {"NSValue", "Foundation.NSValue, Xamarin.iOS", NULL },
        {"NSNumber", "Foundation.NSNumber, Xamarin.iOS", NULL },
        {"UIImageView", "UIKit.UIImageView, Xamarin.iOS", NULL },
        {"__MonoTouch_UIImageStatusDispatcher", "UIKit.UIImageStatusDispatcher, Xamarin.iOS", NULL },
        {"UINavigationBar", "UIKit.UINavigationBar, Xamarin.iOS", NULL },
        {"UIPresentationController", "UIKit.UIPresentationController, Xamarin.iOS", NULL },
        {"UIPopoverPresentationController", "UIKit.UIPopoverPresentationController, Xamarin.iOS", NULL },
        {"NSPredicate", "Foundation.NSPredicate, Xamarin.iOS", NULL },
        {"NSRunLoop", "Foundation.NSRunLoop, Xamarin.iOS", NULL },
        {"UIScreen", "UIKit.UIScreen, Xamarin.iOS", NULL },
        {"UITableView", "UIKit.UITableView, Xamarin.iOS", NULL },
        {"UITableViewCell", "UIKit.UITableViewCell, Xamarin.iOS", NULL },
        {"NSString", "Foundation.NSString, Xamarin.iOS", NULL },
        {"UIToolbar", "UIKit.UIToolbar, Xamarin.iOS", NULL },
        {"NSURL", "Foundation.NSUrl, Xamarin.iOS", NULL },
        {"NSSortDescriptor", "Foundation.NSSortDescriptor, Xamarin.iOS", NULL },
        {"UILabel", "UIKit.UILabel, Xamarin.iOS", NULL },
        {"UILocalNotification", "UIKit.UILocalNotification, Xamarin.iOS", NULL },
        {"UINavigationItem", "UIKit.UINavigationItem, Xamarin.iOS", NULL },
        {"__MonoMac_NSActionDispatcher", "Foundation.NSActionDispatcher, Xamarin.iOS", NULL },
        {"__MonoMac_NSAsyncActionDispatcher", "Foundation.NSAsyncActionDispatcher, Xamarin.iOS", NULL },
        {"NSAutoreleasePool", "Foundation.NSAutoreleasePool, Xamarin.iOS", NULL },
        {"NSError", "Foundation.NSError, Xamarin.iOS", NULL },
        {"CALayer", "CoreAnimation.CALayer, Xamarin.iOS", NULL },
        {"CAGradientLayer", "CoreAnimation.CAGradientLayer, Xamarin.iOS", NULL },
        {"NSUserActivity", "Foundation.NSUserActivity, Xamarin.iOS", NULL },
        {"UIPress", "UIKit.UIPress, Xamarin.iOS", NULL },
        {"ALAssetsLibrary", "AssetsLibrary.ALAssetsLibrary, Xamarin.iOS", NULL },
        {"UITableViewController", "UIKit.UITableViewController, Xamarin.iOS", NULL },
        {"UITableViewFocusUpdateContext", "UIKit.UITableViewFocusUpdateContext, Xamarin.iOS", NULL },
        {"NSException", "Foundation.NSException, Xamarin.iOS", NULL },
        {"UITableViewHeaderFooterView", "UIKit.UITableViewHeaderFooterView, Xamarin.iOS", NULL },
        {"UITableViewRowAction", "UIKit.UITableViewRowAction, Xamarin.iOS", NULL },
        {"PHAsset", "Photos.PHAsset, Xamarin.iOS", NULL },
        {"PHCollection", "Photos.PHCollection, Xamarin.iOS", NULL },
        {"PHAssetCollection", "Photos.PHAssetCollection, Xamarin.iOS", NULL },
        {"PHCachingImageManager", "Photos.PHCachingImageManager, Xamarin.iOS", NULL },
        {"PHChange", "Photos.PHChange, Xamarin.iOS", NULL },
        {"UIAlertAction", "UIKit.UIAlertAction, Xamarin.iOS", NULL },
        {"UIAlertController", "UIKit.UIAlertController, Xamarin.iOS", NULL },
        {"UICollectionViewFlowLayout", "UIKit.UICollectionViewFlowLayout, Xamarin.iOS", NULL },
        {"UICollectionViewFocusUpdateContext", "UIKit.UICollectionViewFocusUpdateContext, Xamarin.iOS", NULL },
        {"UICollectionReusableView", "UIKit.UICollectionReusableView, Xamarin.iOS", NULL },
        {"UICollectionViewCell", "UIKit.UICollectionViewCell, Xamarin.iOS", NULL },
        {"UIUserNotificationSettings", "UIKit.UIUserNotificationSettings, Xamarin.iOS", NULL },
        {"UICollectionViewController", "UIKit.UICollectionViewController, Xamarin.iOS", NULL },
        {"UITouch", "UIKit.UITouch, Xamarin.iOS", NULL },
        {"UIWindow", "UIKit.UIWindow, Xamarin.iOS", NULL },
        {"UITraitCollection", "UIKit.UITraitCollection, Xamarin.iOS", NULL },
        {"UIApplicationShortcutItem", "UIKit.UIApplicationShortcutItem, Xamarin.iOS", NULL },
        {"PHFetchResult", "Photos.PHFetchResult, Xamarin.iOS", NULL },
        {"UIGestureRecognizer", "UIKit.UIGestureRecognizer, Xamarin.iOS", NULL },
        {"UIBarButtonItem", "UIKit.UIBarButtonItem, Xamarin.iOS", NULL },
        {"UIImage", "UIKit.UIImage, Xamarin.iOS", NULL },
        {"NSData", "Foundation.NSData, Xamarin.iOS", NULL },
        {"NSDictionary", "Foundation.NSDictionary, Xamarin.iOS", NULL },
        {"NSMutableDictionary", "Foundation.NSMutableDictionary, Xamarin.iOS", NULL },
        {"AVCaptureDevice", "AVFoundation.AVCaptureDevice, Xamarin.iOS", NULL },
        {"AppDelegate", "GMPickerTest.AppDelegate, GMPickerTest", NULL },
        {"ViewController", "GMPickerTest.ViewController, GMPickerTest", NULL },
        {"__UIGestureRecognizerToken", "UIKit.UIGestureRecognizer+Token, Xamarin.iOS", NULL },
        {"__UIGestureRecognizerParameterlessToken", "UIKit.UIGestureRecognizer+ParameterlessDispatch, Xamarin.iOS", NULL },
        {"__UIGestureRecognizerParametrizedToken", "UIKit.UIGestureRecognizer+ParametrizedDispatch, Xamarin.iOS", NULL },
        {"UIKit_UIBarButtonItem_Callback", "UIKit.UIBarButtonItem+Callback, Xamarin.iOS", NULL },
        {"__NSObject_Disposer", "Foundation.NSObject+NSObject_Disposer, Xamarin.iOS", NULL },
        {"UIKit_UIScrollView__UIScrollViewDelegate", "UIKit.UIScrollView+_UIScrollViewDelegate, Xamarin.iOS", NULL },
        {"GMImagePicker_GMAlbumsViewCell", "GMImagePicker.GMAlbumsViewCell, GMImagePicker.Xamarin", NULL },
        {"GMImagePicker_GMGridViewCell", "GMImagePicker.GMGridViewCell, GMImagePicker.Xamarin", NULL },
        {"DummyClass", "GMImagePicker.DummyClass, GMImagePicker.Xamarin", NULL },
        {"GMImagePicker_GMGridViewController", "GMImagePicker.GMGridViewController, GMImagePicker.Xamarin", NULL },
        {"GMImagePicker_GMImagePickerController_GMNavigationControllerDelegate", "GMImagePicker.GMImagePickerController+GMNavigationControllerDelegate, GMImagePicker.Xamarin", NULL },
        {"GMImagePicker_GMImagePickerController", "GMImagePicker.GMImagePickerController, GMImagePicker.Xamarin", NULL },
        {"GMImagePicker_GMAlbumsViewController", "GMImagePicker.GMAlbumsViewController, GMImagePicker.Xamarin", NULL },
        {"GMImagePicker_GMGridViewController_GMGridViewCollectionViewSource", "GMImagePicker.GMGridViewController+GMGridViewCollectionViewSource, GMImagePicker.Xamarin", NULL },
        {"GMImagePicker_GMImagePickerController_GMImagePickerDelegate", "GMImagePicker.GMImagePickerController+GMImagePickerDelegate, GMImagePicker.Xamarin", NULL },
        {"GMImagePicker_GMAlbumsViewController_GMAlbumsViewTableViewSource", "GMImagePicker.GMAlbumsViewController+GMAlbumsViewTableViewSource, GMImagePicker.Xamarin", NULL },
        { NULL, NULL, NULL },
    };

    static const char *__xamarin_registration_assemblies []= {
        "GMPickerTest",
        "Xamarin.iOS",
        "mscorlib",
        "System",
        "System.Core",
        "GMImagePicker.Xamarin"
    };

    static struct MTRegistrationMap __xamarin_registration_map = {
        NULL,
        __xamarin_registration_assemblies,
        __xamarin_class_map,
        6,
        112,
        18
    };

void xamarin_create_classes () {
    __xamarin_class_map [0].handle = objc_getClass ("NSObject");
    __xamarin_class_map [1].handle = objc_getClass ("UIResponder");
    __xamarin_class_map [2].handle = objc_getClass ("UIViewController");
    __xamarin_class_map [3].handle = objc_getClass ("NSIndexPath");
    __xamarin_class_map [4].handle = objc_getClass ("PHFetchOptions");
    __xamarin_class_map [5].handle = objc_getClass ("NSIndexSet");
    __xamarin_class_map [6].handle = objc_getClass ("PHFetchResultChangeDetails");
    __xamarin_class_map [7].handle = objc_getClass ("PHImageManager");
    __xamarin_class_map [8].handle = objc_getClass ("UIFocusAnimationCoordinator");
    __xamarin_class_map [9].handle = objc_getClass ("UIFocusUpdateContext");
    __xamarin_class_map [10].handle = objc_getClass ("PHImageRequestOptions");
    __xamarin_class_map [11].handle = objc_getClass ("NSLayoutConstraint");
    __xamarin_class_map [12].handle = objc_getClass ("PHObject");
    __xamarin_class_map [13].handle = objc_getClass ("PHPhotoLibrary");
    __xamarin_class_map [14].handle = objc_getClass ("UIFont");
    __xamarin_class_map [15].handle = objc_getClass ("NSArray");
    __xamarin_class_map [16].handle = objc_getClass ("NSMutableArray");
    __xamarin_class_map [17].handle = objc_getClass ("UIApplication");
    __xamarin_class_map [18].handle = objc_getClass ("NSBundle");
    __xamarin_class_map [19].handle = objc_getClass ("UIBarItem");
    __xamarin_class_map [20].handle = objc_getClass ("UIBezierPath");
    __xamarin_class_map [21].handle = objc_getClass ("UIView");
    __xamarin_class_map [22].handle = objc_getClass ("UIControl");
    __xamarin_class_map [23].handle = objc_getClass ("UIButton");
    __xamarin_class_map [24].handle = objc_getClass ("NSCoder");
    __xamarin_class_map [25].handle = objc_getClass ("UIScrollView");
    __xamarin_class_map [26].handle = objc_getClass ("UICollectionView");
    __xamarin_class_map [27].handle = objc_getClass ("UICollectionViewLayout");
    __xamarin_class_map [28].handle = objc_getClass ("UICollectionViewLayoutAttributes");
    __xamarin_class_map [29].handle = objc_getClass ("UICollectionViewTransitionLayout");
    __xamarin_class_map [30].handle = objc_getClass ("UIColor");
    __xamarin_class_map [31].handle = objc_getClass ("UINavigationController");
    __xamarin_class_map [32].handle = objc_getClass ("UIImagePickerController");
    __xamarin_class_map [33].handle = objc_getClass ("UIKit_UIControlEventProxy");
    __xamarin_class_map [34].handle = objc_getClass ("UIDevice");
    __xamarin_class_map [35].handle = objc_getClass ("NSNull");
    __xamarin_class_map [36].handle = objc_getClass ("NSValue");
    __xamarin_class_map [37].handle = objc_getClass ("NSNumber");
    __xamarin_class_map [38].handle = objc_getClass ("UIImageView");
    __xamarin_class_map [39].handle = objc_getClass ("__MonoTouch_UIImageStatusDispatcher");
    __xamarin_class_map [40].handle = objc_getClass ("UINavigationBar");
    __xamarin_class_map [41].handle = objc_getClass ("UIPresentationController");
    __xamarin_class_map [42].handle = objc_getClass ("UIPopoverPresentationController");
    __xamarin_class_map [43].handle = objc_getClass ("NSPredicate");
    __xamarin_class_map [44].handle = objc_getClass ("NSRunLoop");
    __xamarin_class_map [45].handle = objc_getClass ("UIScreen");
    __xamarin_class_map [46].handle = objc_getClass ("UITableView");
    __xamarin_class_map [47].handle = objc_getClass ("UITableViewCell");
    __xamarin_class_map [48].handle = objc_getClass ("NSString");
    __xamarin_class_map [49].handle = objc_getClass ("UIToolbar");
    __xamarin_class_map [50].handle = objc_getClass ("NSURL");
    __xamarin_class_map [51].handle = objc_getClass ("NSSortDescriptor");
    __xamarin_class_map [52].handle = objc_getClass ("UILabel");
    __xamarin_class_map [53].handle = objc_getClass ("UILocalNotification");
    __xamarin_class_map [54].handle = objc_getClass ("UINavigationItem");
    __xamarin_class_map [55].handle = objc_getClass ("__MonoMac_NSActionDispatcher");
    __xamarin_class_map [56].handle = objc_getClass ("__MonoMac_NSAsyncActionDispatcher");
    __xamarin_class_map [57].handle = objc_getClass ("NSAutoreleasePool");
    __xamarin_class_map [58].handle = objc_getClass ("NSError");
    __xamarin_class_map [59].handle = objc_getClass ("CALayer");
    __xamarin_class_map [60].handle = objc_getClass ("CAGradientLayer");
    __xamarin_class_map [61].handle = objc_getClass ("NSUserActivity");
    __xamarin_class_map [62].handle = objc_getClass ("UIPress");
    __xamarin_class_map [63].handle = objc_getClass ("ALAssetsLibrary");
    __xamarin_class_map [64].handle = objc_getClass ("UITableViewController");
    __xamarin_class_map [65].handle = objc_getClass ("UITableViewFocusUpdateContext");
    __xamarin_class_map [66].handle = objc_getClass ("NSException");
    __xamarin_class_map [67].handle = objc_getClass ("UITableViewHeaderFooterView");
    __xamarin_class_map [68].handle = objc_getClass ("UITableViewRowAction");
    __xamarin_class_map [69].handle = objc_getClass ("PHAsset");
    __xamarin_class_map [70].handle = objc_getClass ("PHCollection");
    __xamarin_class_map [71].handle = objc_getClass ("PHAssetCollection");
    __xamarin_class_map [72].handle = objc_getClass ("PHCachingImageManager");
    __xamarin_class_map [73].handle = objc_getClass ("PHChange");
    __xamarin_class_map [74].handle = objc_getClass ("UIAlertAction");
    __xamarin_class_map [75].handle = objc_getClass ("UIAlertController");
    __xamarin_class_map [76].handle = objc_getClass ("UICollectionViewFlowLayout");
    __xamarin_class_map [77].handle = objc_getClass ("UICollectionViewFocusUpdateContext");
    __xamarin_class_map [78].handle = objc_getClass ("UICollectionReusableView");
    __xamarin_class_map [79].handle = objc_getClass ("UICollectionViewCell");
    __xamarin_class_map [80].handle = objc_getClass ("UIUserNotificationSettings");
    __xamarin_class_map [81].handle = objc_getClass ("UICollectionViewController");
    __xamarin_class_map [82].handle = objc_getClass ("UITouch");
    __xamarin_class_map [83].handle = objc_getClass ("UIWindow");
    __xamarin_class_map [84].handle = objc_getClass ("UITraitCollection");
    __xamarin_class_map [85].handle = objc_getClass ("UIApplicationShortcutItem");
    __xamarin_class_map [86].handle = objc_getClass ("PHFetchResult");
    __xamarin_class_map [87].handle = objc_getClass ("UIGestureRecognizer");
    __xamarin_class_map [88].handle = objc_getClass ("UIBarButtonItem");
    __xamarin_class_map [89].handle = objc_getClass ("UIImage");
    __xamarin_class_map [90].handle = objc_getClass ("NSData");
    __xamarin_class_map [91].handle = objc_getClass ("NSDictionary");
    __xamarin_class_map [92].handle = objc_getClass ("NSMutableDictionary");
    __xamarin_class_map [93].handle = objc_getClass ("AVCaptureDevice");
    __xamarin_class_map [94].handle = [AppDelegate class];
    __xamarin_class_map [95].handle = [ViewController class];
    __xamarin_class_map [96].handle = objc_getClass ("__UIGestureRecognizerToken");
    __xamarin_class_map [97].handle = objc_getClass ("__UIGestureRecognizerParameterlessToken");
    __xamarin_class_map [98].handle = objc_getClass ("__UIGestureRecognizerParametrizedToken");
    __xamarin_class_map [99].handle = objc_getClass ("UIKit_UIBarButtonItem_Callback");
    __xamarin_class_map [100].handle = objc_getClass ("__NSObject_Disposer");
    __xamarin_class_map [101].handle = objc_getClass ("UIKit_UIScrollView__UIScrollViewDelegate");
    __xamarin_class_map [102].handle = [GMImagePicker_GMAlbumsViewCell class];
    __xamarin_class_map [103].handle = [GMImagePicker_GMGridViewCell class];
    __xamarin_class_map [104].handle = [DummyClass class];
    __xamarin_class_map [105].handle = [GMImagePicker_GMGridViewController class];
    __xamarin_class_map [106].handle = [GMImagePicker_GMImagePickerController_GMNavigationControllerDelegate class];
    __xamarin_class_map [107].handle = [GMImagePicker_GMImagePickerController class];
    __xamarin_class_map [108].handle = [GMImagePicker_GMAlbumsViewController class];
    __xamarin_class_map [109].handle = [GMImagePicker_GMGridViewController_GMGridViewCollectionViewSource class];
    __xamarin_class_map [110].handle = [GMImagePicker_GMImagePickerController_GMImagePickerDelegate class];
    __xamarin_class_map [111].handle = [GMImagePicker_GMAlbumsViewController_GMAlbumsViewTableViewSource class];
    xamarin_add_registration_map (&__xamarin_registration_map);
}