#include "il2cpp-config.h"
#include "class-internals.h"
#include "codegen/il2cpp-codegen.h"
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#include "t1742.h"
#include <cstring>
#include <string.h>
#include <stdio.h>
#ifndef _MSC_VER
#include <alloca.h>
#else
#include <malloc.h>
#endif
#include <cmath>
#include <limits>
#include <assert.h>
#include "t1742MD.h"


#include "t96.h"

// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$3132
void t1742_marshal(const t1742& unmarshaled, t1742_marshaled& marshaled)
{
}
void t1742_marshal_back(const t1742_marshaled& marshaled, t1742& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$3132
void t1742_marshal_cleanup(t1742_marshaled& marshaled)
{
}
#include "t1743.h"
#ifndef _MSC_VER
#else
#endif
#include "t1743MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$20
void t1743_marshal(const t1743& unmarshaled, t1743_marshaled& marshaled)
{
}
void t1743_marshal_back(const t1743_marshaled& marshaled, t1743& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$20
void t1743_marshal_cleanup(t1743_marshaled& marshaled)
{
}
#include "t1744.h"
#ifndef _MSC_VER
#else
#endif
#include "t1744MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$32
void t1744_marshal(const t1744& unmarshaled, t1744_marshaled& marshaled)
{
}
void t1744_marshal_back(const t1744_marshaled& marshaled, t1744& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$32
void t1744_marshal_cleanup(t1744_marshaled& marshaled)
{
}
#include "t1745.h"
#ifndef _MSC_VER
#else
#endif
#include "t1745MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$48
void t1745_marshal(const t1745& unmarshaled, t1745_marshaled& marshaled)
{
}
void t1745_marshal_back(const t1745_marshaled& marshaled, t1745& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$48
void t1745_marshal_cleanup(t1745_marshaled& marshaled)
{
}
#include "t1746.h"
#ifndef _MSC_VER
#else
#endif
#include "t1746MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$64
void t1746_marshal(const t1746& unmarshaled, t1746_marshaled& marshaled)
{
}
void t1746_marshal_back(const t1746_marshaled& marshaled, t1746& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$64
void t1746_marshal_cleanup(t1746_marshaled& marshaled)
{
}
#include "t1747.h"
#ifndef _MSC_VER
#else
#endif
#include "t1747MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$12
void t1747_marshal(const t1747& unmarshaled, t1747_marshaled& marshaled)
{
}
void t1747_marshal_back(const t1747_marshaled& marshaled, t1747& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$12
void t1747_marshal_cleanup(t1747_marshaled& marshaled)
{
}
#include "t1748.h"
#ifndef _MSC_VER
#else
#endif
#include "t1748MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$136
void t1748_marshal(const t1748& unmarshaled, t1748_marshaled& marshaled)
{
}
void t1748_marshal_back(const t1748_marshaled& marshaled, t1748& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$136
void t1748_marshal_cleanup(t1748_marshaled& marshaled)
{
}
#include "t1749.h"
#ifndef _MSC_VER
#else
#endif
#include "t1749MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$8
void t1749_marshal(const t1749& unmarshaled, t1749_marshaled& marshaled)
{
}
void t1749_marshal_back(const t1749_marshaled& marshaled, t1749& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$8
void t1749_marshal_cleanup(t1749_marshaled& marshaled)
{
}
#include "t1750.h"
#ifndef _MSC_VER
#else
#endif
#include "t1750MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$72
void t1750_marshal(const t1750& unmarshaled, t1750_marshaled& marshaled)
{
}
void t1750_marshal_back(const t1750_marshaled& marshaled, t1750& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$72
void t1750_marshal_cleanup(t1750_marshaled& marshaled)
{
}
#include "t1751.h"
#ifndef _MSC_VER
#else
#endif
#include "t1751MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$124
void t1751_marshal(const t1751& unmarshaled, t1751_marshaled& marshaled)
{
}
void t1751_marshal_back(const t1751_marshaled& marshaled, t1751& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$124
void t1751_marshal_cleanup(t1751_marshaled& marshaled)
{
}
#include "t1752.h"
#ifndef _MSC_VER
#else
#endif
#include "t1752MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$96
void t1752_marshal(const t1752& unmarshaled, t1752_marshaled& marshaled)
{
}
void t1752_marshal_back(const t1752_marshaled& marshaled, t1752& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$96
void t1752_marshal_cleanup(t1752_marshaled& marshaled)
{
}
#include "t1753.h"
#ifndef _MSC_VER
#else
#endif
#include "t1753MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$2048
void t1753_marshal(const t1753& unmarshaled, t1753_marshaled& marshaled)
{
}
void t1753_marshal_back(const t1753_marshaled& marshaled, t1753& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$2048
void t1753_marshal_cleanup(t1753_marshaled& marshaled)
{
}
#include "t1754.h"
#ifndef _MSC_VER
#else
#endif
#include "t1754MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$256
void t1754_marshal(const t1754& unmarshaled, t1754_marshaled& marshaled)
{
}
void t1754_marshal_back(const t1754_marshaled& marshaled, t1754& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$256
void t1754_marshal_cleanup(t1754_marshaled& marshaled)
{
}
#include "t1755.h"
#ifndef _MSC_VER
#else
#endif
#include "t1755MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$1024
void t1755_marshal(const t1755& unmarshaled, t1755_marshaled& marshaled)
{
}
void t1755_marshal_back(const t1755_marshaled& marshaled, t1755& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$1024
void t1755_marshal_cleanup(t1755_marshaled& marshaled)
{
}
#include "t1756.h"
#ifndef _MSC_VER
#else
#endif
#include "t1756MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$640
void t1756_marshal(const t1756& unmarshaled, t1756_marshaled& marshaled)
{
}
void t1756_marshal_back(const t1756_marshaled& marshaled, t1756& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$640
void t1756_marshal_cleanup(t1756_marshaled& marshaled)
{
}
#include "t1757.h"
#ifndef _MSC_VER
#else
#endif
#include "t1757MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$128
void t1757_marshal(const t1757& unmarshaled, t1757_marshaled& marshaled)
{
}
void t1757_marshal_back(const t1757_marshaled& marshaled, t1757& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$128
void t1757_marshal_cleanup(t1757_marshaled& marshaled)
{
}
#include "t1758.h"
#ifndef _MSC_VER
#else
#endif
#include "t1758MD.h"



// Conversion methods for marshalling of: <PrivateImplementationDetails>/$ArrayType$52
void t1758_marshal(const t1758& unmarshaled, t1758_marshaled& marshaled)
{
}
void t1758_marshal_back(const t1758_marshaled& marshaled, t1758& unmarshaled)
{
}
// Conversion method for clean up from marshalling of: <PrivateImplementationDetails>/$ArrayType$52
void t1758_marshal_cleanup(t1758_marshaled& marshaled)
{
}
#include "t1759.h"
#ifndef _MSC_VER
#else
#endif
#include "t1759MD.h"



#ifdef __clang__
#pragma clang diagnostic pop
#endif
