blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 4
201
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 0
85
| license_type
stringclasses 2
values | repo_name
stringlengths 7
100
| snapshot_id
stringlengths 40
40
| revision_id
stringlengths 40
40
| branch_name
stringclasses 260
values | visit_date
timestamp[us] | revision_date
timestamp[us] | committer_date
timestamp[us] | github_id
int64 11.4k
681M
⌀ | star_events_count
int64 0
209k
| fork_events_count
int64 0
110k
| gha_license_id
stringclasses 17
values | gha_event_created_at
timestamp[us] | gha_created_at
timestamp[us] | gha_language
stringclasses 80
values | src_encoding
stringclasses 28
values | language
stringclasses 1
value | is_vendor
bool 1
class | is_generated
bool 2
classes | length_bytes
int64 8
9.86M
| extension
stringclasses 52
values | content
stringlengths 8
9.86M
| authors
sequencelengths 1
1
| author
stringlengths 0
119
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
f7547b7a9aef924c2c5392eccae8ff57497546a9 | 556db265723b0cc30ad2917442ed6dad92fd9044 | /tensorflow/compiler/xla/tests/multiple_devices_on_host_test.cc | d54139f384d09e6962e6a09d6d520a5cec5b6a3f | [
"MIT",
"Apache-2.0",
"BSD-2-Clause"
] | permissive | graphcore/tensorflow | c1669b489be0e045b3ec856b311b3139858de196 | 085b20a4b6287eff8c0b792425d52422ab8cbab3 | refs/heads/r2.6/sdk-release-3.2 | 2023-07-06T06:23:53.857743 | 2023-03-14T13:04:04 | 2023-03-14T13:48:43 | 162,717,602 | 84 | 17 | Apache-2.0 | 2023-03-25T01:13:37 | 2018-12-21T13:30:38 | C++ | UTF-8 | C++ | false | false | 4,860 | cc | /* Copyright 2018 The TensorFlow Authors. All Rights Reserved.
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
==============================================================================*/
#include "absl/synchronization/mutex.h"
#include "tensorflow/compiler/xla/client/client_library.h"
#include "tensorflow/compiler/xla/client/xla_builder.h"
#include "tensorflow/compiler/xla/shape_util.h"
#include "tensorflow/core/lib/core/status_test_util.h"
#include "tensorflow/core/platform/env.h"
#include "tensorflow/core/platform/test.h"
namespace xla {
namespace {
StatusOr<XlaComputation> BuildComputation() {
XlaBuilder b("computation");
Shape scalar_s32 = ShapeUtil::MakeShape(S32, {});
XlaOp infeed = InfeedWithToken(CreateToken(&b), scalar_s32);
return b.Build(
OutfeedWithToken(GetTupleElement(infeed, 0) +
ConstantLiteral(&b, LiteralUtil::CreateR0<int32>(1)),
GetTupleElement(infeed, 1), scalar_s32, ""));
}
void CompileAndExecute(
LocalExecutable* executable, int device_ordinal, LocalClient* client,
absl::Mutex* results_mutex,
std::vector<std::pair<int, StatusOr<ScopedShapedBuffer>>>* results) {
xla::ExecutableRunOptions execute_options;
execute_options.set_intra_op_thread_pool(
client->backend().eigen_intra_op_thread_pool_device());
execute_options.set_device_ordinal(device_ordinal);
execute_options.set_allocator(
xla::ClientLibrary::GetXlaService(client->platform())
->backend()
.memory_allocator());
StatusOr<ScopedShapedBuffer> result =
executable->Run(absl::Span<const ShapedBuffer* const>(), execute_options);
{
absl::MutexLock lock(results_mutex);
results->emplace_back(device_ordinal, std::move(result));
}
}
void TestWithDeviceCount(const int device_count) {
// Run `device_count` copies of the XLA program built by BuildComputation.
TF_ASSERT_OK_AND_ASSIGN(
se::Platform* const platform,
perftools::gputools::MultiPlatformManager::PlatformWithName("Host"));
xla::LocalClientOptions client_options;
client_options.set_platform(platform);
TF_ASSERT_OK_AND_ASSIGN(
LocalClient* const client,
xla::ClientLibrary::GetOrCreateLocalClient(client_options));
TF_ASSERT_OK_AND_ASSIGN(XlaComputation xla_computation, BuildComputation());
TF_ASSERT_OK_AND_ASSIGN(
auto executables,
client->Compile(xla_computation, {}, xla::ExecutableBuildOptions{}));
std::unique_ptr<LocalExecutable> executable = std::move(executables[0]);
std::vector<tensorflow::Thread*> threads;
absl::Mutex results_mutex;
std::vector<std::pair<int, StatusOr<ScopedShapedBuffer>>> results;
tensorflow::Env* env = tensorflow::Env::Default();
for (int device_ordinal = 0; device_ordinal < device_count;
device_ordinal++) {
tensorflow::Thread* t = env->StartThread(
tensorflow::ThreadOptions{}, absl::StrCat("thread-", device_ordinal),
[&executable, device_ordinal, client, &results_mutex, &results] {
CompileAndExecute(executable.get(), device_ordinal, client,
&results_mutex, &results);
});
threads.push_back(t);
}
for (int device_ordinal = 0; device_ordinal < device_count;
device_ordinal++) {
TF_ASSERT_OK(client->TransferToInfeedLocal(
LiteralUtil::CreateR0<int32>(device_ordinal * 100), device_ordinal));
}
for (int device_ordinal = 0; device_ordinal < device_count;
device_ordinal++) {
Literal outfeed(ShapeUtil::MakeShape(S32, {}));
TF_ASSERT_OK(client->TransferFromOutfeedLocal(device_ordinal, &outfeed));
EXPECT_EQ(outfeed, LiteralUtil::CreateR0<int32>(device_ordinal * 100 + 1));
}
for (int device_ordinal = 0; device_ordinal < device_count;
device_ordinal++) {
delete threads[device_ordinal];
}
for (int device_ordinal = 0; device_ordinal < device_count;
device_ordinal++) {
TF_ASSERT_OK(results[device_ordinal].second.status());
}
}
// NB! This test requires --xla_force_host_platform_device_count=4
TEST(MultipleDeviceOnHostTest, OneDevice) { TestWithDeviceCount(1); }
TEST(MultipleDeviceOnHostTest, TwoDevices) { TestWithDeviceCount(2); }
TEST(MultipleDeviceOnHostTest, ThreeDevices) { TestWithDeviceCount(3); }
TEST(MultipleDeviceOnHostTest, FourDevices) { TestWithDeviceCount(4); }
} // namespace
} // namespace xla
| [
"[email protected]"
] | |
40aefd31e4f071c9a8d204fbd8758f31021751c7 | e7d5f58b5946c95e2bab39ac0a9caa1b84c81e8b | /AR_Sim/Misc/WindowsHandler.cpp | ec23895e62b45338b48168d889779c1f0a4b0616 | [] | no_license | ATriantafyllopoulos/Diploma_Thesis | fa198317d891ff6b81b2ecf84d671277429156ca | 1b801f30c39fb70404332b7de39b2a9a3bd9989e | refs/heads/master | 2021-01-17T07:14:56.547216 | 2016-12-22T14:26:32 | 2016-12-22T14:26:32 | 55,900,291 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,773 | cpp | #include "WindowsHandler.h"
//global static instance used to reference member function as glfw callbacks
static WindowsHandler *callBackInstance;
WindowsHandler::WindowsHandler() : WindowsHandler::WindowsHandler("Default Name", 640, 480)
{
fpsCount = 0;
fpsLimit = 1;
title = "";
width = 0;
height = 0;
viewMode = M_VIEW;
objectMode = M_POINT_SPRITE;
collisionMethod = M_BVH;
virtualDemo = false;
}
WindowsHandler::WindowsHandler(std::string inTitle, int inWidth, int inHeight)
{
callBackInstance = this;
fpsCount = 0;
fpsLimit = 1;
title = inTitle;
width = inWidth;
height = inHeight;
createWindow();
glfwSetMouseButtonCallback(window, onMouseClickPure);
glfwSetKeyCallback(window, keyCallbackPure);
viewMode = M_AR;
objectMode = M_CUBE;
collisionMethod = M_BVH;
PrintMainMenu();
sdkCreateTimer(&timer);
Object_Rain = false;
Rain_Counter = 0;
}
void WindowsHandler::keyCallback(GLFWwindow* window, int key, int scancode, int action, int mods)
{
if (key == GLFW_KEY_C && action == GLFW_PRESS)
{
world->toggleARcollisions();
}
else if (key == GLFW_KEY_V && action == GLFW_PRESS)
{
if(viewMode == M_AR)
{
std::cout << "Changing to free moving view mode." << std::endl;
viewMode = M_VIEW;
world->setMode(M_VIEW);
}
else if(viewMode == M_VIEW)
{
std::cout << "Changing to AR view mode." << std::endl;
viewMode = M_AR;
world->setMode(M_AR);
}
}
else if (key == GLFW_KEY_O && action == GLFW_PRESS)
{
ChangeObject();
}
else if (key == GLFW_KEY_M && action == GLFW_PRESS)
{
if(collisionMethod == M_BVH)
{
std::cout << "Changing to collision detection using uniform grid." << std::endl;
collisionMethod = M_UNIFORM_GRID;
world->setCollisionDetectionMethod(M_UNIFORM_GRID);
}
else if(collisionMethod == M_UNIFORM_GRID)
{
std::cout << "Changing to collision detection using BVH." << std::endl;
collisionMethod = M_BVH;
world->setCollisionDetectionMethod(M_BVH);
}
}
else if (key == GLFW_KEY_KP_ADD && action == GLFW_PRESS)
{
world->increaseARrestitution();
}
else if (key == GLFW_KEY_KP_SUBTRACT && action == GLFW_PRESS)
{
world->decreaseARrestitution();
}
else if (key == GLFW_KEY_R && action == GLFW_PRESS)
{
world->toggleShowRangeData();
}
else if (key == GLFW_KEY_E && action == GLFW_PRESS)
{
virtualDemo = true;
}
else if (key == GLFW_KEY_P && action == GLFW_PRESS)
{
//world->togglePauseFrame();
world->toggleSimulation();
}
else if (key == GLFW_KEY_H && action == GLFW_PRESS)
{
PrintMainMenu();
}
else if (key == GLFW_KEY_F && action == GLFW_PRESS)
{
world->toggleSimulation();
world->DemoMode();
world->toggleSimulation();
}
else if (key == GLFW_KEY_Q && action == GLFW_PRESS)
{
Object_Rain = !Object_Rain;
}
else if (key == GLFW_KEY_G && action == GLFW_PRESS)
{
world->toggleGravity();
}
else if (key == GLFW_KEY_F1 && action == GLFW_PRESS)
{
if (mods == GLFW_MOD_SHIFT)
{
std::cout << "Shift+F1 pressed" << std::endl;
world->changeSpring(0.05);
}
else
{
std::cout << "F1 pressed" << std::endl;
world->changeSpring(-0.05);
}
}
else if (key == GLFW_KEY_F2 && action == GLFW_PRESS)
{
if (mods == GLFW_MOD_SHIFT)
{
world->changeDamping(0.005);
}
else
{
world->changeDamping(-0.005);
}
}
else if (key == GLFW_KEY_F3 && action == GLFW_PRESS)
{
if (mods == GLFW_MOD_SHIFT)
{
world->changeGlobalDamping(0.05);
}
else
{
world->changeGlobalDamping(-0.05);
}
}
else if (key == GLFW_KEY_F4 && action == GLFW_PRESS)
{
if (mods == GLFW_MOD_SHIFT)
{
world->changeShear(0.05);
}
else
{
world->changeShear(-0.05);
}
}
}
void WindowsHandler::ChangeObject()
{
if (objectMode == M_BUNNY)
{
std::cout << "Changing to throwing teapots" << std::endl;
objectMode = M_TEAPOT;
world->setObjectMode(M_TEAPOT);
}
else if (objectMode == M_TEAPOT)
{
std::cout << "Changing to throwing bananas" << std::endl;
objectMode = M_BANANA;
world->setObjectMode(M_BANANA);
}
else if (objectMode == M_BANANA)
{
std::cout << "Changing to throwing cubes" << std::endl;
objectMode = M_CUBE;
world->setObjectMode(M_CUBE);
}
else if (objectMode == M_CUBE)
{
std::cout << "Changing to throwing bunnies" << std::endl;
objectMode = M_BUNNY;
world->setObjectMode(M_BUNNY);
}
}
void WindowsHandler::keyCallbackPure(GLFWwindow* window, int key, int scancode, int action, int mods)
{
if(callBackInstance)
callBackInstance->keyCallback(window, key, scancode, action, mods);
}
void WindowsHandler::onMouseClick(GLFWwindow* win, int button, int action, int mods)
{
double xpos, ypos;
glfwGetCursorPos(window, &xpos, &ypos);
if (button == GLFW_MOUSE_BUTTON_RIGHT && action == GLFW_PRESS)
{
world->addSphere(xpos, ypos);
}
else if (button == GLFW_MOUSE_BUTTON_MIDDLE && action == GLFW_PRESS)
{
world->throwSphere(xpos, ypos);
}
}
void WindowsHandler::onMouseClickPure(GLFWwindow* win, int button, int action, int mods)
{
if(callBackInstance)
callBackInstance->onMouseClick(win, button, action, mods);
}
WindowsHandler::~WindowsHandler()
{
sdkDeleteTimer(&timer);
glfwTerminate();
}
void WindowsHandler::PrintMainMenu()
{
std::cout << "Current version only supports keyboard menu" << std::endl;
std::cout << "Press C to toggle AR collisions ON and OFF" << std::endl;
std::cout << "Press V to toggle between a free moving and an AR view mode" << std::endl;
std::cout << "Press M to toggle between collision detection methods (BVH and Uniform Grid)" << std::endl;
std::cout << "Press O to toggle between objects (Stanford Bunny, Teapot, Cube, and Banana)" << std::endl;
std::cout << "Press P pause in a current frame or continue video" << std::endl;
std::cout << "Press R to toggle visualization of range data" << std::endl;
std::cout << "Press H at any time to display these instructions again" << std::endl;
}
void WindowsHandler::createWindow()
{
if( !glfwInit() )
{
fprintf( stderr, "Failed to initialize GLFW\n" );
getchar();
}
glfwWindowHint(GLFW_SAMPLES, 4);
glfwWindowHint(GLFW_RESIZABLE,GL_FALSE);
glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
glfwWindowHint(GLFW_OPENGL_FORWARD_COMPAT, GL_TRUE); // To make MacOS happy; should not be needed
glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
// Open a window and create its OpenGL context
window = glfwCreateWindow( width, height, title.c_str(), NULL, NULL);
glfwMakeContextCurrent(window);
// Initialize GLEW
glewExperimental = GL_TRUE; //necessary because system is unsupported
if (glewInit() != GLEW_OK) {
fprintf(stderr, "Failed to initialize GLEW\n");
getchar();
glfwTerminate();
}
// Ensure we can capture the escape key being pressed below
glfwSetInputMode(window, GLFW_STICKY_KEYS, GL_TRUE);
glfwSetInputMode(window, GLFW_STICKY_MOUSE_BUTTONS, 0);
if (!window)
{
std::cerr << "Error occured during glfw initialization" << std::endl;
}
// Dark blue background
// glClearColor(0.0f, 0.0f, 0.4f, 0.0f);
}
void WindowsHandler::Run()
{
do{
sdkStartTimer(&timer);
world->update();
world->render();
sdkStopTimer(&timer);
computeFPS();
if (Object_Rain)
{
if (++Rain_Counter == 20)
Rain_Objects();
}
} // Check if the ESC key was pressed or the window was closed
while( glfwGetKey(window, GLFW_KEY_ESCAPE ) != GLFW_PRESS &&
glfwWindowShouldClose(window) == 0 );
}
void WindowsHandler::Demo()
{
do{
sdkStartTimer(&timer);
world->DemoMode();
sdkStopTimer(&timer);
computeFPS();
} // Check if the ESC key was pressed or the window was closed
while( glfwGetKey(window, GLFW_KEY_ESCAPE ) != GLFW_PRESS &&
glfwWindowShouldClose(window) == 0 );
}
void WindowsHandler::Rain_Objects()
{
ChangeObject();
double xpos, ypos;
glfwGetCursorPos(window, &xpos, &ypos);
world->addSphere(xpos, ypos);
Rain_Counter = 0;
}
void WindowsHandler::computeFPS()
{
fpsCount++;
if (fpsCount == fpsLimit)
{
float ifps = 1000.f / sdkGetAverageTimerValue(&timer);
fpsCount = 0;
fpsLimit = (int)MAX(ifps, 1.f);
std::string title = "Simulation FPS: ";
std::ostringstream ss;
ss << ifps;
std::string s(ss.str());
title += s;
glfwSetWindowTitle(window, title.c_str());
sdkResetTimer(&timer);
}
}
/**
this function is called by the viewer's constructor
to which an instance of the WindowsHandler class is passed as a paremeter
should be called in main immediately after viewer is created
and definitely before any call to ShowWindow
*/
void WindowsHandler::setWorld(VirtualWorld *w)
{
world = w;
}
| [
"[email protected]"
] | |
693bd09b34d2b2b35dc0148da5e58855bbe8372d | f5ad041e88412641162f46e8efe8a20c912a1ebf | /android/headers/stone/19/frameworks/native/include/media/drm/DrmAPI.h | 4a86218a343184d2634b1c917b839c28cc3984ee | [] | no_license | BAT6188/webrtc_module_core | cef0726e7a113589a3c768ab7909159782d744f6 | e58d71f5a90609ac7bf5f5b91d12533e5d8a6c60 | refs/heads/master | 2023-05-24T06:49:20.606529 | 2016-05-28T03:39:17 | 2016-05-28T03:50:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,521 | h | /*
* Copyright (C) 2013 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef DRM_API_H_
#define DRM_API_H_
#include <utils/List.h>
#include <utils/String8.h>
#include <utils/Vector.h>
#include <utils/KeyedVector.h>
#include <utils/RefBase.h>
#include <utils/Mutex.h>
#include <media/stagefright/foundation/ABase.h>
// Loadable DrmEngine shared libraries should define the entry points
// createDrmFactory and createCryptoFactory as shown below:
//
// extern "C" {
// extern android::DrmFactory *createDrmFactory();
// extern android::CryptoFactory *createCryptoFactory();
// }
namespace android {
class DrmPlugin;
class DrmPluginListener;
// DRMs are implemented in DrmEngine plugins, which are dynamically
// loadable shared libraries that implement the entry points
// createDrmFactory and createCryptoFactory. createDrmFactory
// constructs and returns an instance of a DrmFactory object. Similarly,
// createCryptoFactory creates an instance of a CryptoFactory object.
// When a MediaCrypto or MediaDrm object needs to be constructed, all
// available DrmEngines present in the plugins directory on the device
// are scanned for a matching DrmEngine that can support the crypto
// scheme. When a match is found, the DrmEngine's createCryptoPlugin and
// createDrmPlugin methods are used to create CryptoPlugin or
// DrmPlugin instances to support that DRM scheme.
class DrmFactory {
public:
DrmFactory() {}
virtual ~DrmFactory() {}
// DrmFactory::isCryptoSchemeSupported can be called to determine
// if the plugin factory is able to construct plugins that support a
// given crypto scheme, which is specified by a UUID.
virtual bool isCryptoSchemeSupported(const uint8_t uuid[16]) = 0;
// DrmFactory::isContentTypeSupported can be called to determine
// if the plugin factory is able to construct plugins that support a
// given media container format specified by mimeType
virtual bool isContentTypeSupported(const String8 &mimeType) = 0;
// Construct a DrmPlugin for the crypto scheme specified by UUID.
virtual status_t createDrmPlugin(
const uint8_t uuid[16], DrmPlugin **plugin) = 0;
private:
DrmFactory(const DrmFactory &);
DrmFactory &operator=(const DrmFactory &);
};
class DrmPlugin {
public:
enum EventType {
kDrmPluginEventProvisionRequired = 1,
kDrmPluginEventKeyNeeded,
kDrmPluginEventKeyExpired,
kDrmPluginEventVendorDefined
};
// Drm keys can be for offline content or for online streaming.
// Offline keys are persisted on the device and may be used when the device
// is disconnected from the network. The Release type is used to request
// that offline keys be no longer restricted to offline use.
enum KeyType {
kKeyType_Offline,
kKeyType_Streaming,
kKeyType_Release
};
DrmPlugin() {}
virtual ~DrmPlugin() {}
// Open a new session with the DrmPlugin object. A session ID is returned
// in the sessionId parameter.
virtual status_t openSession(Vector<uint8_t> &sessionId) = 0;
// Close a session on the DrmPlugin object.
virtual status_t closeSession(Vector<uint8_t> const &sessionId) = 0;
// A key request/response exchange occurs between the app and a License
// Server to obtain the keys required to decrypt the content. getKeyRequest()
// is used to obtain an opaque key request blob that is delivered to the
// license server.
//
// The scope parameter may be a sessionId or a keySetId, depending on the
// specified keyType. When the keyType is kKeyType_Offline or
// kKeyType_Streaming, scope should be set to the sessionId the keys will be
// provided to. When the keyType is kKeyType_Release, scope should be set to
// the keySetId of the keys being released. Releasing keys from a device
// invalidates them for all sessions.
//
// The init data passed to getKeyRequest is container-specific and its
// meaning is interpreted based on the mime type provided in the mimeType
// parameter to getKeyRequest. It could contain, for example, the content
// ID, key ID or other data obtained from the content metadata that is required
// in generating the key request. Init may be null when keyType is
// kKeyType_Release.
//
// mimeType identifies the mime type of the content
//
// keyType specifies if the keys are to be used for streaming or offline content
//
// optionalParameters are included in the key request message to allow a
// client application to provide additional message parameters to the server.
//
// If successful, the opaque key request blob is returned to the caller.
virtual status_t
getKeyRequest(Vector<uint8_t> const &scope,
Vector<uint8_t> const &initData,
String8 const &mimeType, KeyType keyType,
KeyedVector<String8, String8> const &optionalParameters,
Vector<uint8_t> &request, String8 &defaultUrl) = 0;
//
// After a key response is received by the app, it is provided to the
// Drm plugin using provideKeyResponse.
//
// scope may be a sessionId or a keySetId depending on the type of the
// response. Scope should be set to the sessionId when the response is
// for either streaming or offline key requests. Scope should be set to the
// keySetId when the response is for a release request.
//
// When the response is for an offline key request, a keySetId is returned
// in the keySetId vector parameter that can be used to later restore the
// keys to a new session with the method restoreKeys. When the response is
// for a streaming or release request, no keySetId is returned.
//
virtual status_t provideKeyResponse(Vector<uint8_t> const &scope,
Vector<uint8_t> const &response,
Vector<uint8_t> &keySetId) = 0;
// Remove the current keys from a session
virtual status_t removeKeys(Vector<uint8_t> const &sessionId) = 0;
// Restore persisted offline keys into a new session. keySetId identifies
// the keys to load, obtained from a prior call to provideKeyResponse().
virtual status_t restoreKeys(Vector<uint8_t> const &sessionId,
Vector<uint8_t> const &keySetId) = 0;
// Request an informative description of the license for the session. The status
// is in the form of {name, value} pairs. Since DRM license policies vary by
// vendor, the specific status field names are determined by each DRM vendor.
// Refer to your DRM provider documentation for definitions of the field names
// for a particular DrmEngine.
virtual status_t
queryKeyStatus(Vector<uint8_t> const &sessionId,
KeyedVector<String8, String8> &infoMap) const = 0;
// A provision request/response exchange occurs between the app and a
// provisioning server to retrieve a device certificate. getProvisionRequest
// is used to obtain an opaque key request blob that is delivered to the
// provisioning server.
//
// If successful, the opaque provision request blob is returned to the caller.
virtual status_t getProvisionRequest(Vector<uint8_t> &request,
String8 &defaultUrl) = 0;
// After a provision response is received by the app, it is provided to the
// Drm plugin using provideProvisionResponse.
virtual status_t provideProvisionResponse(Vector<uint8_t> const &response) = 0;
// A means of enforcing the contractual requirement for a concurrent stream
// limit per subscriber across devices is provided via SecureStop. SecureStop
// is a means of securely monitoring the lifetime of sessions. Since playback
// on a device can be interrupted due to reboot, power failure, etc. a means
// of persisting the lifetime information on the device is needed.
//
// A signed version of the sessionID is written to persistent storage on the
// device when each MediaCrypto object is created. The sessionID is signed by
// the device private key to prevent tampering.
//
// In the normal case, playback will be completed, the session destroyed and
// the Secure Stops will be queried. The App queries secure stops and forwards
// the secure stop message to the server which verifies the signature and
// notifies the server side database that the session destruction has been
// confirmed. The persisted record on the client is only removed after positive
// confirmation that the server received the message using releaseSecureStops().
virtual status_t getSecureStops(List<Vector<uint8_t> > &secureStops) = 0;
virtual status_t releaseSecureStops(Vector<uint8_t> const &ssRelease) = 0;
// Read a property value given the device property string. There are a few forms
// of property access methods, depending on the data type returned.
// Since DRM plugin properties may vary, additional field names may be defined
// by each DRM vendor. Refer to your DRM provider documentation for definitions
// of its additional field names.
//
// Standard values are:
// "vendor" [string] identifies the maker of the plugin
// "version" [string] identifies the version of the plugin
// "description" [string] describes the plugin
// 'deviceUniqueId' [byte array] The device unique identifier is established
// during device provisioning and provides a means of uniquely identifying
// each device.
virtual status_t getPropertyString(String8 const &name, String8 &value ) const = 0;
virtual status_t getPropertyByteArray(String8 const &name,
Vector<uint8_t> &value ) const = 0;
// Write a property value given the device property string. There are a few forms
// of property setting methods, depending on the data type.
// Since DRM plugin properties may vary, additional field names may be defined
// by each DRM vendor. Refer to your DRM provider documentation for definitions
// of its field names.
virtual status_t setPropertyString(String8 const &name,
String8 const &value ) = 0;
virtual status_t setPropertyByteArray(String8 const &name,
Vector<uint8_t> const &value ) = 0;
// The following methods implement operations on a CryptoSession to support
// encrypt, decrypt, sign verify operations on operator-provided
// session keys.
//
// The algorithm string conforms to JCA Standard Names for Cipher
// Transforms and is case insensitive. For example "AES/CBC/PKCS5Padding".
//
// Return OK if the algorithm is supported, otherwise return BAD_VALUE
//
virtual status_t setCipherAlgorithm(Vector<uint8_t> const &sessionId,
String8 const &algorithm) = 0;
//
// The algorithm string conforms to JCA Standard Names for Mac
// Algorithms and is case insensitive. For example "HmacSHA256".
//
// Return OK if the algorithm is supported, otherwise return BAD_VALUE
//
virtual status_t setMacAlgorithm(Vector<uint8_t> const &sessionId,
String8 const &algorithm) = 0;
// Encrypt the provided input buffer with the cipher algorithm
// specified by setCipherAlgorithm and the key selected by keyId,
// and return the encrypted data.
virtual status_t encrypt(Vector<uint8_t> const &sessionId,
Vector<uint8_t> const &keyId,
Vector<uint8_t> const &input,
Vector<uint8_t> const &iv,
Vector<uint8_t> &output) = 0;
// Decrypt the provided input buffer with the cipher algorithm
// specified by setCipherAlgorithm and the key selected by keyId,
// and return the decrypted data.
virtual status_t decrypt(Vector<uint8_t> const &sessionId,
Vector<uint8_t> const &keyId,
Vector<uint8_t> const &input,
Vector<uint8_t> const &iv,
Vector<uint8_t> &output) = 0;
// Compute a signature on the provided message using the mac algorithm
// specified by setMacAlgorithm and the key selected by keyId,
// and return the signature.
virtual status_t sign(Vector<uint8_t> const &sessionId,
Vector<uint8_t> const &keyId,
Vector<uint8_t> const &message,
Vector<uint8_t> &signature) = 0;
// Compute a signature on the provided message using the mac algorithm
// specified by setMacAlgorithm and the key selected by keyId,
// and compare with the expected result. Set result to true or
// false depending on the outcome.
virtual status_t verify(Vector<uint8_t> const &sessionId,
Vector<uint8_t> const &keyId,
Vector<uint8_t> const &message,
Vector<uint8_t> const &signature,
bool &match) = 0;
status_t setListener(const sp<DrmPluginListener>& listener) {
Mutex::Autolock lock(mEventLock);
mListener = listener;
return OK;
}
protected:
// Plugins call sendEvent to deliver events to the java app
void sendEvent(EventType eventType, int extra,
Vector<uint8_t> const *sessionId,
Vector<uint8_t> const *data);
private:
Mutex mEventLock;
sp<DrmPluginListener> mListener;
DISALLOW_EVIL_CONSTRUCTORS(DrmPlugin);
};
class DrmPluginListener: virtual public RefBase
{
public:
virtual void sendEvent(DrmPlugin::EventType eventType, int extra,
Vector<uint8_t> const *sesionId,
Vector<uint8_t> const *data) = 0;
};
inline void DrmPlugin::sendEvent(EventType eventType, int extra,
Vector<uint8_t> const *sessionId,
Vector<uint8_t> const *data) {
mEventLock.lock();
sp<DrmPluginListener> listener = mListener;
mEventLock.unlock();
if (listener != NULL) {
listener->sendEvent(eventType, extra, sessionId, data);
}
}
} // namespace android
#endif // DRM_API_H_
| [
"[email protected]"
] | |
9d59c25aa23e992b3049d463b735e95ea51ae90c | df56c3d9f44132d636c0cef1b70e40034ff09022 | /networkingtestandutils/networkingperformancemeasurementtools/netperftefplugin/inc/iperfprotocol.h | e2e8a638c17445d1a579ae24b5265bf329607a22 | [] | no_license | SymbianSource/oss.FCL.sf.os.networkingsrv | e6317d7ee0ebae163572127269c6cf40b98e3e1c | b283ce17f27f4a95f37cdb38c6ce79d38ae6ebf9 | refs/heads/master | 2021-01-12T11:29:50.765762 | 2010-10-14T06:50:50 | 2010-10-14T06:50:50 | 72,938,071 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,141 | h | // iperfprotocol.h
//
// Portions Copyright (c) 1997-2009 Nokia Corporation and/or its subsidiary(-ies).
//
/*
* Copyright (c) 1999-2007, The Board of Trustees of the University of Illinois
* All Rights Reserved.
*
* Iperf performance test
* Mark Gates
* Ajay Tirumala
* Jim Ferguson
* Jon Dugan
* Feng Qin
* Kevin Gibbs
* John Estabrook
* National Laboratory for Applied Network Research
* National Center for Supercomputing Applications
* University of Illinois at Urbana-Champaign
* http://www.ncsa.uiuc.edu
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software (Iperf) and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation the
* rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
* sell copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* - Redistributions of source code must retain the above copyright notice, this
* list of conditions and the following disclaimers.
*
* - Redistributions in binary form must reproduce the above copyright notice,
* this list of conditions and the following disclaimers in the documentation
* and/or other materials provided with the distribution.
*
* - Neither the names of the University of Illinois, NCSA, nor the names of its
* contributors may be used to endorse or promote products derived from this
* Software without specific prior written permission.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* CONTIBUTORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
* SOFTWARE.
*
*/
/**
* @file
*
* IPerf protocol. Talks the same language as remote PC-based iperf to compare
* sequence numbers, delays, metrics etc.
*
* @internalTechnology
*/
#ifndef __IPERF_PROTOCOL_H
#define __IPERF_PROTOCOL_H
#include "iperfudpheader.h"
#include "iperfclientheader.h"
#include "iperfserverheader.h"
enum TSessionType
{
ENone = 0, // session has not been initialised yet
EClient, // synonymous with upload test - also consistent with iperf nomenclature
EServer, // synonymous with download test - also consistent with iperf nomenclature
};
enum EDisassembleResult
{
// ETypeAccepted...
EValidInSeq = 0, // valid, in sequence (if layer does not support sequencing, then it is assumed to be in sequence anyhow)
EValidOutOfSeq, // valid, but out of sequence (layer must support sequence numbering)
// ETypeIgnored...
EValidNotAddressee, // valid, but not addressed to us
EValidDuplicate, // valid, but duplicate (layer must support sequence numbering)
EInvalid, // invalid, badly formatted protocol
EUnsupported, // validity indeterminate, valid enough to detect unsupported feature(s) but unable to validate after that
// ETypeLost...
ELost, // validity n/a, a message (of indeterminate length) has been lost (layer must support sequence numbering)
ENumDisassembleResults, // number of disassembly results
};
class CIperfProtocol
{
public:
static TInt AssembleIperfHeader(TDes8& aPacket, TInt aClientListeningPort, TInt aThroughputInKbps);
static TInt UpdateIperfHeader(TDes8& aPacket,TIperfUdpHeader::TMsg aMsg, TInt aSeqNum);
static TInt DisassembleIperf(TDes8 &aPacket, TSessionType aType,
TIperfUdpHeader::TMsg &aMsg, TInt& aSeqNum);
static EDisassembleResult DisassembleIperf(TIperfClientHeader &aClient, TInt aLength);
static EDisassembleResult DisassembleIperf(TIperfServerHeader &aClient);
};
#endif //ifndef __IPERF_PROTOCOL_H
| [
"[email protected]"
] | |
80caeeeacd95ead107e9366e9678645e29efb265 | fc353ca6be2bc55cb69f6ce3e21800a1ede28270 | /common/bpcodec/apps/bpreceivefile/src/BpReceiveFileRunner.cpp | 9fa72cc8b6e53711bec649a9318daba129ca6c00 | [] | no_license | aggelis/HDTN | b4b43781a2e6490b9f7066377553e53f37fff742 | 85c1a060fb1f65fed0755fee8f0a45233c1d78d8 | refs/heads/master | 2023-09-05T09:36:47.019948 | 2021-09-29T15:00:47 | 2021-09-29T15:00:47 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,523 | cpp | #include <iostream>
#include "BpReceiveFile.h"
#include "BpReceiveFileRunner.h"
#include "SignalHandler.h"
#include <boost/filesystem.hpp>
#include <boost/program_options.hpp>
#include <boost/lexical_cast.hpp>
#include "Uri.h"
void BpReceiveFileRunner::MonitorExitKeypressThreadFunction() {
std::cout << "Keyboard Interrupt.. exiting\n";
m_runningFromSigHandler = false; //do this first
}
BpReceiveFileRunner::BpReceiveFileRunner() {}
BpReceiveFileRunner::~BpReceiveFileRunner() {}
bool BpReceiveFileRunner::Run(int argc, const char* const argv[], volatile bool & running, bool useSignalHandler) {
//scope to ensure clean exit before return 0
{
running = true;
m_runningFromSigHandler = true;
SignalHandler sigHandler(boost::bind(&BpReceiveFileRunner::MonitorExitKeypressThreadFunction, this));
InductsConfig_ptr inductsConfigPtr;
OutductsConfig_ptr outductsConfigPtr;
cbhe_eid_t myEid;
bool isAcsAware;
std::string saveDirectory;
boost::program_options::options_description desc("Allowed options");
try {
desc.add_options()
("help", "Produce help message.")
("save-directory", boost::program_options::value<std::string>()->default_value(""), "Directory to save file(s) to. Empty=>DoNotSaveToDisk")
("inducts-config-file", boost::program_options::value<std::string>()->default_value("inducts.json"), "Inducts Configuration File.")
("my-uri-eid", boost::program_options::value<std::string>()->default_value("ipn:2.1"), "BpReceiveFile Eid.")
("custody-transfer-outducts-config-file", boost::program_options::value<std::string>()->default_value(""), "Outducts Configuration File for custody transfer (use custody if present).")
("acs-aware-bundle-agent", "Custody transfer should support Aggregate Custody Signals if valid CTEB present.")
;
boost::program_options::variables_map vm;
boost::program_options::store(boost::program_options::parse_command_line(argc, argv, desc, boost::program_options::command_line_style::unix_style | boost::program_options::command_line_style::case_insensitive), vm);
boost::program_options::notify(vm);
if (vm.count("help")) {
std::cout << desc << "\n";
return false;
}
const std::string myUriEid = vm["my-uri-eid"].as<std::string>();
if (!Uri::ParseIpnUriString(myUriEid, myEid.nodeId, myEid.serviceId)) {
std::cerr << "error: bad BpReceiveFile uri string: " << myUriEid << std::endl;
return false;
}
const std::string configFileNameInducts = vm["inducts-config-file"].as<std::string>();
inductsConfigPtr = InductsConfig::CreateFromJsonFile(configFileNameInducts);
if (!inductsConfigPtr) {
std::cerr << "error loading config file: " << configFileNameInducts << std::endl;
return false;
}
std::size_t numInducts = inductsConfigPtr->m_inductElementConfigVector.size();
if (numInducts != 1) {
std::cerr << "error: number of BpReceiveFile inducts is not 1: got " << numInducts << std::endl;
}
//create outduct for custody signals
const std::string outductsConfigFileName = vm["custody-transfer-outducts-config-file"].as<std::string>();
if (outductsConfigFileName.length()) {
outductsConfigPtr = OutductsConfig::CreateFromJsonFile(outductsConfigFileName);
if (!outductsConfigPtr) {
std::cerr << "error loading config file: " << outductsConfigFileName << std::endl;
return false;
}
std::size_t numOutducts = outductsConfigPtr->m_outductElementConfigVector.size();
if (numOutducts != 1) {
std::cerr << "error: number of BpReceiveFile outducts is not 1: got " << numOutducts << std::endl;
}
}
isAcsAware = (vm.count("acs-aware-bundle-agent"));
saveDirectory = vm["save-directory"].as<std::string>();
}
catch (boost::bad_any_cast & e) {
std::cout << "invalid data error: " << e.what() << "\n\n";
std::cout << desc << "\n";
return false;
}
catch (std::exception& e) {
std::cerr << "error: " << e.what() << "\n";
return false;
}
catch (...) {
std::cerr << "Exception of unknown type!\n";
return false;
}
std::cout << "starting BpReceiveFile.." << std::endl;
BpReceiveFile bpReceiveFile(saveDirectory);
bpReceiveFile.Init(*inductsConfigPtr, outductsConfigPtr, isAcsAware, myEid, 0);
if (useSignalHandler) {
sigHandler.Start(false);
}
std::cout << "BpReceiveFileRunner up and running" << std::endl;
while (running && m_runningFromSigHandler) {
boost::this_thread::sleep(boost::posix_time::millisec(250));
if (useSignalHandler) {
sigHandler.PollOnce();
}
}
std::cout << "BpReceiveFileRunner: exiting cleanly..\n";
bpReceiveFile.Stop();
//safe to get any stats now if needed
}
std::cout << "BpReceiveFileRunner: exited cleanly\n";
return true;
}
| [
"btomko@GRLWL2020050782"
] | btomko@GRLWL2020050782 |
6f438bd196241deb31be6dac7211fb85d691cb19 | 5d83739af703fb400857cecc69aadaf02e07f8d1 | /Archive2/cf/669419cc1b6d3b/main.cpp | 6ce2b188b75ca6b003edc953706cddc352ef8f25 | [] | no_license | WhiZTiM/coliru | 3a6c4c0bdac566d1aa1c21818118ba70479b0f40 | 2c72c048846c082f943e6c7f9fa8d94aee76979f | refs/heads/master | 2021-01-01T05:10:33.812560 | 2015-08-24T19:09:22 | 2015-08-24T19:09:22 | 56,789,706 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,144 | cpp | #include <fstream>
#include <vector>
#include <iostream>
struct Product
{
char name[200]; int code; double price;
};
void fileWriteBin( const char* file_name, const std::vector<Product>& prod )
{
std::ofstream file( file_name, std::ios::binary ) ;
for( const Product& p : prod ) file.write( p.name, sizeof(p) ) ;
}
std::vector<Product> readDataBinary( const char* file_name )
{
std::vector<Product> prod ;
std::ifstream file( file_name, std::ios::binary ) ;
Product temp ;
while( file.read( temp.name, sizeof(temp) ) ) prod.push_back(temp) ;
return prod ;
}
int main()
{
const char* const file_name = "products.bin" ;
{
std::vector<Product> prod
{
Product{ "Honey", 1, 12.34 },
Product{ "Coffee", 2, 56.78 },
Product{ "Claret", 3, 90.12 }
};
fileWriteBin( file_name, prod ) ;
}
{
std::vector<Product> prod = readDataBinary(file_name) ;
for( const Product& p : prod )
std::cout << p.name << ' ' << p.code << ' ' << p.price << '\n' ;
}
}
| [
"francis.rammeloo@36614edc-3e3a-acb8-9062-c8ae0e4185df"
] | francis.rammeloo@36614edc-3e3a-acb8-9062-c8ae0e4185df |
ccfa084a172a89a4e578a79dc6f65c23aef8a038 | d9e15021d7057d45e5f27ca266d987200ce17ace | /work/sc_rank_list.cpp | 4390f6911c5671af07d80ce9be65c9dbbf8ac155 | [] | no_license | coeux/nodding | e27805b60972b0d840da6f75db14df3c1e191fd3 | 26a134a15f9a3fde535df6ec4b41a7585c3fc2c1 | refs/heads/master | 2021-01-13T17:31:49.369201 | 2017-04-10T08:25:03 | 2017-04-10T08:25:03 | 81,806,885 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,026 | cpp | #include "sc_rank_list.h"
sc_rank_list::sc_rank_list(int32_t max_size_):
max_size(max_size_),
cur_size(0)
{
list.clear();
}
bool
sc_rank_list::insert(int32_t id_, int32_t value_)
{
if (cur_size == 0)
{
data_pair pair;
pair.id = id_;
pair.value = value_;
list.push_back(std::move(pair));
cur_size++;
max_value = value_;
min_value = value_;
return true;
}
if (value_ <= min_value)
{
if (cur_size >= max_size)
{
return false;
}
else
{
data_pair pair;
pair.id = id_;
pair.value = value_;
list.push_back(std::move(pair));
cur_size++;
min_value = value_;
return true; l
}
}
if (value_ >= max_value)
{
data_pair pair;
pair.id = -1;
pair.value = -1;
list.push_back(std::move(pair));
for(auto j=cur_size;j>0; --j)
{
list[j].value = list[j-1].value;
list[j].id = list[j-1].id;
}
list[0].id = id_;
list[0].value = value_;
max_value = value_;
cur_size++;
if (cur_size > max_size)
{
list.pop_back();
cur_size--;
}
return true; l
}
for(auto i=0; i<cur_size; ++i)
{
data_pair pair;
pair.id = -1;
pair.value = -1;
list.push_back(std::move(pair));
if(value_ > list[i].value)
{
for(auto j=cur_size; j>i; --j)
{
list[j].value = list[j-1].value;
list[j].id = list[j-1].id;
}
list[i].id = id_;
list[i].value = value_;
break;
}
}
if(cur_size > max_size)
{
list.pop_back();
cur_size--;
}
return true;
}
int32_t
sc_rank_list::find(int32_t id_)
{
bool rank = -1;
for(auto i=0; i<cur_size; ++i)
{
if (list[i].id == id_)
{
rank = i+1;
break;
}
}
return rank;
}
const vector<int32_t>&
sc_rank_list::getList()
{
vector<int32_t> print_list;
for(auto i=0; i<cur_size; ++i)
{
print_list.push_back(list[i].id);
}
return print_list;
}
const vector<int32_t>&
sc_rank_list::getList(int count_)
{
int32_t size = count_< cur_size ? count_ : cur_size;
vector<int32_t> print_list;
for(auto i=0; i<size; ++i)
{
print_list.push_back(list[i].id);
}
return print_list;
}
| [
"[email protected]"
] | |
a7e452a19380c9de1189d19b96a822a59279a327 | 3f87e4a7bbda4313850256fd978065007ad7ce9c | /src/script.cpp | 75e0cb5f44425531dec3b691c47fd80704a52701 | [
"MIT"
] | permissive | coinsite/PikachuCoin | a89120cdc3ee7b42fc35c0ef8f5e5d5b7946f4fa | db543cc2e3f40b09d574f989fa4b988dd93e30d4 | refs/heads/master | 2021-01-02T23:13:12.828710 | 2014-02-20T13:20:38 | 2014-02-20T13:20:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 63,096 | cpp | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin developers
// Copyright (c) 2011-2012 Litecoin Developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <boost/foreach.hpp>
#include <boost/tuple/tuple.hpp>
using namespace std;
using namespace boost;
#include "script.h"
#include "keystore.h"
#include "bignum.h"
#include "key.h"
#include "main.h"
#include "sync.h"
#include "util.h"
bool CheckSig(vector<unsigned char> vchSig, vector<unsigned char> vchPubKey, CScript scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType);
typedef vector<unsigned char> valtype;
static const valtype vchFalse(0);
static const valtype vchZero(0);
static const valtype vchTrue(1, 1);
static const CBigNum bnZero(0);
static const CBigNum bnOne(1);
static const CBigNum bnFalse(0);
static const CBigNum bnTrue(1);
static const size_t nMaxNumSize = 4;
CBigNum CastToBigNum(const valtype& vch)
{
if (vch.size() > nMaxNumSize)
throw runtime_error("CastToBigNum() : overflow");
// Get rid of extra leading zeros
return CBigNum(CBigNum(vch).getvch());
}
bool CastToBool(const valtype& vch)
{
for (unsigned int i = 0; i < vch.size(); i++)
{
if (vch[i] != 0)
{
// Can be negative zero
if (i == vch.size()-1 && vch[i] == 0x80)
return false;
return true;
}
}
return false;
}
void MakeSameSize(valtype& vch1, valtype& vch2)
{
// Lengthen the shorter one
if (vch1.size() < vch2.size())
vch1.resize(vch2.size(), 0);
if (vch2.size() < vch1.size())
vch2.resize(vch1.size(), 0);
}
//
// Script is a stack machine (like Forth) that evaluates a predicate
// returning a bool indicating valid or not. There are no loops.
//
#define stacktop(i) (stack.at(stack.size()+(i)))
#define altstacktop(i) (altstack.at(altstack.size()+(i)))
static inline void popstack(vector<valtype>& stack)
{
if (stack.empty())
throw runtime_error("popstack() : stack empty");
stack.pop_back();
}
const char* GetTxnOutputType(txnouttype t)
{
switch (t)
{
case TX_NONSTANDARD: return "nonstandard";
case TX_PUBKEY: return "pubkey";
case TX_PUBKEYHASH: return "pubkeyhash";
case TX_SCRIPTHASH: return "scripthash";
case TX_MULTISIG: return "multisig";
}
return NULL;
}
const char* GetOpName(opcodetype opcode)
{
switch (opcode)
{
// push value
case OP_0 : return "0";
case OP_PUSHDATA1 : return "OP_PUSHDATA1";
case OP_PUSHDATA2 : return "OP_PUSHDATA2";
case OP_PUSHDATA4 : return "OP_PUSHDATA4";
case OP_1NEGATE : return "-1";
case OP_RESERVED : return "OP_RESERVED";
case OP_1 : return "1";
case OP_2 : return "2";
case OP_3 : return "3";
case OP_4 : return "4";
case OP_5 : return "5";
case OP_6 : return "6";
case OP_7 : return "7";
case OP_8 : return "8";
case OP_9 : return "9";
case OP_10 : return "10";
case OP_11 : return "11";
case OP_12 : return "12";
case OP_13 : return "13";
case OP_14 : return "14";
case OP_15 : return "15";
case OP_16 : return "16";
// control
case OP_NOP : return "OP_NOP";
case OP_VER : return "OP_VER";
case OP_IF : return "OP_IF";
case OP_NOTIF : return "OP_NOTIF";
case OP_VERIF : return "OP_VERIF";
case OP_VERNOTIF : return "OP_VERNOTIF";
case OP_ELSE : return "OP_ELSE";
case OP_ENDIF : return "OP_ENDIF";
case OP_VERIFY : return "OP_VERIFY";
case OP_RETURN : return "OP_RETURN";
// stack ops
case OP_TOALTSTACK : return "OP_TOALTSTACK";
case OP_FROMALTSTACK : return "OP_FROMALTSTACK";
case OP_2DROP : return "OP_2DROP";
case OP_2DUP : return "OP_2DUP";
case OP_3DUP : return "OP_3DUP";
case OP_2OVER : return "OP_2OVER";
case OP_2ROT : return "OP_2ROT";
case OP_2SWAP : return "OP_2SWAP";
case OP_IFDUP : return "OP_IFDUP";
case OP_DEPTH : return "OP_DEPTH";
case OP_DROP : return "OP_DROP";
case OP_DUP : return "OP_DUP";
case OP_NIP : return "OP_NIP";
case OP_OVER : return "OP_OVER";
case OP_PICK : return "OP_PICK";
case OP_ROLL : return "OP_ROLL";
case OP_ROT : return "OP_ROT";
case OP_SWAP : return "OP_SWAP";
case OP_TUCK : return "OP_TUCK";
// splice ops
case OP_CAT : return "OP_CAT";
case OP_SUBSTR : return "OP_SUBSTR";
case OP_LEFT : return "OP_LEFT";
case OP_RIGHT : return "OP_RIGHT";
case OP_SIZE : return "OP_SIZE";
// bit logic
case OP_INVERT : return "OP_INVERT";
case OP_AND : return "OP_AND";
case OP_OR : return "OP_OR";
case OP_XOR : return "OP_XOR";
case OP_EQUAL : return "OP_EQUAL";
case OP_EQUALVERIFY : return "OP_EQUALVERIFY";
case OP_RESERVED1 : return "OP_RESERVED1";
case OP_RESERVED2 : return "OP_RESERVED2";
// numeric
case OP_1ADD : return "OP_1ADD";
case OP_1SUB : return "OP_1SUB";
case OP_2MUL : return "OP_2MUL";
case OP_2DIV : return "OP_2DIV";
case OP_NEGATE : return "OP_NEGATE";
case OP_ABS : return "OP_ABS";
case OP_NOT : return "OP_NOT";
case OP_0NOTEQUAL : return "OP_0NOTEQUAL";
case OP_ADD : return "OP_ADD";
case OP_SUB : return "OP_SUB";
case OP_MUL : return "OP_MUL";
case OP_DIV : return "OP_DIV";
case OP_MOD : return "OP_MOD";
case OP_LSHIFT : return "OP_LSHIFT";
case OP_RSHIFT : return "OP_RSHIFT";
case OP_BOOLAND : return "OP_BOOLAND";
case OP_BOOLOR : return "OP_BOOLOR";
case OP_NUMEQUAL : return "OP_NUMEQUAL";
case OP_NUMEQUALVERIFY : return "OP_NUMEQUALVERIFY";
case OP_NUMNOTEQUAL : return "OP_NUMNOTEQUAL";
case OP_LESSTHAN : return "OP_LESSTHAN";
case OP_GREATERTHAN : return "OP_GREATERTHAN";
case OP_LESSTHANOREQUAL : return "OP_LESSTHANOREQUAL";
case OP_GREATERTHANOREQUAL : return "OP_GREATERTHANOREQUAL";
case OP_MIN : return "OP_MIN";
case OP_MAX : return "OP_MAX";
case OP_WITHIN : return "OP_WITHIN";
// crypto
case OP_RIPEMD160 : return "OP_RIPEMD160";
case OP_SHA1 : return "OP_SHA1";
case OP_SHA256 : return "OP_SHA256";
case OP_HASH160 : return "OP_HASH160";
case OP_HASH256 : return "OP_HASH256";
case OP_CODESEPARATOR : return "OP_CODESEPARATOR";
case OP_CHECKSIG : return "OP_CHECKSIG";
case OP_CHECKSIGVERIFY : return "OP_CHECKSIGVERIFY";
case OP_CHECKMULTISIG : return "OP_CHECKMULTISIG";
case OP_CHECKMULTISIGVERIFY : return "OP_CHECKMULTISIGVERIFY";
// expanson
case OP_NOP1 : return "OP_NOP1";
case OP_NOP2 : return "OP_NOP2";
case OP_NOP3 : return "OP_NOP3";
case OP_NOP4 : return "OP_NOP4";
case OP_NOP5 : return "OP_NOP5";
case OP_NOP6 : return "OP_NOP6";
case OP_NOP7 : return "OP_NOP7";
case OP_NOP8 : return "OP_NOP8";
case OP_NOP9 : return "OP_NOP9";
case OP_NOP10 : return "OP_NOP10";
// template matching params
case OP_PUBKEYHASH : return "OP_PUBKEYHASH";
case OP_PUBKEY : return "OP_PUBKEY";
case OP_INVALIDOPCODE : return "OP_INVALIDOPCODE";
default:
return "OP_UNKNOWN";
}
}
bool EvalScript(vector<vector<unsigned char> >& stack, const CScript& script, const CTransaction& txTo, unsigned int nIn, int nHashType)
{
CAutoBN_CTX pctx;
CScript::const_iterator pc = script.begin();
CScript::const_iterator pend = script.end();
CScript::const_iterator pbegincodehash = script.begin();
opcodetype opcode;
valtype vchPushValue;
vector<bool> vfExec;
vector<valtype> altstack;
if (script.size() > 10000)
return false;
int nOpCount = 0;
try
{
while (pc < pend)
{
bool fExec = !count(vfExec.begin(), vfExec.end(), false);
//
// Read instruction
//
if (!script.GetOp(pc, opcode, vchPushValue))
return false;
if (vchPushValue.size() > 520)
return false;
if (opcode > OP_16 && ++nOpCount > 201)
return false;
if (opcode == OP_CAT ||
opcode == OP_SUBSTR ||
opcode == OP_LEFT ||
opcode == OP_RIGHT ||
opcode == OP_INVERT ||
opcode == OP_AND ||
opcode == OP_OR ||
opcode == OP_XOR ||
opcode == OP_2MUL ||
opcode == OP_2DIV ||
opcode == OP_MUL ||
opcode == OP_DIV ||
opcode == OP_MOD ||
opcode == OP_LSHIFT ||
opcode == OP_RSHIFT)
return false;
if (fExec && 0 <= opcode && opcode <= OP_PUSHDATA4)
stack.push_back(vchPushValue);
else if (fExec || (OP_IF <= opcode && opcode <= OP_ENDIF))
switch (opcode)
{
//
// Push value
//
case OP_1NEGATE:
case OP_1:
case OP_2:
case OP_3:
case OP_4:
case OP_5:
case OP_6:
case OP_7:
case OP_8:
case OP_9:
case OP_10:
case OP_11:
case OP_12:
case OP_13:
case OP_14:
case OP_15:
case OP_16:
{
// ( -- value)
CBigNum bn((int)opcode - (int)(OP_1 - 1));
stack.push_back(bn.getvch());
}
break;
//
// Control
//
case OP_NOP:
case OP_NOP1: case OP_NOP2: case OP_NOP3: case OP_NOP4: case OP_NOP5:
case OP_NOP6: case OP_NOP7: case OP_NOP8: case OP_NOP9: case OP_NOP10:
break;
case OP_IF:
case OP_NOTIF:
{
// <expression> if [statements] [else [statements]] endif
bool fValue = false;
if (fExec)
{
if (stack.size() < 1)
return false;
valtype& vch = stacktop(-1);
fValue = CastToBool(vch);
if (opcode == OP_NOTIF)
fValue = !fValue;
popstack(stack);
}
vfExec.push_back(fValue);
}
break;
case OP_ELSE:
{
if (vfExec.empty())
return false;
vfExec.back() = !vfExec.back();
}
break;
case OP_ENDIF:
{
if (vfExec.empty())
return false;
vfExec.pop_back();
}
break;
case OP_VERIFY:
{
// (true -- ) or
// (false -- false) and return
if (stack.size() < 1)
return false;
bool fValue = CastToBool(stacktop(-1));
if (fValue)
popstack(stack);
else
return false;
}
break;
case OP_RETURN:
{
return false;
}
break;
//
// Stack ops
//
case OP_TOALTSTACK:
{
if (stack.size() < 1)
return false;
altstack.push_back(stacktop(-1));
popstack(stack);
}
break;
case OP_FROMALTSTACK:
{
if (altstack.size() < 1)
return false;
stack.push_back(altstacktop(-1));
popstack(altstack);
}
break;
case OP_2DROP:
{
// (x1 x2 -- )
if (stack.size() < 2)
return false;
popstack(stack);
popstack(stack);
}
break;
case OP_2DUP:
{
// (x1 x2 -- x1 x2 x1 x2)
if (stack.size() < 2)
return false;
valtype vch1 = stacktop(-2);
valtype vch2 = stacktop(-1);
stack.push_back(vch1);
stack.push_back(vch2);
}
break;
case OP_3DUP:
{
// (x1 x2 x3 -- x1 x2 x3 x1 x2 x3)
if (stack.size() < 3)
return false;
valtype vch1 = stacktop(-3);
valtype vch2 = stacktop(-2);
valtype vch3 = stacktop(-1);
stack.push_back(vch1);
stack.push_back(vch2);
stack.push_back(vch3);
}
break;
case OP_2OVER:
{
// (x1 x2 x3 x4 -- x1 x2 x3 x4 x1 x2)
if (stack.size() < 4)
return false;
valtype vch1 = stacktop(-4);
valtype vch2 = stacktop(-3);
stack.push_back(vch1);
stack.push_back(vch2);
}
break;
case OP_2ROT:
{
// (x1 x2 x3 x4 x5 x6 -- x3 x4 x5 x6 x1 x2)
if (stack.size() < 6)
return false;
valtype vch1 = stacktop(-6);
valtype vch2 = stacktop(-5);
stack.erase(stack.end()-6, stack.end()-4);
stack.push_back(vch1);
stack.push_back(vch2);
}
break;
case OP_2SWAP:
{
// (x1 x2 x3 x4 -- x3 x4 x1 x2)
if (stack.size() < 4)
return false;
swap(stacktop(-4), stacktop(-2));
swap(stacktop(-3), stacktop(-1));
}
break;
case OP_IFDUP:
{
// (x - 0 | x x)
if (stack.size() < 1)
return false;
valtype vch = stacktop(-1);
if (CastToBool(vch))
stack.push_back(vch);
}
break;
case OP_DEPTH:
{
// -- stacksize
CBigNum bn(stack.size());
stack.push_back(bn.getvch());
}
break;
case OP_DROP:
{
// (x -- )
if (stack.size() < 1)
return false;
popstack(stack);
}
break;
case OP_DUP:
{
// (x -- x x)
if (stack.size() < 1)
return false;
valtype vch = stacktop(-1);
stack.push_back(vch);
}
break;
case OP_NIP:
{
// (x1 x2 -- x2)
if (stack.size() < 2)
return false;
stack.erase(stack.end() - 2);
}
break;
case OP_OVER:
{
// (x1 x2 -- x1 x2 x1)
if (stack.size() < 2)
return false;
valtype vch = stacktop(-2);
stack.push_back(vch);
}
break;
case OP_PICK:
case OP_ROLL:
{
// (xn ... x2 x1 x0 n - xn ... x2 x1 x0 xn)
// (xn ... x2 x1 x0 n - ... x2 x1 x0 xn)
if (stack.size() < 2)
return false;
int n = CastToBigNum(stacktop(-1)).getint();
popstack(stack);
if (n < 0 || n >= (int)stack.size())
return false;
valtype vch = stacktop(-n-1);
if (opcode == OP_ROLL)
stack.erase(stack.end()-n-1);
stack.push_back(vch);
}
break;
case OP_ROT:
{
// (x1 x2 x3 -- x2 x3 x1)
// x2 x1 x3 after first swap
// x2 x3 x1 after second swap
if (stack.size() < 3)
return false;
swap(stacktop(-3), stacktop(-2));
swap(stacktop(-2), stacktop(-1));
}
break;
case OP_SWAP:
{
// (x1 x2 -- x2 x1)
if (stack.size() < 2)
return false;
swap(stacktop(-2), stacktop(-1));
}
break;
case OP_TUCK:
{
// (x1 x2 -- x2 x1 x2)
if (stack.size() < 2)
return false;
valtype vch = stacktop(-1);
stack.insert(stack.end()-2, vch);
}
break;
//
// Splice ops
//
case OP_CAT:
{
// (x1 x2 -- out)
if (stack.size() < 2)
return false;
valtype& vch1 = stacktop(-2);
valtype& vch2 = stacktop(-1);
vch1.insert(vch1.end(), vch2.begin(), vch2.end());
popstack(stack);
if (stacktop(-1).size() > 520)
return false;
}
break;
case OP_SUBSTR:
{
// (in begin size -- out)
if (stack.size() < 3)
return false;
valtype& vch = stacktop(-3);
int nBegin = CastToBigNum(stacktop(-2)).getint();
int nEnd = nBegin + CastToBigNum(stacktop(-1)).getint();
if (nBegin < 0 || nEnd < nBegin)
return false;
if (nBegin > (int)vch.size())
nBegin = vch.size();
if (nEnd > (int)vch.size())
nEnd = vch.size();
vch.erase(vch.begin() + nEnd, vch.end());
vch.erase(vch.begin(), vch.begin() + nBegin);
popstack(stack);
popstack(stack);
}
break;
case OP_LEFT:
case OP_RIGHT:
{
// (in size -- out)
if (stack.size() < 2)
return false;
valtype& vch = stacktop(-2);
int nSize = CastToBigNum(stacktop(-1)).getint();
if (nSize < 0)
return false;
if (nSize > (int)vch.size())
nSize = vch.size();
if (opcode == OP_LEFT)
vch.erase(vch.begin() + nSize, vch.end());
else
vch.erase(vch.begin(), vch.end() - nSize);
popstack(stack);
}
break;
case OP_SIZE:
{
// (in -- in size)
if (stack.size() < 1)
return false;
CBigNum bn(stacktop(-1).size());
stack.push_back(bn.getvch());
}
break;
//
// Bitwise logic
//
case OP_INVERT:
{
// (in - out)
if (stack.size() < 1)
return false;
valtype& vch = stacktop(-1);
for (unsigned int i = 0; i < vch.size(); i++)
vch[i] = ~vch[i];
}
break;
case OP_AND:
case OP_OR:
case OP_XOR:
{
// (x1 x2 - out)
if (stack.size() < 2)
return false;
valtype& vch1 = stacktop(-2);
valtype& vch2 = stacktop(-1);
MakeSameSize(vch1, vch2);
if (opcode == OP_AND)
{
for (unsigned int i = 0; i < vch1.size(); i++)
vch1[i] &= vch2[i];
}
else if (opcode == OP_OR)
{
for (unsigned int i = 0; i < vch1.size(); i++)
vch1[i] |= vch2[i];
}
else if (opcode == OP_XOR)
{
for (unsigned int i = 0; i < vch1.size(); i++)
vch1[i] ^= vch2[i];
}
popstack(stack);
}
break;
case OP_EQUAL:
case OP_EQUALVERIFY:
//case OP_NOTEQUAL: // use OP_NUMNOTEQUAL
{
// (x1 x2 - bool)
if (stack.size() < 2)
return false;
valtype& vch1 = stacktop(-2);
valtype& vch2 = stacktop(-1);
bool fEqual = (vch1 == vch2);
// OP_NOTEQUAL is disabled PKCause it would be too easy to say
// something like n != 1 and have some wiseguy pass in 1 with extra
// zero bytes after it (numerically, 0x01 == 0x0001 == 0x000001)
//if (opcode == OP_NOTEQUAL)
// fEqual = !fEqual;
popstack(stack);
popstack(stack);
stack.push_back(fEqual ? vchTrue : vchFalse);
if (opcode == OP_EQUALVERIFY)
{
if (fEqual)
popstack(stack);
else
return false;
}
}
break;
//
// Numeric
//
case OP_1ADD:
case OP_1SUB:
case OP_2MUL:
case OP_2DIV:
case OP_NEGATE:
case OP_ABS:
case OP_NOT:
case OP_0NOTEQUAL:
{
// (in -- out)
if (stack.size() < 1)
return false;
CBigNum bn = CastToBigNum(stacktop(-1));
switch (opcode)
{
case OP_1ADD: bn += bnOne; break;
case OP_1SUB: bn -= bnOne; break;
case OP_2MUL: bn <<= 1; break;
case OP_2DIV: bn >>= 1; break;
case OP_NEGATE: bn = -bn; break;
case OP_ABS: if (bn < bnZero) bn = -bn; break;
case OP_NOT: bn = (bn == bnZero); break;
case OP_0NOTEQUAL: bn = (bn != bnZero); break;
default: assert(!"invalid opcode"); break;
}
popstack(stack);
stack.push_back(bn.getvch());
}
break;
case OP_ADD:
case OP_SUB:
case OP_MUL:
case OP_DIV:
case OP_MOD:
case OP_LSHIFT:
case OP_RSHIFT:
case OP_BOOLAND:
case OP_BOOLOR:
case OP_NUMEQUAL:
case OP_NUMEQUALVERIFY:
case OP_NUMNOTEQUAL:
case OP_LESSTHAN:
case OP_GREATERTHAN:
case OP_LESSTHANOREQUAL:
case OP_GREATERTHANOREQUAL:
case OP_MIN:
case OP_MAX:
{
// (x1 x2 -- out)
if (stack.size() < 2)
return false;
CBigNum bn1 = CastToBigNum(stacktop(-2));
CBigNum bn2 = CastToBigNum(stacktop(-1));
CBigNum bn;
switch (opcode)
{
case OP_ADD:
bn = bn1 + bn2;
break;
case OP_SUB:
bn = bn1 - bn2;
break;
case OP_MUL:
if (!BN_mul(&bn, &bn1, &bn2, pctx))
return false;
break;
case OP_DIV:
if (!BN_div(&bn, NULL, &bn1, &bn2, pctx))
return false;
break;
case OP_MOD:
if (!BN_mod(&bn, &bn1, &bn2, pctx))
return false;
break;
case OP_LSHIFT:
if (bn2 < bnZero || bn2 > CBigNum(2048))
return false;
bn = bn1 << bn2.getulong();
break;
case OP_RSHIFT:
if (bn2 < bnZero || bn2 > CBigNum(2048))
return false;
bn = bn1 >> bn2.getulong();
break;
case OP_BOOLAND: bn = (bn1 != bnZero && bn2 != bnZero); break;
case OP_BOOLOR: bn = (bn1 != bnZero || bn2 != bnZero); break;
case OP_NUMEQUAL: bn = (bn1 == bn2); break;
case OP_NUMEQUALVERIFY: bn = (bn1 == bn2); break;
case OP_NUMNOTEQUAL: bn = (bn1 != bn2); break;
case OP_LESSTHAN: bn = (bn1 < bn2); break;
case OP_GREATERTHAN: bn = (bn1 > bn2); break;
case OP_LESSTHANOREQUAL: bn = (bn1 <= bn2); break;
case OP_GREATERTHANOREQUAL: bn = (bn1 >= bn2); break;
case OP_MIN: bn = (bn1 < bn2 ? bn1 : bn2); break;
case OP_MAX: bn = (bn1 > bn2 ? bn1 : bn2); break;
default: assert(!"invalid opcode"); break;
}
popstack(stack);
popstack(stack);
stack.push_back(bn.getvch());
if (opcode == OP_NUMEQUALVERIFY)
{
if (CastToBool(stacktop(-1)))
popstack(stack);
else
return false;
}
}
break;
case OP_WITHIN:
{
// (x min max -- out)
if (stack.size() < 3)
return false;
CBigNum bn1 = CastToBigNum(stacktop(-3));
CBigNum bn2 = CastToBigNum(stacktop(-2));
CBigNum bn3 = CastToBigNum(stacktop(-1));
bool fValue = (bn2 <= bn1 && bn1 < bn3);
popstack(stack);
popstack(stack);
popstack(stack);
stack.push_back(fValue ? vchTrue : vchFalse);
}
break;
//
// Crypto
//
case OP_RIPEMD160:
case OP_SHA1:
case OP_SHA256:
case OP_HASH160:
case OP_HASH256:
{
// (in -- hash)
if (stack.size() < 1)
return false;
valtype& vch = stacktop(-1);
valtype vchHash((opcode == OP_RIPEMD160 || opcode == OP_SHA1 || opcode == OP_HASH160) ? 20 : 32);
if (opcode == OP_RIPEMD160)
RIPEMD160(&vch[0], vch.size(), &vchHash[0]);
else if (opcode == OP_SHA1)
SHA1(&vch[0], vch.size(), &vchHash[0]);
else if (opcode == OP_SHA256)
SHA256(&vch[0], vch.size(), &vchHash[0]);
else if (opcode == OP_HASH160)
{
uint160 hash160 = Hash160(vch);
memcpy(&vchHash[0], &hash160, sizeof(hash160));
}
else if (opcode == OP_HASH256)
{
uint256 hash = Hash(vch.begin(), vch.end());
memcpy(&vchHash[0], &hash, sizeof(hash));
}
popstack(stack);
stack.push_back(vchHash);
}
break;
case OP_CODESEPARATOR:
{
// Hash starts after the code separator
pbegincodehash = pc;
}
break;
case OP_CHECKSIG:
case OP_CHECKSIGVERIFY:
{
// (sig pubkey -- bool)
if (stack.size() < 2)
return false;
valtype& vchSig = stacktop(-2);
valtype& vchPubKey = stacktop(-1);
////// debug print
//PrintHex(vchSig.begin(), vchSig.end(), "sig: %s\n");
//PrintHex(vchPubKey.begin(), vchPubKey.end(), "pubkey: %s\n");
// Subset of script starting at the most recent codeseparator
CScript scriptCode(pbegincodehash, pend);
// Drop the signature, since there's no way for a signature to sign itself
scriptCode.FindAndDelete(CScript(vchSig));
bool fSuccess = CheckSig(vchSig, vchPubKey, scriptCode, txTo, nIn, nHashType);
popstack(stack);
popstack(stack);
stack.push_back(fSuccess ? vchTrue : vchFalse);
if (opcode == OP_CHECKSIGVERIFY)
{
if (fSuccess)
popstack(stack);
else
return false;
}
}
break;
case OP_CHECKMULTISIG:
case OP_CHECKMULTISIGVERIFY:
{
// ([sig ...] num_of_signatures [pubkey ...] num_of_pubkeys -- bool)
int i = 1;
if ((int)stack.size() < i)
return false;
int nKeysCount = CastToBigNum(stacktop(-i)).getint();
if (nKeysCount < 0 || nKeysCount > 20)
return false;
nOpCount += nKeysCount;
if (nOpCount > 201)
return false;
int ikey = ++i;
i += nKeysCount;
if ((int)stack.size() < i)
return false;
int nSigsCount = CastToBigNum(stacktop(-i)).getint();
if (nSigsCount < 0 || nSigsCount > nKeysCount)
return false;
int isig = ++i;
i += nSigsCount;
if ((int)stack.size() < i)
return false;
// Subset of script starting at the most recent codeseparator
CScript scriptCode(pbegincodehash, pend);
// Drop the signatures, since there's no way for a signature to sign itself
for (int k = 0; k < nSigsCount; k++)
{
valtype& vchSig = stacktop(-isig-k);
scriptCode.FindAndDelete(CScript(vchSig));
}
bool fSuccess = true;
while (fSuccess && nSigsCount > 0)
{
valtype& vchSig = stacktop(-isig);
valtype& vchPubKey = stacktop(-ikey);
// Check signature
if (CheckSig(vchSig, vchPubKey, scriptCode, txTo, nIn, nHashType))
{
isig++;
nSigsCount--;
}
ikey++;
nKeysCount--;
// If there are more signatures left than keys left,
// then too many signatures have failed
if (nSigsCount > nKeysCount)
fSuccess = false;
}
while (i-- > 0)
popstack(stack);
stack.push_back(fSuccess ? vchTrue : vchFalse);
if (opcode == OP_CHECKMULTISIGVERIFY)
{
if (fSuccess)
popstack(stack);
else
return false;
}
}
break;
default:
return false;
}
// Size limits
if (stack.size() + altstack.size() > 1000)
return false;
}
}
catch (...)
{
return false;
}
if (!vfExec.empty())
return false;
return true;
}
uint256 SignatureHash(CScript scriptCode, const CTransaction& txTo, unsigned int nIn, int nHashType)
{
if (nIn >= txTo.vin.size())
{
printf("ERROR: SignatureHash() : nIn=%d out of range\n", nIn);
return 1;
}
CTransaction txTmp(txTo);
// In case concatenating two scripts ends up with two codeseparators,
// or an extra one at the end, this prevents all those possible incompatibilities.
scriptCode.FindAndDelete(CScript(OP_CODESEPARATOR));
// Blank out other inputs' signatures
for (unsigned int i = 0; i < txTmp.vin.size(); i++)
txTmp.vin[i].scriptSig = CScript();
txTmp.vin[nIn].scriptSig = scriptCode;
// Blank out some of the outputs
if ((nHashType & 0x1f) == SIGHASH_NONE)
{
// Wildcard payee
txTmp.vout.clear();
// Let the others update at will
for (unsigned int i = 0; i < txTmp.vin.size(); i++)
if (i != nIn)
txTmp.vin[i].nSequence = 0;
}
else if ((nHashType & 0x1f) == SIGHASH_SINGLE)
{
// Only lockin the txout payee at same index as txin
unsigned int nOut = nIn;
if (nOut >= txTmp.vout.size())
{
printf("ERROR: SignatureHash() : nOut=%d out of range\n", nOut);
return 1;
}
txTmp.vout.resize(nOut+1);
for (unsigned int i = 0; i < nOut; i++)
txTmp.vout[i].SetNull();
// Let the others update at will
for (unsigned int i = 0; i < txTmp.vin.size(); i++)
if (i != nIn)
txTmp.vin[i].nSequence = 0;
}
// Blank out other inputs completely, not recommended for open transactions
if (nHashType & SIGHASH_ANYONECANPAY)
{
txTmp.vin[0] = txTmp.vin[nIn];
txTmp.vin.resize(1);
}
// Serialize and hash
CDataStream ss(SER_GETHASH, 0);
ss.reserve(10000);
ss << txTmp << nHashType;
return Hash(ss.begin(), ss.end());
}
// Valid signature cache, to avoid doing expensive ECDSA signature checking
// twice for every transaction (once when accepted into memory pool, and
// again when accepted into the block chain)
class CSignatureCache
{
private:
// sigdata_type is (signature hash, signature, public key):
typedef boost::tuple<uint256, std::vector<unsigned char>, std::vector<unsigned char> > sigdata_type;
std::set< sigdata_type> setValid;
CCriticalSection cs_sigcache;
public:
bool
Get(uint256 hash, const std::vector<unsigned char>& vchSig, const std::vector<unsigned char>& pubKey)
{
LOCK(cs_sigcache);
sigdata_type k(hash, vchSig, pubKey);
std::set<sigdata_type>::iterator mi = setValid.find(k);
if (mi != setValid.end())
return true;
return false;
}
void
Set(uint256 hash, const std::vector<unsigned char>& vchSig, const std::vector<unsigned char>& pubKey)
{
// DoS prevention: limit cache size to less than 10MB
// (~200 bytes per cache entry times 50,000 entries)
// Since there are a maximum of 20,000 signature operations per block
// 50,000 is a reasonable default.
int64 nMaxCacheSize = GetArg("-maxsigcachesize", 50000);
if (nMaxCacheSize <= 0) return;
LOCK(cs_sigcache);
while (static_cast<int64>(setValid.size()) > nMaxCacheSize)
{
// Evict a random entry. Random PKCause that helps
// foil would-be DoS attackers who might try to pre-generate
// and re-use a set of valid signatures just-slightly-greater
// than our cache size.
uint256 randomHash = GetRandHash();
std::vector<unsigned char> unused;
std::set<sigdata_type>::iterator it =
setValid.lower_bound(sigdata_type(randomHash, unused, unused));
if (it == setValid.end())
it = setValid.begin();
setValid.erase(*it);
}
sigdata_type k(hash, vchSig, pubKey);
setValid.insert(k);
}
};
bool CheckSig(vector<unsigned char> vchSig, vector<unsigned char> vchPubKey, CScript scriptCode,
const CTransaction& txTo, unsigned int nIn, int nHashType)
{
static CSignatureCache signatureCache;
// Hash type is one byte tacked on to the end of the signature
if (vchSig.empty())
return false;
if (nHashType == 0)
nHashType = vchSig.back();
else if (nHashType != vchSig.back())
return false;
vchSig.pop_back();
uint256 sighash = SignatureHash(scriptCode, txTo, nIn, nHashType);
if (signatureCache.Get(sighash, vchSig, vchPubKey))
return true;
CKey key;
if (!key.SetPubKey(vchPubKey))
return false;
if (!key.Verify(sighash, vchSig))
return false;
signatureCache.Set(sighash, vchSig, vchPubKey);
return true;
}
//
// Return public keys or hashes from scriptPubKey, for 'standard' transaction types.
//
bool Solver(const CScript& scriptPubKey, txnouttype& typeRet, vector<vector<unsigned char> >& vSolutionsRet)
{
// Templates
static map<txnouttype, CScript> mTemplates;
if (mTemplates.empty())
{
// Standard tx, sender provides pubkey, receiver adds signature
mTemplates.insert(make_pair(TX_PUBKEY, CScript() << OP_PUBKEY << OP_CHECKSIG));
// Bitcoin address tx, sender provides hash of pubkey, receiver provides signature and pubkey
mTemplates.insert(make_pair(TX_PUBKEYHASH, CScript() << OP_DUP << OP_HASH160 << OP_PUBKEYHASH << OP_EQUALVERIFY << OP_CHECKSIG));
// Sender provides N pubkeys, receivers provides M signatures
mTemplates.insert(make_pair(TX_MULTISIG, CScript() << OP_SMALLINTEGER << OP_PUBKEYS << OP_SMALLINTEGER << OP_CHECKMULTISIG));
}
// Shortcut for pay-to-script-hash, which are more constrained than the other types:
// it is always OP_HASH160 20 [20 byte hash] OP_EQUAL
if (scriptPubKey.IsPayToScriptHash())
{
typeRet = TX_SCRIPTHASH;
vector<unsigned char> hashBytes(scriptPubKey.begin()+2, scriptPubKey.begin()+22);
vSolutionsRet.push_back(hashBytes);
return true;
}
// Scan templates
const CScript& script1 = scriptPubKey;
BOOST_FOREACH(const PAIRTYPE(txnouttype, CScript)& tplate, mTemplates)
{
const CScript& script2 = tplate.second;
vSolutionsRet.clear();
opcodetype opcode1, opcode2;
vector<unsigned char> vch1, vch2;
// Compare
CScript::const_iterator pc1 = script1.begin();
CScript::const_iterator pc2 = script2.begin();
loop
{
if (pc1 == script1.end() && pc2 == script2.end())
{
// Found a match
typeRet = tplate.first;
if (typeRet == TX_MULTISIG)
{
// Additional checks for TX_MULTISIG:
unsigned char m = vSolutionsRet.front()[0];
unsigned char n = vSolutionsRet.back()[0];
if (m < 1 || n < 1 || m > n || vSolutionsRet.size()-2 != n)
return false;
}
return true;
}
if (!script1.GetOp(pc1, opcode1, vch1))
break;
if (!script2.GetOp(pc2, opcode2, vch2))
break;
// Template matching opcodes:
if (opcode2 == OP_PUBKEYS)
{
while (vch1.size() >= 33 && vch1.size() <= 120)
{
vSolutionsRet.push_back(vch1);
if (!script1.GetOp(pc1, opcode1, vch1))
break;
}
if (!script2.GetOp(pc2, opcode2, vch2))
break;
// Normal situation is to fall through
// to other if/else statments
}
if (opcode2 == OP_PUBKEY)
{
if (vch1.size() < 33 || vch1.size() > 120)
break;
vSolutionsRet.push_back(vch1);
}
else if (opcode2 == OP_PUBKEYHASH)
{
if (vch1.size() != sizeof(uint160))
break;
vSolutionsRet.push_back(vch1);
}
else if (opcode2 == OP_SMALLINTEGER)
{ // Single-byte small integer pushed onto vSolutions
if (opcode1 == OP_0 ||
(opcode1 >= OP_1 && opcode1 <= OP_16))
{
char n = (char)CScript::DecodeOP_N(opcode1);
vSolutionsRet.push_back(valtype(1, n));
}
else
break;
}
else if (opcode1 != opcode2 || vch1 != vch2)
{
// Others must match exactly
break;
}
}
}
vSolutionsRet.clear();
typeRet = TX_NONSTANDARD;
return false;
}
bool Sign1(const CKeyID& address, const CKeyStore& keystore, uint256 hash, int nHashType, CScript& scriptSigRet)
{
CKey key;
if (!keystore.GetKey(address, key))
return false;
vector<unsigned char> vchSig;
if (!key.Sign(hash, vchSig))
return false;
vchSig.push_back((unsigned char)nHashType);
scriptSigRet << vchSig;
return true;
}
bool SignN(const vector<valtype>& multisigdata, const CKeyStore& keystore, uint256 hash, int nHashType, CScript& scriptSigRet)
{
int nSigned = 0;
int nRequired = multisigdata.front()[0];
for (unsigned int i = 1; i < multisigdata.size()-1 && nSigned < nRequired; i++)
{
const valtype& pubkey = multisigdata[i];
CKeyID keyID = CPubKey(pubkey).GetID();
if (Sign1(keyID, keystore, hash, nHashType, scriptSigRet))
++nSigned;
}
return nSigned==nRequired;
}
//
// Sign scriptPubKey with private keys stored in keystore, given transaction hash and hash type.
// Signatures are returned in scriptSigRet (or returns false if scriptPubKey can't be signed),
// unless whichTypeRet is TX_SCRIPTHASH, in which case scriptSigRet is the redemption script.
// Returns false if scriptPubKey could not be completely satisified.
//
bool Solver(const CKeyStore& keystore, const CScript& scriptPubKey, uint256 hash, int nHashType,
CScript& scriptSigRet, txnouttype& whichTypeRet)
{
scriptSigRet.clear();
vector<valtype> vSolutions;
if (!Solver(scriptPubKey, whichTypeRet, vSolutions))
return false;
CKeyID keyID;
switch (whichTypeRet)
{
case TX_NONSTANDARD:
return false;
case TX_PUBKEY:
keyID = CPubKey(vSolutions[0]).GetID();
return Sign1(keyID, keystore, hash, nHashType, scriptSigRet);
case TX_PUBKEYHASH:
keyID = CKeyID(uint160(vSolutions[0]));
if (!Sign1(keyID, keystore, hash, nHashType, scriptSigRet))
return false;
else
{
CPubKey vch;
keystore.GetPubKey(keyID, vch);
scriptSigRet << vch;
}
return true;
case TX_SCRIPTHASH:
return keystore.GetCScript(uint160(vSolutions[0]), scriptSigRet);
case TX_MULTISIG:
scriptSigRet << OP_0; // workaround CHECKMULTISIG bug
return (SignN(vSolutions, keystore, hash, nHashType, scriptSigRet));
}
return false;
}
int ScriptSigArgsExpected(txnouttype t, const std::vector<std::vector<unsigned char> >& vSolutions)
{
switch (t)
{
case TX_NONSTANDARD:
return -1;
case TX_PUBKEY:
return 1;
case TX_PUBKEYHASH:
return 2;
case TX_MULTISIG:
if (vSolutions.size() < 1 || vSolutions[0].size() < 1)
return -1;
return vSolutions[0][0] + 1;
case TX_SCRIPTHASH:
return 1; // doesn't include args needed by the script
}
return -1;
}
bool IsStandard(const CScript& scriptPubKey)
{
vector<valtype> vSolutions;
txnouttype whichType;
if (!Solver(scriptPubKey, whichType, vSolutions))
return false;
if (whichType == TX_MULTISIG)
{
unsigned char m = vSolutions.front()[0];
unsigned char n = vSolutions.back()[0];
// Support up to x-of-3 multisig txns as standard
if (n < 1 || n > 3)
return false;
if (m < 1 || m > n)
return false;
}
return whichType != TX_NONSTANDARD;
}
unsigned int HaveKeys(const vector<valtype>& pubkeys, const CKeyStore& keystore)
{
unsigned int nResult = 0;
BOOST_FOREACH(const valtype& pubkey, pubkeys)
{
CKeyID keyID = CPubKey(pubkey).GetID();
if (keystore.HaveKey(keyID))
++nResult;
}
return nResult;
}
class CKeyStoreIsMineVisitor : public boost::static_visitor<bool>
{
private:
const CKeyStore *keystore;
public:
CKeyStoreIsMineVisitor(const CKeyStore *keystoreIn) : keystore(keystoreIn) { }
bool operator()(const CNoDestination &dest) const { return false; }
bool operator()(const CKeyID &keyID) const { return keystore->HaveKey(keyID); }
bool operator()(const CScriptID &scriptID) const { return keystore->HaveCScript(scriptID); }
};
bool IsMine(const CKeyStore &keystore, const CTxDestination &dest)
{
return boost::apply_visitor(CKeyStoreIsMineVisitor(&keystore), dest);
}
bool IsMine(const CKeyStore &keystore, const CScript& scriptPubKey)
{
vector<valtype> vSolutions;
txnouttype whichType;
if (!Solver(scriptPubKey, whichType, vSolutions))
return false;
CKeyID keyID;
switch (whichType)
{
case TX_NONSTANDARD:
return false;
case TX_PUBKEY:
keyID = CPubKey(vSolutions[0]).GetID();
return keystore.HaveKey(keyID);
case TX_PUBKEYHASH:
keyID = CKeyID(uint160(vSolutions[0]));
return keystore.HaveKey(keyID);
case TX_SCRIPTHASH:
{
CScript subscript;
if (!keystore.GetCScript(CScriptID(uint160(vSolutions[0])), subscript))
return false;
return IsMine(keystore, subscript);
}
case TX_MULTISIG:
{
// Only consider transactions "mine" if we own ALL the
// keys involved. multi-signature transactions that are
// partially owned (somebody else has a key that can spend
// them) enable spend-out-from-under-you attacks, especially
// in shared-wallet situations.
vector<valtype> keys(vSolutions.begin()+1, vSolutions.begin()+vSolutions.size()-1);
return HaveKeys(keys, keystore) == keys.size();
}
}
return false;
}
bool ExtractDestination(const CScript& scriptPubKey, CTxDestination& addressRet)
{
vector<valtype> vSolutions;
txnouttype whichType;
if (!Solver(scriptPubKey, whichType, vSolutions))
return false;
if (whichType == TX_PUBKEY)
{
addressRet = CPubKey(vSolutions[0]).GetID();
return true;
}
else if (whichType == TX_PUBKEYHASH)
{
addressRet = CKeyID(uint160(vSolutions[0]));
return true;
}
else if (whichType == TX_SCRIPTHASH)
{
addressRet = CScriptID(uint160(vSolutions[0]));
return true;
}
// Multisig txns have more than one address...
return false;
}
bool ExtractDestinations(const CScript& scriptPubKey, txnouttype& typeRet, vector<CTxDestination>& addressRet, int& nRequiredRet)
{
addressRet.clear();
typeRet = TX_NONSTANDARD;
vector<valtype> vSolutions;
if (!Solver(scriptPubKey, typeRet, vSolutions))
return false;
if (typeRet == TX_MULTISIG)
{
nRequiredRet = vSolutions.front()[0];
for (unsigned int i = 1; i < vSolutions.size()-1; i++)
{
CTxDestination address = CPubKey(vSolutions[i]).GetID();
addressRet.push_back(address);
}
}
else
{
nRequiredRet = 1;
CTxDestination address;
if (!ExtractDestination(scriptPubKey, address))
return false;
addressRet.push_back(address);
}
return true;
}
bool VerifyScript(const CScript& scriptSig, const CScript& scriptPubKey, const CTransaction& txTo, unsigned int nIn,
bool fValidatePayToScriptHash, int nHashType)
{
vector<vector<unsigned char> > stack, stackCopy;
if (!EvalScript(stack, scriptSig, txTo, nIn, nHashType))
return false;
if (fValidatePayToScriptHash)
stackCopy = stack;
if (!EvalScript(stack, scriptPubKey, txTo, nIn, nHashType))
return false;
if (stack.empty())
return false;
if (CastToBool(stack.back()) == false)
return false;
// Additional validation for spend-to-script-hash transactions:
if (fValidatePayToScriptHash && scriptPubKey.IsPayToScriptHash())
{
if (!scriptSig.IsPushOnly()) // scriptSig must be literals-only
return false; // or validation fails
const valtype& pubKeySerialized = stackCopy.back();
CScript pubKey2(pubKeySerialized.begin(), pubKeySerialized.end());
popstack(stackCopy);
if (!EvalScript(stackCopy, pubKey2, txTo, nIn, nHashType))
return false;
if (stackCopy.empty())
return false;
return CastToBool(stackCopy.back());
}
return true;
}
bool SignSignature(const CKeyStore &keystore, const CScript& fromPubKey, CTransaction& txTo, unsigned int nIn, int nHashType)
{
assert(nIn < txTo.vin.size());
CTxIn& txin = txTo.vin[nIn];
// Leave out the signature from the hash, since a signature can't sign itself.
// The checksig op will also drop the signatures from its hash.
uint256 hash = SignatureHash(fromPubKey, txTo, nIn, nHashType);
txnouttype whichType;
if (!Solver(keystore, fromPubKey, hash, nHashType, txin.scriptSig, whichType))
return false;
if (whichType == TX_SCRIPTHASH)
{
// Solver returns the subscript that need to be evaluated;
// the final scriptSig is the signatures from that
// and then the serialized subscript:
CScript subscript = txin.scriptSig;
// Recompute txn hash using subscript in place of scriptPubKey:
uint256 hash2 = SignatureHash(subscript, txTo, nIn, nHashType);
txnouttype subType;
bool fSolved =
Solver(keystore, subscript, hash2, nHashType, txin.scriptSig, subType) && subType != TX_SCRIPTHASH;
// Append serialized subscript whether or not it is completely signed:
txin.scriptSig << static_cast<valtype>(subscript);
if (!fSolved) return false;
}
// Test solution
return VerifyScript(txin.scriptSig, fromPubKey, txTo, nIn, true, 0);
}
bool SignSignature(const CKeyStore &keystore, const CTransaction& txFrom, CTransaction& txTo, unsigned int nIn, int nHashType)
{
assert(nIn < txTo.vin.size());
CTxIn& txin = txTo.vin[nIn];
assert(txin.prevout.n < txFrom.vout.size());
const CTxOut& txout = txFrom.vout[txin.prevout.n];
return SignSignature(keystore, txout.scriptPubKey, txTo, nIn, nHashType);
}
bool VerifySignature(const CTransaction& txFrom, const CTransaction& txTo, unsigned int nIn, bool fValidatePayToScriptHash, int nHashType)
{
assert(nIn < txTo.vin.size());
const CTxIn& txin = txTo.vin[nIn];
if (txin.prevout.n >= txFrom.vout.size())
return false;
const CTxOut& txout = txFrom.vout[txin.prevout.n];
if (txin.prevout.hash != txFrom.GetHash())
return false;
return VerifyScript(txin.scriptSig, txout.scriptPubKey, txTo, nIn, fValidatePayToScriptHash, nHashType);
}
static CScript PushAll(const vector<valtype>& values)
{
CScript result;
BOOST_FOREACH(const valtype& v, values)
result << v;
return result;
}
static CScript CombineMultisig(CScript scriptPubKey, const CTransaction& txTo, unsigned int nIn,
const vector<valtype>& vSolutions,
vector<valtype>& sigs1, vector<valtype>& sigs2)
{
// Combine all the signatures we've got:
set<valtype> allsigs;
BOOST_FOREACH(const valtype& v, sigs1)
{
if (!v.empty())
allsigs.insert(v);
}
BOOST_FOREACH(const valtype& v, sigs2)
{
if (!v.empty())
allsigs.insert(v);
}
// Build a map of pubkey -> signature by matching sigs to pubkeys:
assert(vSolutions.size() > 1);
unsigned int nSigsRequired = vSolutions.front()[0];
unsigned int nPubKeys = vSolutions.size()-2;
map<valtype, valtype> sigs;
BOOST_FOREACH(const valtype& sig, allsigs)
{
for (unsigned int i = 0; i < nPubKeys; i++)
{
const valtype& pubkey = vSolutions[i+1];
if (sigs.count(pubkey))
continue; // Already got a sig for this pubkey
if (CheckSig(sig, pubkey, scriptPubKey, txTo, nIn, 0))
{
sigs[pubkey] = sig;
break;
}
}
}
// Now build a merged CScript:
unsigned int nSigsHave = 0;
CScript result; result << OP_0; // pop-one-too-many workaround
for (unsigned int i = 0; i < nPubKeys && nSigsHave < nSigsRequired; i++)
{
if (sigs.count(vSolutions[i+1]))
{
result << sigs[vSolutions[i+1]];
++nSigsHave;
}
}
// Fill any missing with OP_0:
for (unsigned int i = nSigsHave; i < nSigsRequired; i++)
result << OP_0;
return result;
}
static CScript CombineSignatures(CScript scriptPubKey, const CTransaction& txTo, unsigned int nIn,
const txnouttype txType, const vector<valtype>& vSolutions,
vector<valtype>& sigs1, vector<valtype>& sigs2)
{
switch (txType)
{
case TX_NONSTANDARD:
// Don't know anything about this, assume bigger one is correct:
if (sigs1.size() >= sigs2.size())
return PushAll(sigs1);
return PushAll(sigs2);
case TX_PUBKEY:
case TX_PUBKEYHASH:
// Signatures are bigger than placeholders or empty scripts:
if (sigs1.empty() || sigs1[0].empty())
return PushAll(sigs2);
return PushAll(sigs1);
case TX_SCRIPTHASH:
if (sigs1.empty() || sigs1.back().empty())
return PushAll(sigs2);
else if (sigs2.empty() || sigs2.back().empty())
return PushAll(sigs1);
else
{
// Recurse to combine:
valtype spk = sigs1.back();
CScript pubKey2(spk.begin(), spk.end());
txnouttype txType2;
vector<vector<unsigned char> > vSolutions2;
Solver(pubKey2, txType2, vSolutions2);
sigs1.pop_back();
sigs2.pop_back();
CScript result = CombineSignatures(pubKey2, txTo, nIn, txType2, vSolutions2, sigs1, sigs2);
result << spk;
return result;
}
case TX_MULTISIG:
return CombineMultisig(scriptPubKey, txTo, nIn, vSolutions, sigs1, sigs2);
}
return CScript();
}
CScript CombineSignatures(CScript scriptPubKey, const CTransaction& txTo, unsigned int nIn,
const CScript& scriptSig1, const CScript& scriptSig2)
{
txnouttype txType;
vector<vector<unsigned char> > vSolutions;
Solver(scriptPubKey, txType, vSolutions);
vector<valtype> stack1;
EvalScript(stack1, scriptSig1, CTransaction(), 0, 0);
vector<valtype> stack2;
EvalScript(stack2, scriptSig2, CTransaction(), 0, 0);
return CombineSignatures(scriptPubKey, txTo, nIn, txType, vSolutions, stack1, stack2);
}
unsigned int CScript::GetSigOpCount(bool fAccurate) const
{
unsigned int n = 0;
const_iterator pc = begin();
opcodetype lastOpcode = OP_INVALIDOPCODE;
while (pc < end())
{
opcodetype opcode;
if (!GetOp(pc, opcode))
break;
if (opcode == OP_CHECKSIG || opcode == OP_CHECKSIGVERIFY)
n++;
else if (opcode == OP_CHECKMULTISIG || opcode == OP_CHECKMULTISIGVERIFY)
{
if (fAccurate && lastOpcode >= OP_1 && lastOpcode <= OP_16)
n += DecodeOP_N(lastOpcode);
else
n += 20;
}
lastOpcode = opcode;
}
return n;
}
unsigned int CScript::GetSigOpCount(const CScript& scriptSig) const
{
if (!IsPayToScriptHash())
return GetSigOpCount(true);
// This is a pay-to-script-hash scriptPubKey;
// get the last item that the scriptSig
// pushes onto the stack:
const_iterator pc = scriptSig.begin();
vector<unsigned char> data;
while (pc < scriptSig.end())
{
opcodetype opcode;
if (!scriptSig.GetOp(pc, opcode, data))
return 0;
if (opcode > OP_16)
return 0;
}
/// ... and return it's opcount:
CScript subscript(data.begin(), data.end());
return subscript.GetSigOpCount(true);
}
bool CScript::IsPayToScriptHash() const
{
// Extra-fast test for pay-to-script-hash CScripts:
return (this->size() == 23 &&
this->at(0) == OP_HASH160 &&
this->at(1) == 0x14 &&
this->at(22) == OP_EQUAL);
}
class CScriptVisitor : public boost::static_visitor<bool>
{
private:
CScript *script;
public:
CScriptVisitor(CScript *scriptin) { script = scriptin; }
bool operator()(const CNoDestination &dest) const {
script->clear();
return false;
}
bool operator()(const CKeyID &keyID) const {
script->clear();
*script << OP_DUP << OP_HASH160 << keyID << OP_EQUALVERIFY << OP_CHECKSIG;
return true;
}
bool operator()(const CScriptID &scriptID) const {
script->clear();
*script << OP_HASH160 << scriptID << OP_EQUAL;
return true;
}
};
void CScript::SetDestination(const CTxDestination& dest)
{
boost::apply_visitor(CScriptVisitor(this), dest);
}
void CScript::SetMultisig(int nRequired, const std::vector<CKey>& keys)
{
this->clear();
*this << EncodeOP_N(nRequired);
BOOST_FOREACH(const CKey& key, keys)
*this << key.GetPubKey();
*this << EncodeOP_N(keys.size()) << OP_CHECKMULTISIG;
}
| [
"[email protected]"
] | |
3ec879a6d5a09792e37707a32107ce59217d569d | 98663b6fb7cfc27caea1d4fd4a744d8df534316f | /AgoraHQ-Broadcaster-Windows/AgoraHQ/DlgAnswerResultStatics.cpp | 79d29d92e0bf6d6df9416af9c60708bc906dbf88 | [
"MIT"
] | permissive | gaurav-algorythma/HQ | 93453ffa0ec1beeb02b4bd2885bd67cf405cce9b | 3d8b52e05d3f900d515ab59261a78d039ac422a4 | refs/heads/master | 2021-04-09T10:41:07.788776 | 2018-02-22T15:33:08 | 2018-02-22T15:33:08 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 4,003 | cpp | // DlgAnswerResultStatics.cpp : 实现文件
//
#include "stdafx.h"
#include "AgoraHQ.h"
#include "DlgAnswerResultStatics.h"
#include "afxdialogex.h"
#include "commonFun.h"
// CDlgAnswerResultStatics 对话框
IMPLEMENT_DYNAMIC(CDlgAnswerResultStatics, CDialogEx)
CDlgAnswerResultStatics::CDlgAnswerResultStatics(CWnd* pParent /*=NULL*/)
: CDialogEx(CDlgAnswerResultStatics::IDD, pParent)
{
}
CDlgAnswerResultStatics::~CDlgAnswerResultStatics()
{
}
void CDlgAnswerResultStatics::DoDataExchange(CDataExchange* pDX)
{
CDialogEx::DoDataExchange(pDX);
DDX_Control(pDX, IDC_LIST_ANSWER_STATICS, m_ltrResult);
}
BEGIN_MESSAGE_MAP(CDlgAnswerResultStatics, CDialogEx)
ON_BN_CLICKED(IDC_BUTTON_SAVE, &CDlgAnswerResultStatics::OnBnClickedButtonSave)
ON_BN_CLICKED(IDC_BUTTON_CANCLE, &CDlgAnswerResultStatics::OnBnClickedButtonCancle)
END_MESSAGE_MAP()
// CDlgAnswerResultStatics 消息处理程序
BOOL CDlgAnswerResultStatics::OnInitDialog()
{
CDialogEx::OnInitDialog();
m_ltrResult.SetExtendedStyle(LVS_EX_GRIDLINES | LVS_EX_FULLROWSELECT);
LONG lStyle;
lStyle = GetWindowLong(m_ltrResult.m_hWnd, GWL_STYLE);
lStyle &= ~LVS_TYPEMASK;
lStyle |= LVS_REPORT;
SetWindowLong(m_ltrResult.m_hWnd, GWL_STYLE, lStyle);
m_ltrResult.InsertColumn(0, _T("QuestionID"), LVCFMT_CENTER, 60);
m_ltrResult.InsertColumn(1, _T("Total"), LVCFMT_CENTER, 50);
m_ltrResult.InsertColumn(2, _T("Correct"), LVCFMT_CENTER, 50);
m_ltrResult.InsertColumn(3, _T("Wrong"), LVCFMT_CENTER, 50);
m_ltrResult.InsertColumn(4, _T("Answer"), LVCFMT_CENTER, 50);
m_ltrResult.InsertColumn(5, _T("A"), LVCFMT_CENTER, 50);
m_ltrResult.InsertColumn(6, _T("B"), LVCFMT_CENTER, 50);
m_ltrResult.InsertColumn(7, _T("C"), LVCFMT_CENTER, 50);
m_ltrResult.InsertColumn(8, _T("D"), LVCFMT_CENTER, 50);
m_ltrResult.InsertColumn(9, _T("rightPercent"), LVCFMT_CENTER, 75);
return TRUE;
}
void CDlgAnswerResultStatics::OnBnClickedButtonSave()
{
// TODO: 在此添加控件通知处理程序代码
CDialogEx::OnOK();
}
void CDlgAnswerResultStatics::OnBnClickedButtonCancle()
{
// TODO: 在此添加控件通知处理程序代码
CDialogEx::OnCancel();
}
void CDlgAnswerResultStatics::setContext(const tagQuestionStatics &questionStatics)
{
CString strQuestionId = s2cs(int2str(questionStatics.nsid + 1));
CString strTotal = s2cs(int2str(questionStatics.nTotal));
CString strCorrect = s2cs(int2str(questionStatics.ncorrectNum));
CString strWrong = s2cs(int2str(questionStatics.nTotal - questionStatics.ncorrectNum));
double dCorrertPercent = 0.0f;
if (questionStatics.nTotal)
double dCorrertPercent = 0.0f;
if (questionStatics.nTotal)
dCorrertPercent = 1.00 * (questionStatics.ncorrectNum) / (questionStatics.nTotal);
CString strCorrectPercent;
strCorrectPercent.Format(_T("%.2f"), dCorrertPercent);
ASSERT(5 > questionStatics.nresult);
CString strResutl;
if (0 == questionStatics.nresult){
strResutl = _T("A");
}
else if (1 == questionStatics.nresult){
strResutl = _T("B");
}
else if (2 == questionStatics.nresult){
strResutl = _T("C");
}
else if (3 == questionStatics.nresult){
strResutl = _T("D");
}
CString strAnswerA = s2cs(int2str(questionStatics.mapSpread.at("A")));
CString strAnswerB = s2cs(int2str(questionStatics.mapSpread.at("B")));
CString strAnswerC = s2cs(int2str(questionStatics.mapSpread.at("C")));
CString strAnswerD = s2cs(int2str(questionStatics.mapSpread.at("D")));
int nCount = m_ltrResult.GetItemCount();
m_ltrResult.InsertItem(nCount, _T(""));
m_ltrResult.SetItemText(nCount, 0, strQuestionId);
m_ltrResult.SetItemText(nCount, 1, strTotal);
m_ltrResult.SetItemText(nCount, 2, strCorrect);
m_ltrResult.SetItemText(nCount, 3, strWrong);
m_ltrResult.SetItemText(nCount, 4, strResutl);
m_ltrResult.SetItemText(nCount, 5, strAnswerA);
m_ltrResult.SetItemText(nCount, 6, strAnswerB);
m_ltrResult.SetItemText(nCount, 7, strAnswerC);
m_ltrResult.SetItemText(nCount, 8, strAnswerD);
m_ltrResult.SetItemText(nCount, 9, strCorrectPercent);
Invalidate(TRUE);
} | [
"[email protected]"
] | |
77fb9adf442e40881a6733c68b3cde5f6fd8aa77 | 07a87ad4aa358b7524d25bed4af776620aa56fa0 | /SCProjects/OpprimoBot/Source/Commander/UnitSetup.cpp | 09d554e2cd0124e9372b9b083e5071b5d2208e43 | [
"MIT"
] | permissive | jhagelback/OpprimoBot | 9a515dbacc3d22bd63d3a3ca869ebb1c7e81eed9 | 65eeb7e0c838e47df5027c8a746248bd30299640 | refs/heads/master | 2016-09-11T07:40:31.122742 | 2015-04-19T09:41:33 | 2015-04-19T09:41:33 | 34,200,025 | 20 | 7 | null | null | null | null | UTF-8 | C++ | false | false | 1,160 | cpp | #include "UnitSetup.h"
UnitSetup::UnitSetup()
{
}
bool UnitSetup::equals(UnitType mType)
{
return equals(type, mType);
}
bool UnitSetup::equals(UnitType t1, UnitType t2)
{
UnitType used1 = t1;
UnitType used2 = t2;
if (t1.getID() == UnitTypes::Terran_Siege_Tank_Siege_Mode) used1 = UnitTypes::Terran_Siege_Tank_Tank_Mode;
if (t2.getID() == UnitTypes::Terran_Siege_Tank_Siege_Mode) used2 = UnitTypes::Terran_Siege_Tank_Tank_Mode;
if (t1.getID() == UnitTypes::Zerg_Lurker) used1 = UnitTypes::Zerg_Hydralisk;
if (t2.getID() == UnitTypes::Zerg_Lurker) used2 = UnitTypes::Zerg_Hydralisk;
if (t1.getID() == UnitTypes::Zerg_Guardian) used1 = UnitTypes::Zerg_Mutalisk;
if (t2.getID() == UnitTypes::Zerg_Guardian) used2 = UnitTypes::Zerg_Mutalisk;
if (t1.getID() == UnitTypes::Zerg_Devourer) used1 = UnitTypes::Zerg_Mutalisk;
if (t2.getID() == UnitTypes::Zerg_Devourer) used2 = UnitTypes::Zerg_Mutalisk;
if (t1.getID() == UnitTypes::Protoss_High_Templar) used1 = UnitTypes::Protoss_Archon;
if (t2.getID() == UnitTypes::Protoss_High_Templar) used2 = UnitTypes::Protoss_Archon;
if (used1.getID() == used2.getID())
{
return true;
}
return false;
}
| [
"[email protected]"
] | |
b0035b3433067ebf13069794d18e8ea1838cf3dc | 94db0bd95a58fabfd47517ed7d7d819a542693cd | /client/ClientRes/IOSAPI/Classes/Native/mscorlib_System_Collections_Generic_Dictionary_2_V1183099139.h | 5af9912abbb10fcad8401ecb6a96066a179471b4 | [] | no_license | Avatarchik/card | 9fc6efa058085bd25f2b8831267816aa12b24350 | d18dbc9c7da5cf32c963458ac13731ecfbf252fa | refs/heads/master | 2020-06-07T07:01:00.444233 | 2017-12-11T10:52:17 | 2017-12-11T10:52:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,276 | h | #pragma once
#include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
#include "mscorlib_System_ValueType3507792607.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_En816591077.h"
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<GameEventTypes,System.Object>
struct Enumerator_t1183099139
{
public:
// System.Collections.Generic.Dictionary`2/Enumerator<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator::host_enumerator
Enumerator_t816591077 ___host_enumerator_0;
public:
inline static int32_t get_offset_of_host_enumerator_0() { return static_cast<int32_t>(offsetof(Enumerator_t1183099139, ___host_enumerator_0)); }
inline Enumerator_t816591077 get_host_enumerator_0() const { return ___host_enumerator_0; }
inline Enumerator_t816591077 * get_address_of_host_enumerator_0() { return &___host_enumerator_0; }
inline void set_host_enumerator_0(Enumerator_t816591077 value)
{
___host_enumerator_0 = value;
}
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"1"
] | 1 |
c7cb4f258d5bfe6519928b8f967972b439a0d95c | 1341ebf56cee66f15431236c74e8bb1db02558ac | /content/browser/message_port_unittest.cc | 486efb77db0a55d3fe9486da7d06a124f60ec86e | [
"BSD-3-Clause"
] | permissive | nerdooit/chromium | 41584349b52e0b941ec45ebb5ba5695268e5872f | de77d445d3428ef72455c3b0d9be7e050d447135 | refs/heads/master | 2023-01-11T20:03:40.846099 | 2020-01-25T12:45:08 | 2020-01-25T12:45:08 | 236,195,538 | 1 | 0 | BSD-3-Clause | 2020-01-25T16:25:12 | 2020-01-25T16:25:11 | null | UTF-8 | C++ | false | false | 5,182 | cc | // Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/public/browser/message_port.h"
#include "base/run_loop.h"
#include "base/strings/string16.h"
#include "base/strings/utf_string_conversions.h"
#include "base/test/task_environment.h"
#include "testing/gmock/include/gmock/gmock.h"
#include "testing/gtest/include/gtest/gtest.h"
namespace content {
namespace {
using Message = MessagePort::Message;
class LenientMockReceiver : public MessagePort::MessageReceiver {
public:
LenientMockReceiver() = default;
~LenientMockReceiver() override = default;
// MessagePort::MessageReceiver implementation:
MOCK_METHOD1(OnMessage, bool(Message));
MOCK_METHOD0(OnPipeError, void());
};
using MockReceiver = testing::StrictMock<LenientMockReceiver>;
using testing::_;
using testing::Invoke;
} // namespace
TEST(MessagePortTest, EndToEnd) {
base::test::SingleThreadTaskEnvironment task_env;
// Create a dummy pipe and ensure it behaves as expected.
MessagePort port0;
EXPECT_FALSE(port0.IsValid());
EXPECT_FALSE(port0.is_errored());
EXPECT_TRUE(port0.is_closed());
EXPECT_FALSE(port0.is_transferable());
EXPECT_FALSE(port0.HasReceiver());
EXPECT_FALSE(port0.CanPostMessage());
// Create a pipe.
auto pipe = MessagePort::CreatePair();
port0 = std::move(pipe.first);
MessagePort port1 = std::move(pipe.second);
EXPECT_TRUE(port0.IsValid());
EXPECT_FALSE(port0.is_errored());
EXPECT_FALSE(port0.is_closed());
EXPECT_TRUE(port0.is_transferable());
EXPECT_FALSE(port0.HasReceiver());
EXPECT_FALSE(port0.CanPostMessage());
EXPECT_TRUE(port1.IsValid());
EXPECT_FALSE(port1.is_errored());
EXPECT_FALSE(port1.is_closed());
EXPECT_TRUE(port1.is_transferable());
EXPECT_FALSE(port1.HasReceiver());
EXPECT_FALSE(port1.CanPostMessage());
// And bind both endpoints to distinct receivers. The ports should remain
// valid but no longer be transferable.
MockReceiver receiver0;
MockReceiver receiver1;
port0.SetReceiver(&receiver0, task_env.GetMainThreadTaskRunner());
port1.SetReceiver(&receiver1, task_env.GetMainThreadTaskRunner());
EXPECT_TRUE(port0.IsValid());
EXPECT_FALSE(port0.is_errored());
EXPECT_FALSE(port0.is_closed());
EXPECT_FALSE(port0.is_transferable());
EXPECT_TRUE(port0.HasReceiver());
EXPECT_TRUE(port0.CanPostMessage());
EXPECT_TRUE(port1.IsValid());
EXPECT_FALSE(port1.is_errored());
EXPECT_FALSE(port1.is_closed());
EXPECT_FALSE(port1.is_transferable());
EXPECT_TRUE(port1.HasReceiver());
EXPECT_TRUE(port1.CanPostMessage());
// Send a simple string-only message one way from port 0 to port 1.
base::string16 message(base::UTF8ToUTF16("foo"));
{
base::RunLoop run_loop;
EXPECT_CALL(receiver1, OnMessage(_))
.WillOnce(
Invoke([&message, &run_loop](Message&& received_message) -> bool {
EXPECT_EQ(message, received_message.data);
EXPECT_TRUE(received_message.ports.empty());
run_loop.Quit();
return true;
}));
port0.PostMessage(Message(message));
run_loop.Run();
testing::Mock::VerifyAndClearExpectations(&receiver0);
testing::Mock::VerifyAndClearExpectations(&receiver1);
}
// Send a message the other way (from 1 to 0) with a port.
auto pipe2 = MessagePort::CreatePair();
{
base::RunLoop run_loop;
EXPECT_CALL(receiver0, OnMessage(_))
.WillOnce(
Invoke([&message, &run_loop](Message&& received_message) -> bool {
EXPECT_EQ(message, received_message.data);
EXPECT_EQ(1u, received_message.ports.size());
run_loop.Quit();
return true;
}));
port1.PostMessage(Message(message, std::move(pipe2.first)));
run_loop.Run();
testing::Mock::VerifyAndClearExpectations(&receiver0);
testing::Mock::VerifyAndClearExpectations(&receiver1);
}
// Close one end of the pipe and expect the other end to get an error.
{
base::RunLoop run_loop;
EXPECT_CALL(receiver1, OnPipeError()).WillOnce(Invoke([&run_loop]() {
run_loop.Quit();
}));
port0.Close();
EXPECT_FALSE(port0.IsValid());
EXPECT_FALSE(port0.is_errored());
EXPECT_TRUE(port0.is_closed());
EXPECT_FALSE(port0.is_transferable());
EXPECT_FALSE(port0.HasReceiver());
EXPECT_FALSE(port0.CanPostMessage());
run_loop.Run();
EXPECT_TRUE(port1.IsValid());
EXPECT_TRUE(port1.is_errored());
EXPECT_FALSE(port1.is_closed());
EXPECT_FALSE(port1.is_transferable());
EXPECT_TRUE(port1.HasReceiver());
EXPECT_FALSE(port1.CanPostMessage());
testing::Mock::VerifyAndClearExpectations(&receiver0);
testing::Mock::VerifyAndClearExpectations(&receiver1);
}
// Reset the pipe and expect it to go back to a fully default state.
port1.Reset();
EXPECT_FALSE(port1.IsValid());
EXPECT_FALSE(port1.is_errored());
EXPECT_TRUE(port1.is_closed());
EXPECT_FALSE(port1.is_transferable());
EXPECT_FALSE(port1.HasReceiver());
EXPECT_FALSE(port1.CanPostMessage());
}
} // namespace content
| [
"[email protected]"
] | |
c7fbe6d9162e1c6055034914517399bf30ab6b77 | 3d14bed25bf61c150de8c7cb45b34e61dafd36d9 | /src/protokoll/paket/PaketC9PlayerListItem.cpp | 69d3f0a76c27765387ebae19900a52f31b495c0c | [] | no_license | ulisesarturo/WiiCraft | 63ee72c0a692b38358475877d80226115208c14d | 29aeb6d6fb21d02bd30ddd281ebd0080dced57c0 | refs/heads/master | 2021-01-14T11:32:22.699949 | 2014-04-28T20:13:55 | 2014-04-28T20:13:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,087 | cpp | /* Copyright (c) 2012, Kose Alexander
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are met:
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
* 3. All advertising materials mentioning features or use of this software
* must display the following acknowledgement:
* This product includes software developed by Kose Alexander.
* 4. Neither the name of Kose Alexander nor the
* names of its contributors may be used to endorse or promote products
* derived from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY KOSE ALEXANDER ''AS IS'' AND ANY
* EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
* WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
* DISCLAIMED. IN NO EVENT SHALL KOSE ALEXANDER BE LIABLE FOR ANY
* DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
* (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
* ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
* (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*/
#include "PaketC9PlayerListItem.h"
#include <cstdio>
#include "../../net/DataInputStream.h"
#include "../../exception/ExcSocketStringLaengeUeberschritten.h"
#include "../ServerInfo.h"
#include "../PaketManager.h"
#include "../../util/Debug.h"
using namespace std;
PaketC9PlayerListItem::PaketC9PlayerListItem() {
PaketServer::id = 0xc9;
PaketServer::prio = 50;
}
PaketServer *PaketC9PlayerListItem::gebeInstanz() {
return new PaketC9PlayerListItem();
}
bool PaketC9PlayerListItem::registierePaket() {
PaketManager::registrierePaket(new PaketC9PlayerListItem());
return true;
}
void PaketC9PlayerListItem::lesePaketInhalt(DataInputStream *in) {
try {
this->playerName = in->leseString(16);
} catch (ExcSocketStringLaengeUeberschritten &exception) {
throw ExcSocketStringLaengeUeberschritten(PaketServer::id);
}
this->online = in->leseBoolean();
this->ping = in->leseShort();
}
void PaketC9PlayerListItem::verarbeitePaket() {
ServerInfo::gebeServerInfo()->aktualisiereSpielerStatus(this->playerName,
this->online, this->ping);
#ifdef DEBUG_ON
char *buffer = new char[100];
sprintf(buffer, "spieler: %s, online: %i, ping: %i",
this->playerName.data(), this->online, this->ping);
Debug::schreibePaketLog("PaketC9PlayerListItem", buffer);
delete[] buffer;
#endif
}
| [
"[email protected]"
] | |
f497e66c850a69f3163249a6787880d316f0e051 | ed1e56663558d952668c3590b9f05bcbeb994aa5 | /Source/Utility.h | 5df638caa6f1823683d1ad57fd850d67e978e60b | [
"Apache-2.0"
] | permissive | ArchRobison/Voromoeba | f33dc3fa0c264c42bb9063cac38a2570805d1fd5 | 608aeebd03f955a2180d05f310de6097c3df0c69 | refs/heads/main | 2023-02-05T13:27:21.644361 | 2021-01-02T20:39:06 | 2021-01-02T20:39:06 | 323,153,416 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,391 | h | /* Copyright 1996-2021 Arch D. Robison
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
*/
/******************************************************************************
Utility functions for Seismic Duck and Voromoeba
*******************************************************************************/
#ifndef UTILITY_H
#define UTILITY_H
#include <cstdlib>
#include <cstdint>
#include <initializer_list>
#include <limits>
#include "AssertLib.h"
typedef uint8_t byte;
//! Return minimum of two values.
template<typename T>
inline T Min(const T& a, const T& b) {
return a<b ? a : b;
}
//! Return maximum of two values.
template<typename T>
inline T Max(const T& a, const T& b) {
return a<b ? b : a;
}
//! Return x clipped to closed interval [a,b]
template<typename T>
inline T Clip(T a, T b, T x) {
Assert(!(b<a));
return x<a ? a : b<x ? b : x;
}
inline int Round(float x) { // FIXME - add SSE version
x += x<0 ? -0.5f : 0.5f;
return int(x);
}
inline int Ceiling(float x) { // FIXME - add SSE version
int t = int(x);
if (x>0 && x!=t) ++t;
return t;
}
inline int Floor(float x) { // FIXME - add SSE version
int t = int(x);
if (x<0 && x!=t) --t;
return t;
}
inline float Square(float z) {
return z*z;
}
//! Return true if z is an IEEE "Infinity"
inline bool IsInfinity(float z) {
return z==std::numeric_limits<float>::infinity();
}
//! Return random integer in [0,a)
uint32_t RandomUInt(uint32_t a);
//! Return random real in [0,a)
float RandomFloat(float a);
template<typename T>
constexpr T Pi = static_cast<T>(3.141592653589793);
//! Return random angle
inline float RandomAngle() {
return RandomFloat(2*Pi<float>);
}
//! Base class for non-copiable non-assignable classes
class NoCopy {
NoCopy(const NoCopy&) = delete;
void operator=(const NoCopy&) = delete;
public:
NoCopy() {}
};
//! No-frills array class
//!
//! Extra is number of additional elements to add beyond reported size.
//! These additional elements may be accessed via operator[],
//! even though they are beyond the reported size.
//! E.g., AdditiveSynthesizer uses Extra=1 to simplify logic.
template<typename T, size_t Extra=0>
class SimpleArray : NoCopy {
T* myStart;
size_t mySize;
public:
SimpleArray() : myStart(0), mySize(0) {}
SimpleArray(size_t n) {
myStart = new T[n+Extra];
mySize = n;
}
~SimpleArray() { clear(); }
size_t size() const { return mySize; }
void clear() {
if (myStart) {
delete[] myStart;
myStart = nullptr;
mySize = 0;
}
}
void resize(size_t n) {
clear();
if (n+Extra>0) {
myStart = new T[n+Extra];
mySize = n;
}
}
template<typename U>
void assign(const U* array, size_t count) {
clear();
if (count>0) {
myStart = new T[count+Extra];
for (size_t i=0; i<count; ++i)
myStart[i] = array[i];
mySize = count;
}
}
void fill(const T& value) {
for (size_t i=0; i<mySize; ++i)
myStart[i] = value;
}
T* begin() { return myStart; }
const T* begin() const { return myStart; }
T* end() { return myStart+mySize; }
const T* end() const { return myStart+mySize; }
//! Subscript is checked against size()+Extra.
T& operator[](size_t k) {
Assert(k<mySize+Extra);
return myStart[k];
}
const T& operator[](size_t k) const {
Assert(k<mySize+Extra);
return myStart[k];
}
};
//! No-frills bag class
template<typename T>
class SimpleBag {
T* myBegin;
T* myEnd;
T* myLimit;
public:
//! Create bag and reserve space for maxSize items.
SimpleBag(size_t maxSize) {
myEnd = myBegin = (T*)operator new(sizeof(T)*maxSize);
myLimit = myBegin + maxSize;
}
~SimpleBag() {
operator delete(myBegin);
}
//! True if bag is empty.
bool isEmpty() {
Assert(myBegin<=myEnd);
return myEnd==myBegin;
}
//! Pop item from end of bag
void pop(T& dst) {
Assert(!isEmpty());
dst = *--myEnd;
myEnd->~T();
}
//! Add item to end of bag. Number of items must not exceed maxSize specified by constructor.
void push(T i) {
Assert(myEnd<myLimit);
new(myEnd++) T(i);
}
typedef T* iterator;
iterator begin() { return myBegin; }
iterator end() { return myEnd; }
//! Erase *i. Afterwards i points to the next unvisited item.
void erase(iterator i) {
Assert(myBegin<=i && i<myEnd);
pop(*i);
}
};
#endif /* UTILITY_H */ | [
"[email protected]"
] | |
b7c6539b07bb27323405124ca22716a59d7cdacc | adf0421f9256480923bf0e084b5b158fb8a2a652 | /Tree/515.FindLargestValueInEachTreeRow_找到树每行的最大值.cpp | 6a974c4b999e6fa8d6abe157ab2b6b8bebf3beb0 | [] | no_license | XAlearnerer/LeetCode | d5c6ac850fb73766639e730d0ed9a962166d07a2 | 6bbdac1ccd8e30ba48747877e2f34b5ca97ce844 | refs/heads/master | 2020-04-01T01:30:37.673708 | 2019-10-15T02:38:22 | 2019-10-15T02:38:22 | 152,741,487 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 698 | cpp | #include<iostream>
#include<algorithm>
#include<vector>
#include<unordered_map>
#include<queue>
using namespace std;
struct TreeNode {
int val;
TreeNode *left;
TreeNode *right;
TreeNode(int x) : val(x), left(NULL), right(NULL) {}
};
class Solution {
public:
vector<int> largestValues(TreeNode* root) {
queue<TreeNode*> q;
if (!root) return {};
vector<int> res;
q.push(root);
while (!q.empty())
{
int size = q.size();
int m = INT_MIN;
for (int i = 0; i != size; ++i)
{
TreeNode* t = q.front();
q.pop();
if (t->val > m) m = t->val;
if (t->left) q.push(t->left);
if (t->right) q.push(t->right);
}
res.push_back(m);
}
return res;
}
};
| [
"[email protected]"
] | |
11f5cd07fe0a5e44e92dcedb40eb845298b67678 | bb6ebff7a7f6140903d37905c350954ff6599091 | /content/renderer/clipboard_client.h | 7f1b2dcfdff07c2058c178d8b44a2a1c6129c123 | [
"BSD-3-Clause"
] | permissive | PDi-Communication-Systems-Inc/lollipop_external_chromium_org | faa6602bd6bfd9b9b6277ce3cd16df0bd26e7f2f | ccadf4e63dd34be157281f53fe213d09a8c66d2c | refs/heads/master | 2022-12-23T18:07:04.568931 | 2016-04-11T16:03:36 | 2016-04-11T16:03:36 | 53,677,925 | 0 | 1 | BSD-3-Clause | 2022-12-09T23:46:46 | 2016-03-11T15:49:07 | C++ | UTF-8 | C++ | false | false | 2,922 | h | // Copyright (c) 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef CONTENT_RENDERER_CLIPBOARD_CLIENT_H_
#define CONTENT_RENDERER_CLIPBOARD_CLIENT_H_
#include "content/common/clipboard_format.h"
#include "ui/base/clipboard/clipboard.h"
class GURL;
namespace content {
// Interface for the content embedder to implement to support clipboard.
class ClipboardClient {
public:
class WriteContext {
public:
virtual ~WriteContext() { }
// Writes bitmap data into the context, updating the ObjectMap.
virtual void WriteBitmapFromPixels(ui::Clipboard::ObjectMap* objects,
const void* pixels,
const gfx::Size& size) = 0;
// Flushes all gathered data.
virtual void Flush(const ui::Clipboard::ObjectMap& objects) = 0;
};
virtual ~ClipboardClient() { }
// Get a clipboard that can be used to construct a ScopedClipboardWriterGlue.
virtual ui::Clipboard* GetClipboard() = 0;
// Get a sequence number which uniquely identifies clipboard state.
virtual uint64 GetSequenceNumber(ui::ClipboardType type) = 0;
// Tests whether the clipboard contains a certain format
virtual bool IsFormatAvailable(ClipboardFormat format,
ui::ClipboardType type) = 0;
// Clear the contents of the clipboard.
virtual void Clear(ui::ClipboardType type) = 0;
// Reads the available types from the clipboard, if available.
virtual void ReadAvailableTypes(ui::ClipboardType type,
std::vector<base::string16>* types,
bool* contains_filenames) = 0;
// Reads text from the clipboard, trying UNICODE first, then falling back to
// ASCII.
virtual void ReadText(ui::ClipboardType type,
base::string16* result) = 0;
// Reads HTML from the clipboard, if available.
virtual void ReadHTML(ui::ClipboardType type,
base::string16* markup,
GURL* url,
uint32* fragment_start,
uint32* fragment_end) = 0;
// Reads RTF from the clipboard, if available.
virtual void ReadRTF(ui::ClipboardType type, std::string* result) = 0;
// Reads and image from the clipboard, if available.
virtual void ReadImage(ui::ClipboardType type, std::string* data) = 0;
// Reads a custom data type from the clipboard, if available.
virtual void ReadCustomData(ui::ClipboardType clipboard_type,
const base::string16& type,
base::string16* data) = 0;
// Creates a context to write clipboard data. May return NULL.
virtual WriteContext* CreateWriteContext() = 0;
};
} // namespace content
#endif // CONTENT_RENDERER_CLIPBOARD_CLIENT_H_
| [
"[email protected]"
] | |
6b62deb448239620c2bbc302127f56dc88ea90f0 | b4fc1d5e44b4d9201ece21844c143a135c6f553a | /ListaRecursivo/Exercicio2/cubo.h | ce43c9b1d34081d66040f6ebbfeb99ad348c4409 | [] | no_license | liaoliveiralps/estrutura-de-dados-1 | 16f693ff4a21874c6214d65f0d1384e9ba292664 | 077eb69c99fd4b7992a1594e362a137487d7cc87 | refs/heads/main | 2023-03-04T22:20:04.729694 | 2021-02-18T14:21:04 | 2021-02-18T14:21:04 | 340,073,428 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 206 | h | #ifndef FATORIAL_H
#define FATORIAL_H
namespace lia{
class Cubo
{
public:
long unsigned int cuboRecursive(unsigned int x);
long unsigned int cuboIterative(unsigned int x);
};
}
#endif // FATORIAL_H
| [
"[email protected]"
] | |
581168ac706da641d9aaf55defdf5077ceca41f3 | a28ccadc85e1d356743f5f23b7a9945c7e3ee20f | /OpenCVNetwork/src/main/c++/native/network/properties/TCPPacketClient.cpp | b838c14b0cac0c970908990c8446aff227c436bf | [
"MIT"
] | permissive | hesitationer/OpenCVClient | 2e8b2db538c92a05f3a62e5b78d04a1d23a44885 | a7119b1b108b8f15090751218851b8852241d274 | refs/heads/master | 2021-06-11T22:29:49.622612 | 2017-03-09T19:37:57 | 2017-03-09T19:37:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,272 | cpp | //
// Created by dialight on 01.11.16.
//
#include "network/properties/PropertiesClient.hpp"
#include <network/exceptions/IOException.hpp>
TCPPacketClient::TCPPacketClient() : TCPSocketClient() {
}
void TCPPacketClient::registerInPacketHandler(InPacketHandler handler, void *args) {
this->inHandler = handler;
this->inArgs = args;
}
void TCPPacketClient::registerOutPacketHandler(OutPacketHandler handler, void *args) {
this->outHandler = handler;
this->outArgs = args;
}
void TCPPacketClient::setProtocol(Protocol *protocol) {
this->protocol = protocol;
}
void TCPPacketClient::sendPacket(OutPacket *packet) {
std::lock_guard<std::mutex> lock(this->writeLock);
outHandler(packet, outArgs);
writeByte(packet->getId());
packet->write(this);
//lock_guard<mutex> destructor unlock writeLock
}
void TCPPacketClient::trySendPacket(OutPacket *packet) {
if (isConnected()) {
try {
sendPacket(packet); //thread safe
} catch (IOException e) {
e.printError();
close();
}
}
}
void TCPPacketClient::processPacket() {
int id = readByte();
InPacket *packet = protocol->newInstance(id);
packet->read(this);
inHandler(packet, inArgs);
delete packet;
} | [
"[email protected]"
] | |
40e6d87b27a715092ce08b7039ad44887c0e6fad | a50f88f8208c2a4f267a876f625f7179cfeafe24 | /GitHub Centipede/MyCentipede/Game Components/SpiderStateLeftDownDiagonal.cpp | 26d6d1c481d62af07196e83db2b5441c53dee1e9 | [] | no_license | The-Griffin-White/MyCentipedeProject | a9f02bd63b0be8544b510285ccfe737fed2da9b1 | 799c52525ec1c64eb861b5c70317edd5314919dc | refs/heads/master | 2021-08-23T03:07:09.813867 | 2017-12-02T20:26:00 | 2017-12-02T20:26:00 | 111,955,280 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 726 | cpp | #include "SpiderMovementCollection.h"
#include "Spider.h"
#include "SpiderMoveFSM.h"
#include "SpiderStateLeftDown.h"
#include "SpiderStateLeftDownDiagonal.h"
#include "SpiderStateLeftUp.h"
#include "SpiderStateLeftUpDiagonal.h"
SpiderStateLeftDownDiagonal::SpiderStateLeftDownDiagonal()
{
pMoveOffsets = &SpiderMovementCollection::OffsetsLeftDownDiagonal;
}
const SpiderState* SpiderStateLeftDownDiagonal::GetNextState(Spider *pSpider) const
{
const SpiderState* pNextState;
if (rand() % 2 == 1)
{
ConsoleMsg::WriteLine("StateLeftUpDiagonal");
pNextState = &SpiderMoveFSM::StateLeftUpDiagonal;
}
else
{
ConsoleMsg::WriteLine("StateLeftUp");
pNextState = &SpiderMoveFSM::StateLeftUp;
}
return pNextState;
} | [
"[email protected]"
] | |
79c523839c653513d846e4bdf06578217241adcb | 668021cea98489c49dceebcf5dc53f40b9a59f94 | /SportsmenClassificationIOS/Classes/Native/Generics.cpp | 8645abe664f25b6b5a1f82038f39b7f82b65895d | [] | no_license | vologiroff/Sportsmen-Classification-App | f9145c6bcd6af06a98128406652f96f34968afec | 5e8739b714559d5ddd62c950883ce75c7a3309e8 | refs/heads/master | 2023-01-07T06:52:15.653363 | 2020-11-04T20:26:24 | 2020-11-04T20:26:24 | 310,110,232 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,889,396 | cpp | #include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <cstring>
#include <string.h>
#include <stdio.h>
#include <cmath>
#include <limits>
#include <assert.h>
#include <stdint.h>
#include "codegen/il2cpp-codegen.h"
#include "il2cpp-object-internals.h"
template <typename R, typename T1, typename T2>
struct VirtFuncInvoker2
{
typedef R (*Func)(void*, T1, T2, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1, T2 p2)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
template <typename R, typename T1>
struct VirtFuncInvoker1
{
typedef R (*Func)(void*, T1, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename R>
struct VirtFuncInvoker0
{
typedef R (*Func)(void*, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename T1>
struct VirtActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
struct VirtActionInvoker0
{
typedef void (*Action)(void*, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeObject* obj)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
((Action)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename T1, typename T2>
struct VirtActionInvoker2
{
typedef void (*Action)(void*, T1, T2, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1, T2 p2)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
((Action)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
template <typename T1, typename T2, typename T3>
struct VirtActionInvoker3
{
typedef void (*Action)(void*, T1, T2, T3, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1, T2 p2, T3 p3)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
((Action)invokeData.methodPtr)(obj, p1, p2, p3, invokeData.method);
}
};
template <typename T1>
struct GenericVirtActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_virtual_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
struct GenericVirtActionInvoker0
{
typedef void (*Action)(void*, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_virtual_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename T1, typename T2>
struct GenericVirtActionInvoker2
{
typedef void (*Action)(void*, T1, T2, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1, T2 p2)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_virtual_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
template <typename T1, typename T2, typename T3>
struct GenericVirtActionInvoker3
{
typedef void (*Action)(void*, T1, T2, T3, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1, T2 p2, T3 p3)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_virtual_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, p2, p3, invokeData.method);
}
};
template <typename T1>
struct InterfaceActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj, T1 p1)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
struct InterfaceActionInvoker0
{
typedef void (*Action)(void*, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
((Action)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename T1, typename T2>
struct InterfaceActionInvoker2
{
typedef void (*Action)(void*, T1, T2, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj, T1 p1, T2 p2)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
((Action)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
template <typename T1, typename T2, typename T3>
struct InterfaceActionInvoker3
{
typedef void (*Action)(void*, T1, T2, T3, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj, T1 p1, T2 p2, T3 p3)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
((Action)invokeData.methodPtr)(obj, p1, p2, p3, invokeData.method);
}
};
template <typename T1>
struct GenericInterfaceActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_interface_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
struct GenericInterfaceActionInvoker0
{
typedef void (*Action)(void*, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_interface_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename T1, typename T2>
struct GenericInterfaceActionInvoker2
{
typedef void (*Action)(void*, T1, T2, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1, T2 p2)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_interface_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
template <typename T1, typename T2, typename T3>
struct GenericInterfaceActionInvoker3
{
typedef void (*Action)(void*, T1, T2, T3, const RuntimeMethod*);
static inline void Invoke (const RuntimeMethod* method, RuntimeObject* obj, T1 p1, T2 p2, T3 p3)
{
VirtualInvokeData invokeData;
il2cpp_codegen_get_generic_interface_invoke_data(method, obj, &invokeData);
((Action)invokeData.methodPtr)(obj, p1, p2, p3, invokeData.method);
}
};
// <>f__AnonymousType0`1<System.Object>
struct U3CU3Ef__AnonymousType0_1_t103DB909F3478F55EAABC0751EA7624561E5B35F;
// System.Action`1<System.Boolean>
struct Action_1_t6036B3C6D9E897E6266019A987CFC19CFC59CB64;
// System.Action`1<System.Guid>
struct Action_1_t914484DED737548EE8FABFA959036371C8235942;
// System.Action`1<System.Object>
struct Action_1_t551A279CEADCF6EEAE8FA2B1E1E757D0D15290D0;
// System.Action`1<System.Threading.AsyncLocalValueChangedArgs`1<System.Object>>
struct Action_1_tC9C78235CE090A8C814E2C458627F15C33AF0180;
// System.Action`2<System.Boolean,System.Object>
struct Action_2_t6C33D80670016FFA10F03F59FB542306FA60F1F3;
// System.Action`2<System.Char,System.Object>
struct Action_2_t2F784F6A8F0E6D7B6C7C73DCA17B1CCA8D724E48;
// System.Action`2<System.Int32,System.Int32>
struct Action_2_t5B6D9846A42CF1FAF7059138EA4A212815F00916;
// System.Action`2<System.Int32,System.Int64>
struct Action_2_tC52FA3FD223419FC0456E089309277012CCE38E8;
// System.Action`2<System.Object,System.Boolean>
struct Action_2_t429E4750D84EBAC7EB494EB565EE0C8E1177C576;
// System.Action`2<System.Object,System.Int32Enum>
struct Action_2_t4A92D51BAC0CF291CCBECDD41B622EDAE4E77D9F;
// System.Action`2<System.Object,System.Object>
struct Action_2_t0DB6FD6F515527EAB552B690A291778C6F00D48C;
// System.Action`3<System.Object,System.Boolean,UnityEngine.Profiling.Experimental.DebugScreenCapture>
struct Action_3_t5EE4F8B9C50F576C16A8CE302D8F2790394C22EA;
// System.Action`3<System.Object,System.Object,System.Object>
struct Action_3_tCC14115B7178951118504E7198B7C872630643C5;
// System.Array/EmptyInternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>
struct EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F;
// System.Array/EmptyInternalEnumerator`1<System.Boolean>
struct EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8;
// System.Array/EmptyInternalEnumerator`1<System.Byte>
struct EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A;
// System.Array/EmptyInternalEnumerator`1<System.Char>
struct EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD;
// System.Array/EmptyInternalEnumerator`1<System.Collections.DictionaryEntry>
struct EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Int32,System.Object>>
struct EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Int32>>
struct EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Object>>
struct EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Resources.ResourceLocator>>
struct EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.UInt64,System.Object>>
struct EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Generic.HashSet`1/Slot<System.Object>>
struct EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>
struct EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>
struct EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>
struct EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>
struct EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>
struct EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>
struct EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>
struct EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>
struct EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007;
// System.Array/EmptyInternalEnumerator`1<System.Collections.Hashtable/bucket>
struct EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F;
// System.Array/EmptyInternalEnumerator`1<System.DateTime>
struct EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0;
// System.Array/EmptyInternalEnumerator`1<System.Decimal>
struct EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29;
// System.Array/EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventProvider/SessionInfo>
struct EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB;
// System.Array/EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventSource/EventMetadata>
struct EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82;
// System.Array/EmptyInternalEnumerator`1<System.Double>
struct EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0;
// System.Array/EmptyInternalEnumerator`1<System.Globalization.InternalCodePageDataItem>
struct EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81;
// System.Array/EmptyInternalEnumerator`1<System.Globalization.InternalEncodingDataItem>
struct EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3;
// System.Array/EmptyInternalEnumerator`1<System.Guid>
struct EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455;
// System.Array/EmptyInternalEnumerator`1<System.Int16>
struct EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611;
// System.Array/EmptyInternalEnumerator`1<System.Int32>
struct EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89;
// System.Array/EmptyInternalEnumerator`1<System.Int32Enum>
struct EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B;
// System.Array/EmptyInternalEnumerator`1<System.Int64>
struct EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0;
// System.Array/EmptyInternalEnumerator`1<System.IntPtr>
struct EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C;
// System.Array/EmptyInternalEnumerator`1<System.Object>
struct EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A;
// System.Array/EmptyInternalEnumerator`1<System.ParameterizedStrings/FormatParam>
struct EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C;
// System.Array/EmptyInternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>
struct EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666;
// System.Array/EmptyInternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>
struct EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B;
// System.Array/EmptyInternalEnumerator`1<System.Reflection.ParameterModifier>
struct EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00;
// System.Array/EmptyInternalEnumerator`1<System.Resources.ResourceLocator>
struct EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551;
// System.Array/EmptyInternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>
struct EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38;
// System.Array/EmptyInternalEnumerator`1<System.Runtime.InteropServices.GCHandle>
struct EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC;
// System.Array/EmptyInternalEnumerator`1<System.SByte>
struct EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343;
// System.Array/EmptyInternalEnumerator`1<System.Single>
struct EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236;
// System.Array/EmptyInternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping>
struct EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4;
// System.Array/EmptyInternalEnumerator`1<System.Threading.CancellationTokenRegistration>
struct EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF;
// System.Array/EmptyInternalEnumerator`1<System.TimeSpan>
struct EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6;
// System.Array/EmptyInternalEnumerator`1<System.UInt16>
struct EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611;
// System.Array/EmptyInternalEnumerator`1<System.UInt32>
struct EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6;
// System.Array/EmptyInternalEnumerator`1<System.UInt64>
struct EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD;
// System.Array/EmptyInternalEnumerator`1<System.UIntPtr>
struct EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.BeforeRenderHelper/OrderBlock>
struct EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.Color32>
struct EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>
struct EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>
struct EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.Keyframe>
struct EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>
struct EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.Plane>
struct EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.Playables.PlayableBinding>
struct EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.RaycastHit2D>
struct EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.RaycastHit>
struct EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.Rendering.BatchVisibility>
struct EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.SendMouseEvents/HitInfo>
struct EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcAchievementData>
struct EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcScoreData>
struct EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.UI.ColorBlock>
struct EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.UI.Navigation>
struct EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.UI.SpriteState>
struct EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.UICharInfo>
struct EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.UILineInfo>
struct EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.UIVertex>
struct EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.UnitySynchronizationContext/WorkRequest>
struct EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.Vector2>
struct EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.Vector3>
struct EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC;
// System.Array/EmptyInternalEnumerator`1<UnityEngine.Vector4>
struct EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281;
// System.AsyncCallback
struct AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4;
// System.Boolean[]
struct BooleanU5BU5D_t192C7579715690E25BD5EFED47F3E0FC9DCB2040;
// System.Byte[]
struct ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821;
// System.Char[]
struct CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2;
// System.Collections.Generic.EqualityComparer`1<System.Object>
struct EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA;
// System.Collections.IDictionary
struct IDictionary_t1BD5C1546718A374EA8122FBD6C6EE45331E8CE7;
// System.Delegate
struct Delegate_t;
// System.DelegateData
struct DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE;
// System.Delegate[]
struct DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86;
// System.Diagnostics.StackTrace[]
struct StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196;
// System.Diagnostics.Tracing.TraceLoggingEventTypes
struct TraceLoggingEventTypes_t9CC0B45F554DBE11BA54227A704E1AC027E5DD25;
// System.IAsyncResult
struct IAsyncResult_t8E194308510B375B42432981AE5E7488C458D598;
// System.IFormatProvider
struct IFormatProvider_t4247E13AE2D97A079B88D594B7ABABF313259901;
// System.Int32[]
struct Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83;
// System.IntPtr[]
struct IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD;
// System.InvalidOperationException
struct InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1;
// System.Object[]
struct ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A;
// System.Reflection.MemberInfo
struct MemberInfo_t;
// System.Reflection.MethodInfo
struct MethodInfo_t;
// System.Reflection.ParameterInfo[]
struct ParameterInfoU5BU5D_t9F6F38E4A0B0A78E2F463D1B2C0031716CA7A694;
// System.Runtime.Serialization.SafeSerializationManager
struct SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770;
// System.Security.Cryptography.RandomNumberGenerator
struct RandomNumberGenerator_t12277F7F965BA79C54E4B3BFABD27A5FFB725EE2;
// System.String
struct String_t;
// System.Threading.CancellationCallbackInfo
struct CancellationCallbackInfo_t8CDEA0AA9C9D1A2321FE2F88878F4B5E0901CF36;
// System.Threading.ManualResetEvent
struct ManualResetEvent_tDFAF117B200ECA4CCF4FD09593F949A016D55408;
// System.Threading.SendOrPostCallback
struct SendOrPostCallback_t3F9C0164860E4AA5138DF8B4488DFB0D33147F01;
// System.Threading.SparselyPopulatedArrayFragment`1<System.Threading.CancellationCallbackInfo>
struct SparselyPopulatedArrayFragment_1_tA54224D01E2FDC03AC2867CDDC8C53E17FA933D7;
// System.Type
struct Type_t;
// System.UInt32[]
struct UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB;
// System.Void
struct Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017;
// UnityEngine.Camera
struct Camera_t48B2B9ECB3CE6108A98BF949A1CECF0FE3421F34;
// UnityEngine.EventSystems.BaseRaycaster
struct BaseRaycaster_tC7F6105A89F54A38FBFC2659901855FDBB0E3966;
// UnityEngine.Events.UnityAction
struct UnityAction_tD19B26F1B2C048E38FD5801A33573BE01064CAF4;
// UnityEngine.GameObject
struct GameObject_tBD1244AD56B4E59AAD76E5E7C9282EC5CE434F0F;
// UnityEngine.LowLevel.PlayerLoopSystem/UpdateFunction
struct UpdateFunction_tD84FFC4AEE25C3DEBD3AB85700E096090FC7995E;
// UnityEngine.LowLevel.PlayerLoopSystem[]
struct PlayerLoopSystemU5BU5D_tA93C9CA08EF430375F9D4356DD0963BAEE961B77;
// UnityEngine.Object
struct Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0;
// UnityEngine.Playables.PlayableBinding/CreateOutputMethod
struct CreateOutputMethod_tA7B649F49822FC5DD0B0D9F17247C73CAECB1CA3;
// UnityEngine.Playables.PlayableBinding[]
struct PlayableBindingU5BU5D_t7EB322901D51EAB67BA4F711C87F3AC1CF5D89AB;
// UnityEngine.Sprite
struct Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198;
// UnityEngine.UI.Selectable
struct Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A;
IL2CPP_EXTERN_C RuntimeClass* AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Boolean_tB53F6830F670160873277339AA58F15CAED4399C_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Guid_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Int32Enum_t6312CE4586C17FE2E2E513D2E7655B574F10FDCD_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Int64_t7A386C2FF7B0280A0F516992401DDFCF0FF7B436_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C String_t* _stringLiteral2743196813A5635EC097418239BD515966A50491;
IL2CPP_EXTERN_C String_t* _stringLiteral5858A25A11472FD4CFA2597DDB1EFF89706B5707;
IL2CPP_EXTERN_C String_t* _stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m04B5C2FD10B42EA5CD3BBE88C3B8E1AF021CD27D_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m07E77FDBFD58E5EE65287D586B1E09E258371140_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m0C60BE6EA74588A46F15051C3259341BDCB8F58A_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m0CABA4EE26CC086C7D8C239B67A07B4890E7C8EC_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m0FB286FD156C69E50C98EDD6ADF037DC6A46D771_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m165DF603BD5CC24DD7D73981775AAEE1DF235094_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m17E39F6C3ADB920CA93850D89890D0E47C36592D_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m1868AC47033FE9A5533D64C53CBF30CCF4F13274_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m1CE82E4289FB0185AFB66AE7C7EF92511DC7017E_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m247079442CEC480662FA971CAD91C5A1ED937A9A_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m293B9C3C02900945171CC48486B75790594968C4_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m2AF423D17198E438C0EFC65B276D2C53E684A093_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m2B71AC61E1D5E112E4E40B79E0FC768F981AF275_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m2D99D91E76466691A4182B87F18C0507601C08C8_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m2E3532B82D1C6D2AE0835E096591EC98D0982AB2_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m420EE01A411C337671037356ED272F11275F1CB5_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m43159AC3B73F8C7B43D68F731301DAAF9660A0FF_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m43D211386BFACB64619122C4508DE298757FFDF0_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m48F65C072D4CD934C97FB2CB5DF62922B52C9970_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m4A4EFA8829A60E09FE4E94105F12D16C78230B77_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m4BBE2ED9520467529E070DEDE2D4EA9BC34FFF46_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m4D75CAE0763650D9067F695B43181AD1167219BC_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m596FBD0FF13E8AC079AF1E3FCBF59FD8BFF0076E_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m5A7A5AF62CCF46153A47CEF59A43C83C6D92BB56_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m5E5746A2F739063EB4AAD252A5755542C93CE3DC_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m60F72696ADBA60FCDF548CC21844A3852BAA9820_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m630AF63B3207B43E2ED4C1B2D919B2E336C6859F_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m68884E7F37A82001ECE18FF1AB9E0807E71EEB14_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m688871A0D97BDF5D132509D3C505A14475EF10FA_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m6B46980E651EA5A3FDFDF0E11A514D4392774364_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m6E9F5FEA95891488995D987661B9DDDFFA7E2EA4_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m6F736FA9A64A4731F43C0EB684DEC9FC7827B12F_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m70740947394191A6C9D5A4BE101FBE4AB834E6E5_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m74C53F2B3DCAF7CA8A55FD1A12A8A27D6D9A540E_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m74F78B949FE0A28B76A17D74BD70A9ED83FD0864_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m7724FEA10A3B810C3543323AE7A1F3B663972FF5_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m7BC4D764094154DE60F8FB6C4201D3E091D5BFE5_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m7FF157DCF930FD6D8E3448441F2EE79E8CB462A9_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m80A2ACBC3B0046EDE292A4DDE0674EEE5ED4861B_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m83FBD6CF2834CFCAD3D84A8215C40BCC028353A8_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m8444FDF54FEBD602CA48F528EC463DB1AC8082E6_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m89E994B29B5FB68A2E132D5BE44DED295944AC41_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m8AFD620D0B3BD3A1F968761903831952C731B3A2_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m8D6D84541FA8C039CE3800A657E8640AFFCD1063_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m8D775E44C86196D9A8E7493AE45BB5274764C46A_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_m952BF74D0CB1544321A6EC1605BF7919CAFF0896_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mA06904B635841F0E7F80D2F769DE07A6ED082B01_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mA09E0C78D8EF2892E5C4EF4F2DCFBF8DBEFDD8FB_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mA4E7989BC90D09B31EEDA1BDF04507D72F72A2A8_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mA8EDB09064057A0786F373AD65D2D1BD26181070_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mADF4703A99D76C5A2AE37C4DC95E3958DBE9E99C_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mB020239A7A0F12907B4A51FA17738728687ADE59_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mB4538F08D37C1AF8ED2E5A8542368184F34E58E7_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mB55E0808A4D77A4946F44A0F47F8BE914C329D45_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mB9F9A8521DE3F36A78F934BB06A77280EC38BC9B_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mBA694D08EB8FDE2B47454EDE7A07F687ED317CCF_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mBEC4557EDCDBE1BCFE4279943CFC23E51EE664A0_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mC07B792B936AADB3124956F37200AD20909E051B_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mC1B00DC8F54756D285CE951065DCB3583FA60DBF_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mC1C0DF442F32344DCEA7D870E1301FA676A78DF9_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mC2B8B3B80264600FD8E7FBA9DEBA4BA6FA287810_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mC5BA4F2C682C18C4A01CECEDC74DE8D4FEAAD27C_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mD41BD65921AA0AFAA9025BD7FBEEE634BF58E633_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mD62451B7245670D9AC8F19B55DD0D3E70E56CD3A_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mDA9F64CC2753664296C3D3E7AA3AB26DEDDCA164_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mDB789AF8B347AAB5B9C449C7519E95F969E9DE87_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mE05BEAE26B082F795117C94E65C14D2930BA5E29_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mE2016AE72E368C527141CFB7657D9644FEF1561E_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mEA3554A434E127BEB53A50C0B937A0FDC4155661_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mEA48A914AC1EA8AA2BA4D469555F9A904465F31D_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mEEEA3BB14A06103E355C424A371C59B0968ABC51_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mF477BCDFC6FB221532EC3FBD8F1711E6D55C1F10_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mF50B58F842124158245C98B1F976703224B89103_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* EmptyInternalEnumerator_1_get_Current_mFECAA6FE620D2B630E8A3AC1615D8F677C5F0C22_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m0577F355E2082ACD4D2A5281A5D618D2BAEB018C_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m079C9B7D950F47EBDDE3290AF721C64568541238_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m08ED2C8C47D5621377FB042EFFFF6038160D427C_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m0E37DD99400FD8E67350E2959B777C353662D4AE_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m1AB3F2C70645660A20831F4A4FDBB1AB61DB8420_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m209A56D6C53AC134B236FD1E3808E42C2DA0F378_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m219A6F6D4C2AEE8F86D69E8CED72AB8566CECBFA_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m2EF8D8561F60AAA02F2B3BD2EC7176E50BCD5E52_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m3B5BD0D9A3A2B90B762F783677926F8ED30B67C1_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m3D123B39BCDA4F165484915F8DD3940962AECBF0_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m409E760F9CBF152E005D1ABB74D0D4208D56227F_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m423DED00D8E4A4F471ACF4A96345C45C4378F556_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m4ABCF333B87FC095F8DB1908EE7CB57702BBB20F_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m4BFF9065A44EB1D4FB065F5709238C6489E5A0C5_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m4CE05D9509A3134EAC31E8340F36EC2B4B54703F_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m4CF2B380D638F22E5C70B4E41F35AD95FB71FE26_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m52F1F50D102498BDAA3DC236872E47AB913F5B5D_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m5474D37CD91A506826F57EEEA5BA8900CC2A212D_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m588A1C9004B72DEF16E5D6EEEE07D34F994B5E5B_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m5BF1362D0455A86D563CA0FE18879952C871ABC3_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m5C45B04B93E24CF93F54B15DA1E0A4E5FB0D4F77_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m5E3D89E57206E983F95400F30010E1922D7E1A1C_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m654F712F9682ADAE03DA5A38B8EA05099AB77864_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m70AA9F95B052891AAD4AB638CA09537554ABE683_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m7A52D8C9B31569083E11811B585B6D3BABA3A948_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m7CE9128839CB0EC4AF3B0BAF875A178ED4EA9E42_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m7DAF45BE6246754B95E518F44152AB86F6F01503_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m80B0AC143205EB914B0C033876B87B4C3B344F57_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m80E4BACA28C64E50461E74B92DEE28DD5C49A580_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m81C0B3258A94D63BA8AF4BE1C02FC30E77BCA1C4_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m8322D35634EA8F36F950C7FC88EA889817413E87_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m868993F9E581D2FDE89D311B0D0E7F043B5526EE_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m898EF6FD732B94B5BA3C6CFC17B8C3897D0C5B6B_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m8BCE8ACA1FB9184338A431ADF16C9ADEF01FE5A5_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m8C4CCAC66EBAE129B0DCCA46A73041A2B0F3B999_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m8DD1DD354BD2CCD8BF53308EE859FD91BAC319F4_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m902312010187A018147C6FDDC77113E4B125EC6C_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m92BB9CC66A8467F196EA707E00E7186FA64AE48B_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m94C0D13214FB1EC791B1CC5DFE5A82E2AAE63406_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m95BBA6E2E51E7EFE7672D9D8A78D29B9FFDFEAEE_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_m9A73AB58D1A8BE0B72C490559F3DB7A1A8194174_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mA90DEF143C9B52AABD722C59391860F4421B8D6C_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mB1B90708ED55CB1E651BF9E5FA629B28E8E5977A_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mB446FB579A0D2052E3021D345FBA2E7BD1E2D8E7_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mB4EDDDE7A9FD306176CCDDC4E9693B40EF7B984B_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mB7A85C3324689374F5BBE1813C0439798CDFF9CB_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mC2EC065F63466F7E6AD6C9AE9BC86A3B0CF0E07A_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mC41E15442C38B131C7AD1E88876963F01A4868CB_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mCEBACD4CF4D2DF7FDB7FF8031CCE8725B75DA540_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mCF3BFAF3BCAACDF803583C88DD293C5B812A145C_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mCFB8564C9D825B393AABF73A69BAE8E986796895_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mD3C6FDF318DBC20B66E7B62496085159512C8FB5_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mDBE1EC33C2BD728CBA191BA48B16AFD2BCE81F6D_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mE52FE5CD07FFC9C64D612B428D4C9CE7BD68C140_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mEACBD5ABDAC498CC39F2D794C276AFCB4B23D5A6_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mF0C51E221CD4A4E7C605483AF49C78902866C3C5_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mF3A24C3ABE3B152A3C3A30863E92D79103A50BA1_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mF60DB3DFAED76189D44BCCA186D595043C014D3E_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mF9D5C23927E856F0D50CD0211DD96DED7A737466_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* InternalEnumerator_1_get_Current_mFFD60C69E1F8CF93C20492F2A58FBC09CEB6188F_RuntimeMethod_var;
IL2CPP_EXTERN_C const uint32_t Action_1_BeginInvoke_m10C6A956131CC7E0B40A82EF4973DB68378C7F11_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Action_1_BeginInvoke_m147EA0AF0B438620EBDA154160680EDFB8FDE786_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Action_1_BeginInvoke_m38D4DB74F04D419EB6A08DC496693915A0A3060D_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Action_2_BeginInvoke_m00BD43B0496F386EBA85D9FD7BF8480F6B2C1E13_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Action_2_BeginInvoke_m1A2023AD69CC33FE7360200C4E77F16B840BCCBB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Action_2_BeginInvoke_m4F9434B4D9C00487F3304FDB70D3303596AD3081_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Action_2_BeginInvoke_m6896AF87BCD908F449DE142BACD2A924D9C1869C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Action_2_BeginInvoke_m701B18451EA00B7A907C490C88AD8DA88992B8CC_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Action_2_BeginInvoke_m90CE2E30BF265027DA651AF5A3946F6E1C2404E7_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Action_3_BeginInvoke_mA891E1DC8C7E105C63B16AFFBB1009FC68E1DF91_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m04B5C2FD10B42EA5CD3BBE88C3B8E1AF021CD27D_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m07E77FDBFD58E5EE65287D586B1E09E258371140_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m0C60BE6EA74588A46F15051C3259341BDCB8F58A_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m0CABA4EE26CC086C7D8C239B67A07B4890E7C8EC_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m0FB286FD156C69E50C98EDD6ADF037DC6A46D771_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m165DF603BD5CC24DD7D73981775AAEE1DF235094_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m17E39F6C3ADB920CA93850D89890D0E47C36592D_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m1868AC47033FE9A5533D64C53CBF30CCF4F13274_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m1CE82E4289FB0185AFB66AE7C7EF92511DC7017E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m247079442CEC480662FA971CAD91C5A1ED937A9A_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m293B9C3C02900945171CC48486B75790594968C4_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m2AF423D17198E438C0EFC65B276D2C53E684A093_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m2B71AC61E1D5E112E4E40B79E0FC768F981AF275_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m2D99D91E76466691A4182B87F18C0507601C08C8_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m2E3532B82D1C6D2AE0835E096591EC98D0982AB2_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m420EE01A411C337671037356ED272F11275F1CB5_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m43159AC3B73F8C7B43D68F731301DAAF9660A0FF_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m43D211386BFACB64619122C4508DE298757FFDF0_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m48F65C072D4CD934C97FB2CB5DF62922B52C9970_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m4A4EFA8829A60E09FE4E94105F12D16C78230B77_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m4BBE2ED9520467529E070DEDE2D4EA9BC34FFF46_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m4D75CAE0763650D9067F695B43181AD1167219BC_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m596FBD0FF13E8AC079AF1E3FCBF59FD8BFF0076E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m5A7A5AF62CCF46153A47CEF59A43C83C6D92BB56_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m5E5746A2F739063EB4AAD252A5755542C93CE3DC_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m60F72696ADBA60FCDF548CC21844A3852BAA9820_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m630AF63B3207B43E2ED4C1B2D919B2E336C6859F_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m68884E7F37A82001ECE18FF1AB9E0807E71EEB14_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m688871A0D97BDF5D132509D3C505A14475EF10FA_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m6B46980E651EA5A3FDFDF0E11A514D4392774364_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m6E9F5FEA95891488995D987661B9DDDFFA7E2EA4_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m6F736FA9A64A4731F43C0EB684DEC9FC7827B12F_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m70740947394191A6C9D5A4BE101FBE4AB834E6E5_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m74C53F2B3DCAF7CA8A55FD1A12A8A27D6D9A540E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m74F78B949FE0A28B76A17D74BD70A9ED83FD0864_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m7724FEA10A3B810C3543323AE7A1F3B663972FF5_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m7BC4D764094154DE60F8FB6C4201D3E091D5BFE5_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m7FF157DCF930FD6D8E3448441F2EE79E8CB462A9_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m80A2ACBC3B0046EDE292A4DDE0674EEE5ED4861B_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m83FBD6CF2834CFCAD3D84A8215C40BCC028353A8_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m8444FDF54FEBD602CA48F528EC463DB1AC8082E6_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m89E994B29B5FB68A2E132D5BE44DED295944AC41_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m8AFD620D0B3BD3A1F968761903831952C731B3A2_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m8D6D84541FA8C039CE3800A657E8640AFFCD1063_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m8D775E44C86196D9A8E7493AE45BB5274764C46A_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_m952BF74D0CB1544321A6EC1605BF7919CAFF0896_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mA06904B635841F0E7F80D2F769DE07A6ED082B01_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mA09E0C78D8EF2892E5C4EF4F2DCFBF8DBEFDD8FB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mA4E7989BC90D09B31EEDA1BDF04507D72F72A2A8_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mA8EDB09064057A0786F373AD65D2D1BD26181070_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mADF4703A99D76C5A2AE37C4DC95E3958DBE9E99C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mB020239A7A0F12907B4A51FA17738728687ADE59_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mB4538F08D37C1AF8ED2E5A8542368184F34E58E7_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mB55E0808A4D77A4946F44A0F47F8BE914C329D45_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mB9F9A8521DE3F36A78F934BB06A77280EC38BC9B_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mBA694D08EB8FDE2B47454EDE7A07F687ED317CCF_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mBEC4557EDCDBE1BCFE4279943CFC23E51EE664A0_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mC07B792B936AADB3124956F37200AD20909E051B_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mC1B00DC8F54756D285CE951065DCB3583FA60DBF_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mC1C0DF442F32344DCEA7D870E1301FA676A78DF9_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mC2B8B3B80264600FD8E7FBA9DEBA4BA6FA287810_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mC5BA4F2C682C18C4A01CECEDC74DE8D4FEAAD27C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mD41BD65921AA0AFAA9025BD7FBEEE634BF58E633_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mD62451B7245670D9AC8F19B55DD0D3E70E56CD3A_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mDA9F64CC2753664296C3D3E7AA3AB26DEDDCA164_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mDB789AF8B347AAB5B9C449C7519E95F969E9DE87_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mE05BEAE26B082F795117C94E65C14D2930BA5E29_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mE2016AE72E368C527141CFB7657D9644FEF1561E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mEA3554A434E127BEB53A50C0B937A0FDC4155661_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mEA48A914AC1EA8AA2BA4D469555F9A904465F31D_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mEEEA3BB14A06103E355C424A371C59B0968ABC51_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mF477BCDFC6FB221532EC3FBD8F1711E6D55C1F10_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mF50B58F842124158245C98B1F976703224B89103_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t EmptyInternalEnumerator_1_get_Current_mFECAA6FE620D2B630E8A3AC1615D8F677C5F0C22_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m0577F355E2082ACD4D2A5281A5D618D2BAEB018C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m079C9B7D950F47EBDDE3290AF721C64568541238_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m08ED2C8C47D5621377FB042EFFFF6038160D427C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m0E37DD99400FD8E67350E2959B777C353662D4AE_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m1AB3F2C70645660A20831F4A4FDBB1AB61DB8420_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m209A56D6C53AC134B236FD1E3808E42C2DA0F378_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m219A6F6D4C2AEE8F86D69E8CED72AB8566CECBFA_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m2EF8D8561F60AAA02F2B3BD2EC7176E50BCD5E52_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m3B5BD0D9A3A2B90B762F783677926F8ED30B67C1_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m3D123B39BCDA4F165484915F8DD3940962AECBF0_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m409E760F9CBF152E005D1ABB74D0D4208D56227F_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m423DED00D8E4A4F471ACF4A96345C45C4378F556_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m4ABCF333B87FC095F8DB1908EE7CB57702BBB20F_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m4BFF9065A44EB1D4FB065F5709238C6489E5A0C5_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m4CE05D9509A3134EAC31E8340F36EC2B4B54703F_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m4CF2B380D638F22E5C70B4E41F35AD95FB71FE26_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m52F1F50D102498BDAA3DC236872E47AB913F5B5D_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m5474D37CD91A506826F57EEEA5BA8900CC2A212D_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m588A1C9004B72DEF16E5D6EEEE07D34F994B5E5B_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m5BF1362D0455A86D563CA0FE18879952C871ABC3_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m5C45B04B93E24CF93F54B15DA1E0A4E5FB0D4F77_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m5E3D89E57206E983F95400F30010E1922D7E1A1C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m654F712F9682ADAE03DA5A38B8EA05099AB77864_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m70AA9F95B052891AAD4AB638CA09537554ABE683_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m7A52D8C9B31569083E11811B585B6D3BABA3A948_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m7CE9128839CB0EC4AF3B0BAF875A178ED4EA9E42_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m7DAF45BE6246754B95E518F44152AB86F6F01503_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m80B0AC143205EB914B0C033876B87B4C3B344F57_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m80E4BACA28C64E50461E74B92DEE28DD5C49A580_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m81C0B3258A94D63BA8AF4BE1C02FC30E77BCA1C4_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m8322D35634EA8F36F950C7FC88EA889817413E87_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m868993F9E581D2FDE89D311B0D0E7F043B5526EE_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m898EF6FD732B94B5BA3C6CFC17B8C3897D0C5B6B_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m8BCE8ACA1FB9184338A431ADF16C9ADEF01FE5A5_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m8C4CCAC66EBAE129B0DCCA46A73041A2B0F3B999_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m8DD1DD354BD2CCD8BF53308EE859FD91BAC319F4_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m902312010187A018147C6FDDC77113E4B125EC6C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m92BB9CC66A8467F196EA707E00E7186FA64AE48B_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m94C0D13214FB1EC791B1CC5DFE5A82E2AAE63406_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m95BBA6E2E51E7EFE7672D9D8A78D29B9FFDFEAEE_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_m9A73AB58D1A8BE0B72C490559F3DB7A1A8194174_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mA90DEF143C9B52AABD722C59391860F4421B8D6C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mB1B90708ED55CB1E651BF9E5FA629B28E8E5977A_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mB446FB579A0D2052E3021D345FBA2E7BD1E2D8E7_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mB4EDDDE7A9FD306176CCDDC4E9693B40EF7B984B_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mB7A85C3324689374F5BBE1813C0439798CDFF9CB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mC2EC065F63466F7E6AD6C9AE9BC86A3B0CF0E07A_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mC41E15442C38B131C7AD1E88876963F01A4868CB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mCEBACD4CF4D2DF7FDB7FF8031CCE8725B75DA540_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mCF3BFAF3BCAACDF803583C88DD293C5B812A145C_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mCFB8564C9D825B393AABF73A69BAE8E986796895_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mD3C6FDF318DBC20B66E7B62496085159512C8FB5_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mDBE1EC33C2BD728CBA191BA48B16AFD2BCE81F6D_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mE52FE5CD07FFC9C64D612B428D4C9CE7BD68C140_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mEACBD5ABDAC498CC39F2D794C276AFCB4B23D5A6_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mF0C51E221CD4A4E7C605483AF49C78902866C3C5_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mF3A24C3ABE3B152A3C3A30863E92D79103A50BA1_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mF60DB3DFAED76189D44BCCA186D595043C014D3E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mF9D5C23927E856F0D50CD0211DD96DED7A737466_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t InternalEnumerator_1_get_Current_mFFD60C69E1F8CF93C20492F2A58FBC09CEB6188F_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t U3CU3Ef__AnonymousType0_1_ToString_m1B1F29A3B1690D6AA429AF0A8405278664F94771_MetadataUsageId;
struct Delegate_t_marshaled_com;
struct Delegate_t_marshaled_pinvoke;
struct Exception_t_marshaled_com;
struct Exception_t_marshaled_pinvoke;
struct Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_marshaled_com;
struct ParameterInfo_t37AB8D79D44E14C48CDA9004CB696E240C3FD4DB_marshaled_com;
struct ParameterInfo_t37AB8D79D44E14C48CDA9004CB696E240C3FD4DB_marshaled_pinvoke;
struct PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93_marshaled_com;
struct PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93_marshaled_pinvoke;
struct DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86;
struct ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A;
IL2CPP_EXTERN_C_BEGIN
IL2CPP_EXTERN_C_END
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Object
// <>f__AnonymousType0`1<System.Object>
struct U3CU3Ef__AnonymousType0_1_t103DB909F3478F55EAABC0751EA7624561E5B35F : public RuntimeObject
{
public:
// <message>j__TPar <>f__AnonymousType0`1::<message>i__Field
RuntimeObject * ___U3CmessageU3Ei__Field_0;
public:
inline static int32_t get_offset_of_U3CmessageU3Ei__Field_0() { return static_cast<int32_t>(offsetof(U3CU3Ef__AnonymousType0_1_t103DB909F3478F55EAABC0751EA7624561E5B35F, ___U3CmessageU3Ei__Field_0)); }
inline RuntimeObject * get_U3CmessageU3Ei__Field_0() const { return ___U3CmessageU3Ei__Field_0; }
inline RuntimeObject ** get_address_of_U3CmessageU3Ei__Field_0() { return &___U3CmessageU3Ei__Field_0; }
inline void set_U3CmessageU3Ei__Field_0(RuntimeObject * value)
{
___U3CmessageU3Ei__Field_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CmessageU3Ei__Field_0), (void*)value);
}
};
struct Il2CppArrayBounds;
// System.Array
// System.Array_EmptyInternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>
struct EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Boolean>
struct EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Byte>
struct EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Char>
struct EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.DictionaryEntry>
struct EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>
struct EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>
struct EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>
struct EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>
struct EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>
struct EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>
struct EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>
struct EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>
struct EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>
struct EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>
struct EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>
struct EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>
struct EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>
struct EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>
struct EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Collections.Hashtable_bucket>
struct EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.DateTime>
struct EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Decimal>
struct EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>
struct EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>
struct EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Double>
struct EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalCodePageDataItem>
struct EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalEncodingDataItem>
struct EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Guid>
struct EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Int16>
struct EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Int32>
struct EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Int32Enum>
struct EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Int64>
struct EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.IntPtr>
struct EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Object>
struct EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.ParameterizedStrings_FormatParam>
struct EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>
struct EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>
struct EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Reflection.ParameterModifier>
struct EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Resources.ResourceLocator>
struct EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>
struct EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Runtime.InteropServices.GCHandle>
struct EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.SByte>
struct EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Single>
struct EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>
struct EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.Threading.CancellationTokenRegistration>
struct EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.TimeSpan>
struct EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.UInt16>
struct EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.UInt32>
struct EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.UInt64>
struct EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<System.UIntPtr>
struct EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>
struct EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.Color32>
struct EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>
struct EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>
struct EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.Keyframe>
struct EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>
struct EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.Plane>
struct EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.Playables.PlayableBinding>
struct EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit2D>
struct EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit>
struct EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.Rendering.BatchVisibility>
struct EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.SendMouseEvents_HitInfo>
struct EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcAchievementData>
struct EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcScoreData>
struct EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.ColorBlock>
struct EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.Navigation>
struct EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.SpriteState>
struct EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.UICharInfo>
struct EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.UILineInfo>
struct EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.UIVertex>
struct EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.UnitySynchronizationContext_WorkRequest>
struct EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector2>
struct EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector3>
struct EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector4>
struct EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 : public RuntimeObject
{
public:
public:
};
struct EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281_StaticFields
{
public:
// System.Array_EmptyInternalEnumerator`1<T> System.Array_EmptyInternalEnumerator`1::Value
EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 * ___Value_0;
public:
inline static int32_t get_offset_of_Value_0() { return static_cast<int32_t>(offsetof(EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281_StaticFields, ___Value_0)); }
inline EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 * get_Value_0() const { return ___Value_0; }
inline EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 ** get_address_of_Value_0() { return &___Value_0; }
inline void set_Value_0(EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 * value)
{
___Value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Value_0), (void*)value);
}
};
// System.Collections.Generic.EqualityComparer`1<System.Object>
struct EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA : public RuntimeObject
{
public:
public:
};
struct EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA_StaticFields
{
public:
// System.Collections.Generic.EqualityComparer`1<T> modreq(System.Runtime.CompilerServices.IsVolatile) System.Collections.Generic.EqualityComparer`1::defaultComparer
EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA * ___defaultComparer_0;
public:
inline static int32_t get_offset_of_defaultComparer_0() { return static_cast<int32_t>(offsetof(EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA_StaticFields, ___defaultComparer_0)); }
inline EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA * get_defaultComparer_0() const { return ___defaultComparer_0; }
inline EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA ** get_address_of_defaultComparer_0() { return &___defaultComparer_0; }
inline void set_defaultComparer_0(EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA * value)
{
___defaultComparer_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___defaultComparer_0), (void*)value);
}
};
// System.String
struct String_t : public RuntimeObject
{
public:
// System.Int32 System.String::m_stringLength
int32_t ___m_stringLength_0;
// System.Char System.String::m_firstChar
Il2CppChar ___m_firstChar_1;
public:
inline static int32_t get_offset_of_m_stringLength_0() { return static_cast<int32_t>(offsetof(String_t, ___m_stringLength_0)); }
inline int32_t get_m_stringLength_0() const { return ___m_stringLength_0; }
inline int32_t* get_address_of_m_stringLength_0() { return &___m_stringLength_0; }
inline void set_m_stringLength_0(int32_t value)
{
___m_stringLength_0 = value;
}
inline static int32_t get_offset_of_m_firstChar_1() { return static_cast<int32_t>(offsetof(String_t, ___m_firstChar_1)); }
inline Il2CppChar get_m_firstChar_1() const { return ___m_firstChar_1; }
inline Il2CppChar* get_address_of_m_firstChar_1() { return &___m_firstChar_1; }
inline void set_m_firstChar_1(Il2CppChar value)
{
___m_firstChar_1 = value;
}
};
struct String_t_StaticFields
{
public:
// System.String System.String::Empty
String_t* ___Empty_5;
public:
inline static int32_t get_offset_of_Empty_5() { return static_cast<int32_t>(offsetof(String_t_StaticFields, ___Empty_5)); }
inline String_t* get_Empty_5() const { return ___Empty_5; }
inline String_t** get_address_of_Empty_5() { return &___Empty_5; }
inline void set_Empty_5(String_t* value)
{
___Empty_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Empty_5), (void*)value);
}
};
// System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF : public RuntimeObject
{
public:
public:
};
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_com
{
};
// Mono.Globalization.Unicode.CodePointIndexer_TableRange
struct TableRange_t485CF0807771CC05023466CFCB0AE25C46648100
{
public:
// System.Int32 Mono.Globalization.Unicode.CodePointIndexer_TableRange::Start
int32_t ___Start_0;
// System.Int32 Mono.Globalization.Unicode.CodePointIndexer_TableRange::End
int32_t ___End_1;
// System.Int32 Mono.Globalization.Unicode.CodePointIndexer_TableRange::Count
int32_t ___Count_2;
// System.Int32 Mono.Globalization.Unicode.CodePointIndexer_TableRange::IndexStart
int32_t ___IndexStart_3;
// System.Int32 Mono.Globalization.Unicode.CodePointIndexer_TableRange::IndexEnd
int32_t ___IndexEnd_4;
public:
inline static int32_t get_offset_of_Start_0() { return static_cast<int32_t>(offsetof(TableRange_t485CF0807771CC05023466CFCB0AE25C46648100, ___Start_0)); }
inline int32_t get_Start_0() const { return ___Start_0; }
inline int32_t* get_address_of_Start_0() { return &___Start_0; }
inline void set_Start_0(int32_t value)
{
___Start_0 = value;
}
inline static int32_t get_offset_of_End_1() { return static_cast<int32_t>(offsetof(TableRange_t485CF0807771CC05023466CFCB0AE25C46648100, ___End_1)); }
inline int32_t get_End_1() const { return ___End_1; }
inline int32_t* get_address_of_End_1() { return &___End_1; }
inline void set_End_1(int32_t value)
{
___End_1 = value;
}
inline static int32_t get_offset_of_Count_2() { return static_cast<int32_t>(offsetof(TableRange_t485CF0807771CC05023466CFCB0AE25C46648100, ___Count_2)); }
inline int32_t get_Count_2() const { return ___Count_2; }
inline int32_t* get_address_of_Count_2() { return &___Count_2; }
inline void set_Count_2(int32_t value)
{
___Count_2 = value;
}
inline static int32_t get_offset_of_IndexStart_3() { return static_cast<int32_t>(offsetof(TableRange_t485CF0807771CC05023466CFCB0AE25C46648100, ___IndexStart_3)); }
inline int32_t get_IndexStart_3() const { return ___IndexStart_3; }
inline int32_t* get_address_of_IndexStart_3() { return &___IndexStart_3; }
inline void set_IndexStart_3(int32_t value)
{
___IndexStart_3 = value;
}
inline static int32_t get_offset_of_IndexEnd_4() { return static_cast<int32_t>(offsetof(TableRange_t485CF0807771CC05023466CFCB0AE25C46648100, ___IndexEnd_4)); }
inline int32_t get_IndexEnd_4() const { return ___IndexEnd_4; }
inline int32_t* get_address_of_IndexEnd_4() { return &___IndexEnd_4; }
inline void set_IndexEnd_4(int32_t value)
{
___IndexEnd_4 = value;
}
};
// System.Array_InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>
struct InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Boolean>
struct InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Byte>
struct InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Char>
struct InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.DictionaryEntry>
struct InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>
struct InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>
struct InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>
struct InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>
struct InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>
struct InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>
struct InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>
struct InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>
struct InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>
struct InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>
struct InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>
struct InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>
struct InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>
struct InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>
struct InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Collections.Hashtable_bucket>
struct InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.DateTime>
struct InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Decimal>
struct InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>
struct InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>
struct InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Double>
struct InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>
struct InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>
struct InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Guid>
struct InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Int16>
struct InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Int32>
struct InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Int32Enum>
struct InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Int64>
struct InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.IntPtr>
struct InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Object>
struct InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.ParameterizedStrings_FormatParam>
struct InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>
struct InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>
struct InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Reflection.ParameterModifier>
struct InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Resources.ResourceLocator>
struct InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>
struct InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>
struct InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.SByte>
struct InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Single>
struct InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>
struct InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.Threading.CancellationTokenRegistration>
struct InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.TimeSpan>
struct InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.UInt16>
struct InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.UInt32>
struct InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.UInt64>
struct InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<System.UIntPtr>
struct InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>
struct InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<UnityEngine.Color32>
struct InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>
struct InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>
struct InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<UnityEngine.Keyframe>
struct InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>
struct InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<UnityEngine.Plane>
struct InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>
struct InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<UnityEngine.RaycastHit2D>
struct InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Array_InternalEnumerator`1<UnityEngine.RaycastHit>
struct InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95
{
public:
// System.Array System.Array_InternalEnumerator`1::array
RuntimeArray * ___array_0;
// System.Int32 System.Array_InternalEnumerator`1::idx
int32_t ___idx_1;
public:
inline static int32_t get_offset_of_array_0() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95, ___array_0)); }
inline RuntimeArray * get_array_0() const { return ___array_0; }
inline RuntimeArray ** get_address_of_array_0() { return &___array_0; }
inline void set_array_0(RuntimeArray * value)
{
___array_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___array_0), (void*)value);
}
inline static int32_t get_offset_of_idx_1() { return static_cast<int32_t>(offsetof(InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95, ___idx_1)); }
inline int32_t get_idx_1() const { return ___idx_1; }
inline int32_t* get_address_of_idx_1() { return &___idx_1; }
inline void set_idx_1(int32_t value)
{
___idx_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_pinvoke
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// Native definition for COM marshalling of System.Array/InternalEnumerator`1
#ifndef InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
#define InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com_define
struct InternalEnumerator_1_t2230E371CD528773FD327FDC447CE231DE2AAA56_marshaled_com
{
RuntimeArray * ___array_0;
int32_t ___idx_1;
};
#endif
// System.Boolean
struct Boolean_tB53F6830F670160873277339AA58F15CAED4399C
{
public:
// System.Boolean System.Boolean::m_value
bool ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Boolean_tB53F6830F670160873277339AA58F15CAED4399C, ___m_value_0)); }
inline bool get_m_value_0() const { return ___m_value_0; }
inline bool* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(bool value)
{
___m_value_0 = value;
}
};
struct Boolean_tB53F6830F670160873277339AA58F15CAED4399C_StaticFields
{
public:
// System.String System.Boolean::TrueString
String_t* ___TrueString_5;
// System.String System.Boolean::FalseString
String_t* ___FalseString_6;
public:
inline static int32_t get_offset_of_TrueString_5() { return static_cast<int32_t>(offsetof(Boolean_tB53F6830F670160873277339AA58F15CAED4399C_StaticFields, ___TrueString_5)); }
inline String_t* get_TrueString_5() const { return ___TrueString_5; }
inline String_t** get_address_of_TrueString_5() { return &___TrueString_5; }
inline void set_TrueString_5(String_t* value)
{
___TrueString_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___TrueString_5), (void*)value);
}
inline static int32_t get_offset_of_FalseString_6() { return static_cast<int32_t>(offsetof(Boolean_tB53F6830F670160873277339AA58F15CAED4399C_StaticFields, ___FalseString_6)); }
inline String_t* get_FalseString_6() const { return ___FalseString_6; }
inline String_t** get_address_of_FalseString_6() { return &___FalseString_6; }
inline void set_FalseString_6(String_t* value)
{
___FalseString_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FalseString_6), (void*)value);
}
};
// System.Byte
struct Byte_tF87C579059BD4633E6840EBBBEEF899C6E33EF07
{
public:
// System.Byte System.Byte::m_value
uint8_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Byte_tF87C579059BD4633E6840EBBBEEF899C6E33EF07, ___m_value_0)); }
inline uint8_t get_m_value_0() const { return ___m_value_0; }
inline uint8_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint8_t value)
{
___m_value_0 = value;
}
};
// System.Char
struct Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9
{
public:
// System.Char System.Char::m_value
Il2CppChar ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9, ___m_value_0)); }
inline Il2CppChar get_m_value_0() const { return ___m_value_0; }
inline Il2CppChar* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(Il2CppChar value)
{
___m_value_0 = value;
}
};
struct Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_StaticFields
{
public:
// System.Byte[] System.Char::categoryForLatin1
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___categoryForLatin1_3;
public:
inline static int32_t get_offset_of_categoryForLatin1_3() { return static_cast<int32_t>(offsetof(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_StaticFields, ___categoryForLatin1_3)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_categoryForLatin1_3() const { return ___categoryForLatin1_3; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_categoryForLatin1_3() { return &___categoryForLatin1_3; }
inline void set_categoryForLatin1_3(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___categoryForLatin1_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___categoryForLatin1_3), (void*)value);
}
};
// System.Collections.DictionaryEntry
struct DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4
{
public:
// System.Object System.Collections.DictionaryEntry::_key
RuntimeObject * ____key_0;
// System.Object System.Collections.DictionaryEntry::_value
RuntimeObject * ____value_1;
public:
inline static int32_t get_offset_of__key_0() { return static_cast<int32_t>(offsetof(DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4, ____key_0)); }
inline RuntimeObject * get__key_0() const { return ____key_0; }
inline RuntimeObject ** get_address_of__key_0() { return &____key_0; }
inline void set__key_0(RuntimeObject * value)
{
____key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____key_0), (void*)value);
}
inline static int32_t get_offset_of__value_1() { return static_cast<int32_t>(offsetof(DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4, ____value_1)); }
inline RuntimeObject * get__value_1() const { return ____value_1; }
inline RuntimeObject ** get_address_of__value_1() { return &____value_1; }
inline void set__value_1(RuntimeObject * value)
{
____value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____value_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Collections.DictionaryEntry
struct DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4_marshaled_pinvoke
{
Il2CppIUnknown* ____key_0;
Il2CppIUnknown* ____value_1;
};
// Native definition for COM marshalling of System.Collections.DictionaryEntry
struct DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4_marshaled_com
{
Il2CppIUnknown* ____key_0;
Il2CppIUnknown* ____value_1;
};
// System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>
struct Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D
{
public:
// System.Int32 System.Collections.Generic.Dictionary`2_Entry::hashCode
int32_t ___hashCode_0;
// System.Int32 System.Collections.Generic.Dictionary`2_Entry::next
int32_t ___next_1;
// TKey System.Collections.Generic.Dictionary`2_Entry::key
int32_t ___key_2;
// TValue System.Collections.Generic.Dictionary`2_Entry::value
RuntimeObject * ___value_3;
public:
inline static int32_t get_offset_of_hashCode_0() { return static_cast<int32_t>(offsetof(Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D, ___hashCode_0)); }
inline int32_t get_hashCode_0() const { return ___hashCode_0; }
inline int32_t* get_address_of_hashCode_0() { return &___hashCode_0; }
inline void set_hashCode_0(int32_t value)
{
___hashCode_0 = value;
}
inline static int32_t get_offset_of_next_1() { return static_cast<int32_t>(offsetof(Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D, ___next_1)); }
inline int32_t get_next_1() const { return ___next_1; }
inline int32_t* get_address_of_next_1() { return &___next_1; }
inline void set_next_1(int32_t value)
{
___next_1 = value;
}
inline static int32_t get_offset_of_key_2() { return static_cast<int32_t>(offsetof(Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D, ___key_2)); }
inline int32_t get_key_2() const { return ___key_2; }
inline int32_t* get_address_of_key_2() { return &___key_2; }
inline void set_key_2(int32_t value)
{
___key_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D, ___value_3)); }
inline RuntimeObject * get_value_3() const { return ___value_3; }
inline RuntimeObject ** get_address_of_value_3() { return &___value_3; }
inline void set_value_3(RuntimeObject * value)
{
___value_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_3), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>
struct Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE
{
public:
// System.Int32 System.Collections.Generic.Dictionary`2_Entry::hashCode
int32_t ___hashCode_0;
// System.Int32 System.Collections.Generic.Dictionary`2_Entry::next
int32_t ___next_1;
// TKey System.Collections.Generic.Dictionary`2_Entry::key
RuntimeObject * ___key_2;
// TValue System.Collections.Generic.Dictionary`2_Entry::value
int32_t ___value_3;
public:
inline static int32_t get_offset_of_hashCode_0() { return static_cast<int32_t>(offsetof(Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE, ___hashCode_0)); }
inline int32_t get_hashCode_0() const { return ___hashCode_0; }
inline int32_t* get_address_of_hashCode_0() { return &___hashCode_0; }
inline void set_hashCode_0(int32_t value)
{
___hashCode_0 = value;
}
inline static int32_t get_offset_of_next_1() { return static_cast<int32_t>(offsetof(Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE, ___next_1)); }
inline int32_t get_next_1() const { return ___next_1; }
inline int32_t* get_address_of_next_1() { return &___next_1; }
inline void set_next_1(int32_t value)
{
___next_1 = value;
}
inline static int32_t get_offset_of_key_2() { return static_cast<int32_t>(offsetof(Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE, ___key_2)); }
inline RuntimeObject * get_key_2() const { return ___key_2; }
inline RuntimeObject ** get_address_of_key_2() { return &___key_2; }
inline void set_key_2(RuntimeObject * value)
{
___key_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_2), (void*)value);
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE, ___value_3)); }
inline int32_t get_value_3() const { return ___value_3; }
inline int32_t* get_address_of_value_3() { return &___value_3; }
inline void set_value_3(int32_t value)
{
___value_3 = value;
}
};
// System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>
struct Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA
{
public:
// System.Int32 System.Collections.Generic.Dictionary`2_Entry::hashCode
int32_t ___hashCode_0;
// System.Int32 System.Collections.Generic.Dictionary`2_Entry::next
int32_t ___next_1;
// TKey System.Collections.Generic.Dictionary`2_Entry::key
RuntimeObject * ___key_2;
// TValue System.Collections.Generic.Dictionary`2_Entry::value
RuntimeObject * ___value_3;
public:
inline static int32_t get_offset_of_hashCode_0() { return static_cast<int32_t>(offsetof(Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA, ___hashCode_0)); }
inline int32_t get_hashCode_0() const { return ___hashCode_0; }
inline int32_t* get_address_of_hashCode_0() { return &___hashCode_0; }
inline void set_hashCode_0(int32_t value)
{
___hashCode_0 = value;
}
inline static int32_t get_offset_of_next_1() { return static_cast<int32_t>(offsetof(Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA, ___next_1)); }
inline int32_t get_next_1() const { return ___next_1; }
inline int32_t* get_address_of_next_1() { return &___next_1; }
inline void set_next_1(int32_t value)
{
___next_1 = value;
}
inline static int32_t get_offset_of_key_2() { return static_cast<int32_t>(offsetof(Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA, ___key_2)); }
inline RuntimeObject * get_key_2() const { return ___key_2; }
inline RuntimeObject ** get_address_of_key_2() { return &___key_2; }
inline void set_key_2(RuntimeObject * value)
{
___key_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_2), (void*)value);
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA, ___value_3)); }
inline RuntimeObject * get_value_3() const { return ___value_3; }
inline RuntimeObject ** get_address_of_value_3() { return &___value_3; }
inline void set_value_3(RuntimeObject * value)
{
___value_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_3), (void*)value);
}
};
// System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>
struct Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29
{
public:
// System.Int32 System.Collections.Generic.Dictionary`2_Entry::hashCode
int32_t ___hashCode_0;
// System.Int32 System.Collections.Generic.Dictionary`2_Entry::next
int32_t ___next_1;
// TKey System.Collections.Generic.Dictionary`2_Entry::key
uint64_t ___key_2;
// TValue System.Collections.Generic.Dictionary`2_Entry::value
RuntimeObject * ___value_3;
public:
inline static int32_t get_offset_of_hashCode_0() { return static_cast<int32_t>(offsetof(Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29, ___hashCode_0)); }
inline int32_t get_hashCode_0() const { return ___hashCode_0; }
inline int32_t* get_address_of_hashCode_0() { return &___hashCode_0; }
inline void set_hashCode_0(int32_t value)
{
___hashCode_0 = value;
}
inline static int32_t get_offset_of_next_1() { return static_cast<int32_t>(offsetof(Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29, ___next_1)); }
inline int32_t get_next_1() const { return ___next_1; }
inline int32_t* get_address_of_next_1() { return &___next_1; }
inline void set_next_1(int32_t value)
{
___next_1 = value;
}
inline static int32_t get_offset_of_key_2() { return static_cast<int32_t>(offsetof(Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29, ___key_2)); }
inline uint64_t get_key_2() const { return ___key_2; }
inline uint64_t* get_address_of_key_2() { return &___key_2; }
inline void set_key_2(uint64_t value)
{
___key_2 = value;
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29, ___value_3)); }
inline RuntimeObject * get_value_3() const { return ___value_3; }
inline RuntimeObject ** get_address_of_value_3() { return &___value_3; }
inline void set_value_3(RuntimeObject * value)
{
___value_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_3), (void*)value);
}
};
// System.Collections.Generic.HashSet`1_Slot<System.Object>
struct Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279
{
public:
// System.Int32 System.Collections.Generic.HashSet`1_Slot::hashCode
int32_t ___hashCode_0;
// System.Int32 System.Collections.Generic.HashSet`1_Slot::next
int32_t ___next_1;
// T System.Collections.Generic.HashSet`1_Slot::value
RuntimeObject * ___value_2;
public:
inline static int32_t get_offset_of_hashCode_0() { return static_cast<int32_t>(offsetof(Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279, ___hashCode_0)); }
inline int32_t get_hashCode_0() const { return ___hashCode_0; }
inline int32_t* get_address_of_hashCode_0() { return &___hashCode_0; }
inline void set_hashCode_0(int32_t value)
{
___hashCode_0 = value;
}
inline static int32_t get_offset_of_next_1() { return static_cast<int32_t>(offsetof(Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279, ___next_1)); }
inline int32_t get_next_1() const { return ___next_1; }
inline int32_t* get_address_of_next_1() { return &___next_1; }
inline void set_next_1(int32_t value)
{
___next_1 = value;
}
inline static int32_t get_offset_of_value_2() { return static_cast<int32_t>(offsetof(Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279, ___value_2)); }
inline RuntimeObject * get_value_2() const { return ___value_2; }
inline RuntimeObject ** get_address_of_value_2() { return &___value_2; }
inline void set_value_2(RuntimeObject * value)
{
___value_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_2), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>
struct KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
int32_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE, ___key_0)); }
inline int32_t get_key_0() const { return ___key_0; }
inline int32_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(int32_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>
struct KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
RuntimeObject * ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
int32_t ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E, ___value_1)); }
inline int32_t get_value_1() const { return ___value_1; }
inline int32_t* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(int32_t value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>
struct KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
RuntimeObject * ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>
struct KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
uint64_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4, ___key_0)); }
inline uint64_t get_key_0() const { return ___key_0; }
inline uint64_t* get_address_of_key_0() { return &___key_0; }
inline void set_key_0(uint64_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Hashtable_bucket
struct bucket_t1C848488DF65838689F7773D46F9E7E8C881B083
{
public:
// System.Object System.Collections.Hashtable_bucket::key
RuntimeObject * ___key_0;
// System.Object System.Collections.Hashtable_bucket::val
RuntimeObject * ___val_1;
// System.Int32 System.Collections.Hashtable_bucket::hash_coll
int32_t ___hash_coll_2;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(bucket_t1C848488DF65838689F7773D46F9E7E8C881B083, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_val_1() { return static_cast<int32_t>(offsetof(bucket_t1C848488DF65838689F7773D46F9E7E8C881B083, ___val_1)); }
inline RuntimeObject * get_val_1() const { return ___val_1; }
inline RuntimeObject ** get_address_of_val_1() { return &___val_1; }
inline void set_val_1(RuntimeObject * value)
{
___val_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___val_1), (void*)value);
}
inline static int32_t get_offset_of_hash_coll_2() { return static_cast<int32_t>(offsetof(bucket_t1C848488DF65838689F7773D46F9E7E8C881B083, ___hash_coll_2)); }
inline int32_t get_hash_coll_2() const { return ___hash_coll_2; }
inline int32_t* get_address_of_hash_coll_2() { return &___hash_coll_2; }
inline void set_hash_coll_2(int32_t value)
{
___hash_coll_2 = value;
}
};
// Native definition for P/Invoke marshalling of System.Collections.Hashtable/bucket
struct bucket_t1C848488DF65838689F7773D46F9E7E8C881B083_marshaled_pinvoke
{
Il2CppIUnknown* ___key_0;
Il2CppIUnknown* ___val_1;
int32_t ___hash_coll_2;
};
// Native definition for COM marshalling of System.Collections.Hashtable/bucket
struct bucket_t1C848488DF65838689F7773D46F9E7E8C881B083_marshaled_com
{
Il2CppIUnknown* ___key_0;
Il2CppIUnknown* ___val_1;
int32_t ___hash_coll_2;
};
// System.DateTime
struct DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132
{
public:
// System.UInt64 System.DateTime::dateData
uint64_t ___dateData_44;
public:
inline static int32_t get_offset_of_dateData_44() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132, ___dateData_44)); }
inline uint64_t get_dateData_44() const { return ___dateData_44; }
inline uint64_t* get_address_of_dateData_44() { return &___dateData_44; }
inline void set_dateData_44(uint64_t value)
{
___dateData_44 = value;
}
};
struct DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields
{
public:
// System.Int32[] System.DateTime::DaysToMonth365
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ___DaysToMonth365_29;
// System.Int32[] System.DateTime::DaysToMonth366
Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* ___DaysToMonth366_30;
// System.DateTime System.DateTime::MinValue
DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 ___MinValue_31;
// System.DateTime System.DateTime::MaxValue
DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 ___MaxValue_32;
public:
inline static int32_t get_offset_of_DaysToMonth365_29() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields, ___DaysToMonth365_29)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get_DaysToMonth365_29() const { return ___DaysToMonth365_29; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of_DaysToMonth365_29() { return &___DaysToMonth365_29; }
inline void set_DaysToMonth365_29(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
___DaysToMonth365_29 = value;
Il2CppCodeGenWriteBarrier((void**)(&___DaysToMonth365_29), (void*)value);
}
inline static int32_t get_offset_of_DaysToMonth366_30() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields, ___DaysToMonth366_30)); }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* get_DaysToMonth366_30() const { return ___DaysToMonth366_30; }
inline Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83** get_address_of_DaysToMonth366_30() { return &___DaysToMonth366_30; }
inline void set_DaysToMonth366_30(Int32U5BU5D_t2B9E4FDDDB9F0A00EC0AC631BA2DA915EB1ECF83* value)
{
___DaysToMonth366_30 = value;
Il2CppCodeGenWriteBarrier((void**)(&___DaysToMonth366_30), (void*)value);
}
inline static int32_t get_offset_of_MinValue_31() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields, ___MinValue_31)); }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 get_MinValue_31() const { return ___MinValue_31; }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 * get_address_of_MinValue_31() { return &___MinValue_31; }
inline void set_MinValue_31(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 value)
{
___MinValue_31 = value;
}
inline static int32_t get_offset_of_MaxValue_32() { return static_cast<int32_t>(offsetof(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132_StaticFields, ___MaxValue_32)); }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 get_MaxValue_32() const { return ___MaxValue_32; }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 * get_address_of_MaxValue_32() { return &___MaxValue_32; }
inline void set_MaxValue_32(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 value)
{
___MaxValue_32 = value;
}
};
// System.Decimal
struct Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8
{
public:
// System.Int32 System.Decimal::flags
int32_t ___flags_14;
// System.Int32 System.Decimal::hi
int32_t ___hi_15;
// System.Int32 System.Decimal::lo
int32_t ___lo_16;
// System.Int32 System.Decimal::mid
int32_t ___mid_17;
public:
inline static int32_t get_offset_of_flags_14() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8, ___flags_14)); }
inline int32_t get_flags_14() const { return ___flags_14; }
inline int32_t* get_address_of_flags_14() { return &___flags_14; }
inline void set_flags_14(int32_t value)
{
___flags_14 = value;
}
inline static int32_t get_offset_of_hi_15() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8, ___hi_15)); }
inline int32_t get_hi_15() const { return ___hi_15; }
inline int32_t* get_address_of_hi_15() { return &___hi_15; }
inline void set_hi_15(int32_t value)
{
___hi_15 = value;
}
inline static int32_t get_offset_of_lo_16() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8, ___lo_16)); }
inline int32_t get_lo_16() const { return ___lo_16; }
inline int32_t* get_address_of_lo_16() { return &___lo_16; }
inline void set_lo_16(int32_t value)
{
___lo_16 = value;
}
inline static int32_t get_offset_of_mid_17() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8, ___mid_17)); }
inline int32_t get_mid_17() const { return ___mid_17; }
inline int32_t* get_address_of_mid_17() { return &___mid_17; }
inline void set_mid_17(int32_t value)
{
___mid_17 = value;
}
};
struct Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields
{
public:
// System.UInt32[] System.Decimal::Powers10
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___Powers10_6;
// System.Decimal System.Decimal::Zero
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 ___Zero_7;
// System.Decimal System.Decimal::One
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 ___One_8;
// System.Decimal System.Decimal::MinusOne
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 ___MinusOne_9;
// System.Decimal System.Decimal::MaxValue
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 ___MaxValue_10;
// System.Decimal System.Decimal::MinValue
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 ___MinValue_11;
// System.Decimal System.Decimal::NearNegativeZero
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 ___NearNegativeZero_12;
// System.Decimal System.Decimal::NearPositiveZero
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 ___NearPositiveZero_13;
public:
inline static int32_t get_offset_of_Powers10_6() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___Powers10_6)); }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* get_Powers10_6() const { return ___Powers10_6; }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB** get_address_of_Powers10_6() { return &___Powers10_6; }
inline void set_Powers10_6(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* value)
{
___Powers10_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Powers10_6), (void*)value);
}
inline static int32_t get_offset_of_Zero_7() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___Zero_7)); }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 get_Zero_7() const { return ___Zero_7; }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 * get_address_of_Zero_7() { return &___Zero_7; }
inline void set_Zero_7(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 value)
{
___Zero_7 = value;
}
inline static int32_t get_offset_of_One_8() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___One_8)); }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 get_One_8() const { return ___One_8; }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 * get_address_of_One_8() { return &___One_8; }
inline void set_One_8(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 value)
{
___One_8 = value;
}
inline static int32_t get_offset_of_MinusOne_9() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___MinusOne_9)); }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 get_MinusOne_9() const { return ___MinusOne_9; }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 * get_address_of_MinusOne_9() { return &___MinusOne_9; }
inline void set_MinusOne_9(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 value)
{
___MinusOne_9 = value;
}
inline static int32_t get_offset_of_MaxValue_10() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___MaxValue_10)); }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 get_MaxValue_10() const { return ___MaxValue_10; }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 * get_address_of_MaxValue_10() { return &___MaxValue_10; }
inline void set_MaxValue_10(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 value)
{
___MaxValue_10 = value;
}
inline static int32_t get_offset_of_MinValue_11() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___MinValue_11)); }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 get_MinValue_11() const { return ___MinValue_11; }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 * get_address_of_MinValue_11() { return &___MinValue_11; }
inline void set_MinValue_11(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 value)
{
___MinValue_11 = value;
}
inline static int32_t get_offset_of_NearNegativeZero_12() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___NearNegativeZero_12)); }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 get_NearNegativeZero_12() const { return ___NearNegativeZero_12; }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 * get_address_of_NearNegativeZero_12() { return &___NearNegativeZero_12; }
inline void set_NearNegativeZero_12(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 value)
{
___NearNegativeZero_12 = value;
}
inline static int32_t get_offset_of_NearPositiveZero_13() { return static_cast<int32_t>(offsetof(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8_StaticFields, ___NearPositiveZero_13)); }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 get_NearPositiveZero_13() const { return ___NearPositiveZero_13; }
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 * get_address_of_NearPositiveZero_13() { return &___NearPositiveZero_13; }
inline void set_NearPositiveZero_13(Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 value)
{
___NearPositiveZero_13 = value;
}
};
// System.Diagnostics.Tracing.EventDescriptor
struct EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E
{
public:
union
{
struct
{
union
{
#pragma pack(push, tp, 1)
struct
{
// System.Int32 System.Diagnostics.Tracing.EventDescriptor::m_traceloggingId
int32_t ___m_traceloggingId_0;
};
#pragma pack(pop, tp)
struct
{
int32_t ___m_traceloggingId_0_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
// System.UInt16 System.Diagnostics.Tracing.EventDescriptor::m_id
uint16_t ___m_id_1;
};
#pragma pack(pop, tp)
struct
{
uint16_t ___m_id_1_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___m_version_2_OffsetPadding[2];
// System.Byte System.Diagnostics.Tracing.EventDescriptor::m_version
uint8_t ___m_version_2;
};
#pragma pack(pop, tp)
struct
{
char ___m_version_2_OffsetPadding_forAlignmentOnly[2];
uint8_t ___m_version_2_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___m_channel_3_OffsetPadding[3];
// System.Byte System.Diagnostics.Tracing.EventDescriptor::m_channel
uint8_t ___m_channel_3;
};
#pragma pack(pop, tp)
struct
{
char ___m_channel_3_OffsetPadding_forAlignmentOnly[3];
uint8_t ___m_channel_3_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___m_level_4_OffsetPadding[4];
// System.Byte System.Diagnostics.Tracing.EventDescriptor::m_level
uint8_t ___m_level_4;
};
#pragma pack(pop, tp)
struct
{
char ___m_level_4_OffsetPadding_forAlignmentOnly[4];
uint8_t ___m_level_4_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___m_opcode_5_OffsetPadding[5];
// System.Byte System.Diagnostics.Tracing.EventDescriptor::m_opcode
uint8_t ___m_opcode_5;
};
#pragma pack(pop, tp)
struct
{
char ___m_opcode_5_OffsetPadding_forAlignmentOnly[5];
uint8_t ___m_opcode_5_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___m_task_6_OffsetPadding[6];
// System.UInt16 System.Diagnostics.Tracing.EventDescriptor::m_task
uint16_t ___m_task_6;
};
#pragma pack(pop, tp)
struct
{
char ___m_task_6_OffsetPadding_forAlignmentOnly[6];
uint16_t ___m_task_6_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___m_keywords_7_OffsetPadding[8];
// System.Int64 System.Diagnostics.Tracing.EventDescriptor::m_keywords
int64_t ___m_keywords_7;
};
#pragma pack(pop, tp)
struct
{
char ___m_keywords_7_OffsetPadding_forAlignmentOnly[8];
int64_t ___m_keywords_7_forAlignmentOnly;
};
};
};
uint8_t EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E__padding[16];
};
public:
inline static int32_t get_offset_of_m_traceloggingId_0() { return static_cast<int32_t>(offsetof(EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E, ___m_traceloggingId_0)); }
inline int32_t get_m_traceloggingId_0() const { return ___m_traceloggingId_0; }
inline int32_t* get_address_of_m_traceloggingId_0() { return &___m_traceloggingId_0; }
inline void set_m_traceloggingId_0(int32_t value)
{
___m_traceloggingId_0 = value;
}
inline static int32_t get_offset_of_m_id_1() { return static_cast<int32_t>(offsetof(EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E, ___m_id_1)); }
inline uint16_t get_m_id_1() const { return ___m_id_1; }
inline uint16_t* get_address_of_m_id_1() { return &___m_id_1; }
inline void set_m_id_1(uint16_t value)
{
___m_id_1 = value;
}
inline static int32_t get_offset_of_m_version_2() { return static_cast<int32_t>(offsetof(EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E, ___m_version_2)); }
inline uint8_t get_m_version_2() const { return ___m_version_2; }
inline uint8_t* get_address_of_m_version_2() { return &___m_version_2; }
inline void set_m_version_2(uint8_t value)
{
___m_version_2 = value;
}
inline static int32_t get_offset_of_m_channel_3() { return static_cast<int32_t>(offsetof(EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E, ___m_channel_3)); }
inline uint8_t get_m_channel_3() const { return ___m_channel_3; }
inline uint8_t* get_address_of_m_channel_3() { return &___m_channel_3; }
inline void set_m_channel_3(uint8_t value)
{
___m_channel_3 = value;
}
inline static int32_t get_offset_of_m_level_4() { return static_cast<int32_t>(offsetof(EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E, ___m_level_4)); }
inline uint8_t get_m_level_4() const { return ___m_level_4; }
inline uint8_t* get_address_of_m_level_4() { return &___m_level_4; }
inline void set_m_level_4(uint8_t value)
{
___m_level_4 = value;
}
inline static int32_t get_offset_of_m_opcode_5() { return static_cast<int32_t>(offsetof(EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E, ___m_opcode_5)); }
inline uint8_t get_m_opcode_5() const { return ___m_opcode_5; }
inline uint8_t* get_address_of_m_opcode_5() { return &___m_opcode_5; }
inline void set_m_opcode_5(uint8_t value)
{
___m_opcode_5 = value;
}
inline static int32_t get_offset_of_m_task_6() { return static_cast<int32_t>(offsetof(EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E, ___m_task_6)); }
inline uint16_t get_m_task_6() const { return ___m_task_6; }
inline uint16_t* get_address_of_m_task_6() { return &___m_task_6; }
inline void set_m_task_6(uint16_t value)
{
___m_task_6 = value;
}
inline static int32_t get_offset_of_m_keywords_7() { return static_cast<int32_t>(offsetof(EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E, ___m_keywords_7)); }
inline int64_t get_m_keywords_7() const { return ___m_keywords_7; }
inline int64_t* get_address_of_m_keywords_7() { return &___m_keywords_7; }
inline void set_m_keywords_7(int64_t value)
{
___m_keywords_7 = value;
}
};
// System.Diagnostics.Tracing.EventProvider_SessionInfo
struct SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A
{
public:
// System.Int32 System.Diagnostics.Tracing.EventProvider_SessionInfo::sessionIdBit
int32_t ___sessionIdBit_0;
// System.Int32 System.Diagnostics.Tracing.EventProvider_SessionInfo::etwSessionId
int32_t ___etwSessionId_1;
public:
inline static int32_t get_offset_of_sessionIdBit_0() { return static_cast<int32_t>(offsetof(SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A, ___sessionIdBit_0)); }
inline int32_t get_sessionIdBit_0() const { return ___sessionIdBit_0; }
inline int32_t* get_address_of_sessionIdBit_0() { return &___sessionIdBit_0; }
inline void set_sessionIdBit_0(int32_t value)
{
___sessionIdBit_0 = value;
}
inline static int32_t get_offset_of_etwSessionId_1() { return static_cast<int32_t>(offsetof(SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A, ___etwSessionId_1)); }
inline int32_t get_etwSessionId_1() const { return ___etwSessionId_1; }
inline int32_t* get_address_of_etwSessionId_1() { return &___etwSessionId_1; }
inline void set_etwSessionId_1(int32_t value)
{
___etwSessionId_1 = value;
}
};
// System.Double
struct Double_t358B8F23BDC52A5DD700E727E204F9F7CDE12409
{
public:
// System.Double System.Double::m_value
double ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Double_t358B8F23BDC52A5DD700E727E204F9F7CDE12409, ___m_value_0)); }
inline double get_m_value_0() const { return ___m_value_0; }
inline double* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(double value)
{
___m_value_0 = value;
}
};
struct Double_t358B8F23BDC52A5DD700E727E204F9F7CDE12409_StaticFields
{
public:
// System.Double System.Double::NegativeZero
double ___NegativeZero_7;
public:
inline static int32_t get_offset_of_NegativeZero_7() { return static_cast<int32_t>(offsetof(Double_t358B8F23BDC52A5DD700E727E204F9F7CDE12409_StaticFields, ___NegativeZero_7)); }
inline double get_NegativeZero_7() const { return ___NegativeZero_7; }
inline double* get_address_of_NegativeZero_7() { return &___NegativeZero_7; }
inline void set_NegativeZero_7(double value)
{
___NegativeZero_7 = value;
}
};
// System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521 : public ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF
{
public:
public:
};
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_StaticFields
{
public:
// System.Char[] System.Enum::enumSeperatorCharArray
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* ___enumSeperatorCharArray_0;
public:
inline static int32_t get_offset_of_enumSeperatorCharArray_0() { return static_cast<int32_t>(offsetof(Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_StaticFields, ___enumSeperatorCharArray_0)); }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* get_enumSeperatorCharArray_0() const { return ___enumSeperatorCharArray_0; }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2** get_address_of_enumSeperatorCharArray_0() { return &___enumSeperatorCharArray_0; }
inline void set_enumSeperatorCharArray_0(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* value)
{
___enumSeperatorCharArray_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___enumSeperatorCharArray_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_marshaled_com
{
};
// System.Globalization.InternalCodePageDataItem
struct InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4
{
public:
// System.UInt16 System.Globalization.InternalCodePageDataItem::codePage
uint16_t ___codePage_0;
// System.UInt16 System.Globalization.InternalCodePageDataItem::uiFamilyCodePage
uint16_t ___uiFamilyCodePage_1;
// System.UInt32 System.Globalization.InternalCodePageDataItem::flags
uint32_t ___flags_2;
// System.String System.Globalization.InternalCodePageDataItem::Names
String_t* ___Names_3;
public:
inline static int32_t get_offset_of_codePage_0() { return static_cast<int32_t>(offsetof(InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4, ___codePage_0)); }
inline uint16_t get_codePage_0() const { return ___codePage_0; }
inline uint16_t* get_address_of_codePage_0() { return &___codePage_0; }
inline void set_codePage_0(uint16_t value)
{
___codePage_0 = value;
}
inline static int32_t get_offset_of_uiFamilyCodePage_1() { return static_cast<int32_t>(offsetof(InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4, ___uiFamilyCodePage_1)); }
inline uint16_t get_uiFamilyCodePage_1() const { return ___uiFamilyCodePage_1; }
inline uint16_t* get_address_of_uiFamilyCodePage_1() { return &___uiFamilyCodePage_1; }
inline void set_uiFamilyCodePage_1(uint16_t value)
{
___uiFamilyCodePage_1 = value;
}
inline static int32_t get_offset_of_flags_2() { return static_cast<int32_t>(offsetof(InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4, ___flags_2)); }
inline uint32_t get_flags_2() const { return ___flags_2; }
inline uint32_t* get_address_of_flags_2() { return &___flags_2; }
inline void set_flags_2(uint32_t value)
{
___flags_2 = value;
}
inline static int32_t get_offset_of_Names_3() { return static_cast<int32_t>(offsetof(InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4, ___Names_3)); }
inline String_t* get_Names_3() const { return ___Names_3; }
inline String_t** get_address_of_Names_3() { return &___Names_3; }
inline void set_Names_3(String_t* value)
{
___Names_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Names_3), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Globalization.InternalCodePageDataItem
struct InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4_marshaled_pinvoke
{
uint16_t ___codePage_0;
uint16_t ___uiFamilyCodePage_1;
uint32_t ___flags_2;
char* ___Names_3;
};
// Native definition for COM marshalling of System.Globalization.InternalCodePageDataItem
struct InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4_marshaled_com
{
uint16_t ___codePage_0;
uint16_t ___uiFamilyCodePage_1;
uint32_t ___flags_2;
Il2CppChar* ___Names_3;
};
// System.Globalization.InternalEncodingDataItem
struct InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211
{
public:
// System.String System.Globalization.InternalEncodingDataItem::webName
String_t* ___webName_0;
// System.UInt16 System.Globalization.InternalEncodingDataItem::codePage
uint16_t ___codePage_1;
public:
inline static int32_t get_offset_of_webName_0() { return static_cast<int32_t>(offsetof(InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211, ___webName_0)); }
inline String_t* get_webName_0() const { return ___webName_0; }
inline String_t** get_address_of_webName_0() { return &___webName_0; }
inline void set_webName_0(String_t* value)
{
___webName_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___webName_0), (void*)value);
}
inline static int32_t get_offset_of_codePage_1() { return static_cast<int32_t>(offsetof(InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211, ___codePage_1)); }
inline uint16_t get_codePage_1() const { return ___codePage_1; }
inline uint16_t* get_address_of_codePage_1() { return &___codePage_1; }
inline void set_codePage_1(uint16_t value)
{
___codePage_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Globalization.InternalEncodingDataItem
struct InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211_marshaled_pinvoke
{
char* ___webName_0;
uint16_t ___codePage_1;
};
// Native definition for COM marshalling of System.Globalization.InternalEncodingDataItem
struct InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211_marshaled_com
{
Il2CppChar* ___webName_0;
uint16_t ___codePage_1;
};
// System.Guid
struct Guid_t
{
public:
// System.Int32 System.Guid::_a
int32_t ____a_1;
// System.Int16 System.Guid::_b
int16_t ____b_2;
// System.Int16 System.Guid::_c
int16_t ____c_3;
// System.Byte System.Guid::_d
uint8_t ____d_4;
// System.Byte System.Guid::_e
uint8_t ____e_5;
// System.Byte System.Guid::_f
uint8_t ____f_6;
// System.Byte System.Guid::_g
uint8_t ____g_7;
// System.Byte System.Guid::_h
uint8_t ____h_8;
// System.Byte System.Guid::_i
uint8_t ____i_9;
// System.Byte System.Guid::_j
uint8_t ____j_10;
// System.Byte System.Guid::_k
uint8_t ____k_11;
public:
inline static int32_t get_offset_of__a_1() { return static_cast<int32_t>(offsetof(Guid_t, ____a_1)); }
inline int32_t get__a_1() const { return ____a_1; }
inline int32_t* get_address_of__a_1() { return &____a_1; }
inline void set__a_1(int32_t value)
{
____a_1 = value;
}
inline static int32_t get_offset_of__b_2() { return static_cast<int32_t>(offsetof(Guid_t, ____b_2)); }
inline int16_t get__b_2() const { return ____b_2; }
inline int16_t* get_address_of__b_2() { return &____b_2; }
inline void set__b_2(int16_t value)
{
____b_2 = value;
}
inline static int32_t get_offset_of__c_3() { return static_cast<int32_t>(offsetof(Guid_t, ____c_3)); }
inline int16_t get__c_3() const { return ____c_3; }
inline int16_t* get_address_of__c_3() { return &____c_3; }
inline void set__c_3(int16_t value)
{
____c_3 = value;
}
inline static int32_t get_offset_of__d_4() { return static_cast<int32_t>(offsetof(Guid_t, ____d_4)); }
inline uint8_t get__d_4() const { return ____d_4; }
inline uint8_t* get_address_of__d_4() { return &____d_4; }
inline void set__d_4(uint8_t value)
{
____d_4 = value;
}
inline static int32_t get_offset_of__e_5() { return static_cast<int32_t>(offsetof(Guid_t, ____e_5)); }
inline uint8_t get__e_5() const { return ____e_5; }
inline uint8_t* get_address_of__e_5() { return &____e_5; }
inline void set__e_5(uint8_t value)
{
____e_5 = value;
}
inline static int32_t get_offset_of__f_6() { return static_cast<int32_t>(offsetof(Guid_t, ____f_6)); }
inline uint8_t get__f_6() const { return ____f_6; }
inline uint8_t* get_address_of__f_6() { return &____f_6; }
inline void set__f_6(uint8_t value)
{
____f_6 = value;
}
inline static int32_t get_offset_of__g_7() { return static_cast<int32_t>(offsetof(Guid_t, ____g_7)); }
inline uint8_t get__g_7() const { return ____g_7; }
inline uint8_t* get_address_of__g_7() { return &____g_7; }
inline void set__g_7(uint8_t value)
{
____g_7 = value;
}
inline static int32_t get_offset_of__h_8() { return static_cast<int32_t>(offsetof(Guid_t, ____h_8)); }
inline uint8_t get__h_8() const { return ____h_8; }
inline uint8_t* get_address_of__h_8() { return &____h_8; }
inline void set__h_8(uint8_t value)
{
____h_8 = value;
}
inline static int32_t get_offset_of__i_9() { return static_cast<int32_t>(offsetof(Guid_t, ____i_9)); }
inline uint8_t get__i_9() const { return ____i_9; }
inline uint8_t* get_address_of__i_9() { return &____i_9; }
inline void set__i_9(uint8_t value)
{
____i_9 = value;
}
inline static int32_t get_offset_of__j_10() { return static_cast<int32_t>(offsetof(Guid_t, ____j_10)); }
inline uint8_t get__j_10() const { return ____j_10; }
inline uint8_t* get_address_of__j_10() { return &____j_10; }
inline void set__j_10(uint8_t value)
{
____j_10 = value;
}
inline static int32_t get_offset_of__k_11() { return static_cast<int32_t>(offsetof(Guid_t, ____k_11)); }
inline uint8_t get__k_11() const { return ____k_11; }
inline uint8_t* get_address_of__k_11() { return &____k_11; }
inline void set__k_11(uint8_t value)
{
____k_11 = value;
}
};
struct Guid_t_StaticFields
{
public:
// System.Guid System.Guid::Empty
Guid_t ___Empty_0;
// System.Object System.Guid::_rngAccess
RuntimeObject * ____rngAccess_12;
// System.Security.Cryptography.RandomNumberGenerator System.Guid::_rng
RandomNumberGenerator_t12277F7F965BA79C54E4B3BFABD27A5FFB725EE2 * ____rng_13;
public:
inline static int32_t get_offset_of_Empty_0() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ___Empty_0)); }
inline Guid_t get_Empty_0() const { return ___Empty_0; }
inline Guid_t * get_address_of_Empty_0() { return &___Empty_0; }
inline void set_Empty_0(Guid_t value)
{
___Empty_0 = value;
}
inline static int32_t get_offset_of__rngAccess_12() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ____rngAccess_12)); }
inline RuntimeObject * get__rngAccess_12() const { return ____rngAccess_12; }
inline RuntimeObject ** get_address_of__rngAccess_12() { return &____rngAccess_12; }
inline void set__rngAccess_12(RuntimeObject * value)
{
____rngAccess_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rngAccess_12), (void*)value);
}
inline static int32_t get_offset_of__rng_13() { return static_cast<int32_t>(offsetof(Guid_t_StaticFields, ____rng_13)); }
inline RandomNumberGenerator_t12277F7F965BA79C54E4B3BFABD27A5FFB725EE2 * get__rng_13() const { return ____rng_13; }
inline RandomNumberGenerator_t12277F7F965BA79C54E4B3BFABD27A5FFB725EE2 ** get_address_of__rng_13() { return &____rng_13; }
inline void set__rng_13(RandomNumberGenerator_t12277F7F965BA79C54E4B3BFABD27A5FFB725EE2 * value)
{
____rng_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rng_13), (void*)value);
}
};
// System.Int16
struct Int16_t823A20635DAF5A3D93A1E01CFBF3CBA27CF00B4D
{
public:
// System.Int16 System.Int16::m_value
int16_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int16_t823A20635DAF5A3D93A1E01CFBF3CBA27CF00B4D, ___m_value_0)); }
inline int16_t get_m_value_0() const { return ___m_value_0; }
inline int16_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int16_t value)
{
___m_value_0 = value;
}
};
// System.Int32
struct Int32_t585191389E07734F19F3156FF88FB3EF4800D102
{
public:
// System.Int32 System.Int32::m_value
int32_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int32_t585191389E07734F19F3156FF88FB3EF4800D102, ___m_value_0)); }
inline int32_t get_m_value_0() const { return ___m_value_0; }
inline int32_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int32_t value)
{
___m_value_0 = value;
}
};
// System.Int64
struct Int64_t7A386C2FF7B0280A0F516992401DDFCF0FF7B436
{
public:
// System.Int64 System.Int64::m_value
int64_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int64_t7A386C2FF7B0280A0F516992401DDFCF0FF7B436, ___m_value_0)); }
inline int64_t get_m_value_0() const { return ___m_value_0; }
inline int64_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int64_t value)
{
___m_value_0 = value;
}
};
// System.IntPtr
struct IntPtr_t
{
public:
// System.Void* System.IntPtr::m_value
void* ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(IntPtr_t, ___m_value_0)); }
inline void* get_m_value_0() const { return ___m_value_0; }
inline void** get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(void* value)
{
___m_value_0 = value;
}
};
struct IntPtr_t_StaticFields
{
public:
// System.IntPtr System.IntPtr::Zero
intptr_t ___Zero_1;
public:
inline static int32_t get_offset_of_Zero_1() { return static_cast<int32_t>(offsetof(IntPtr_t_StaticFields, ___Zero_1)); }
inline intptr_t get_Zero_1() const { return ___Zero_1; }
inline intptr_t* get_address_of_Zero_1() { return &___Zero_1; }
inline void set_Zero_1(intptr_t value)
{
___Zero_1 = value;
}
};
// System.ParameterizedStrings_FormatParam
struct FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800
{
public:
// System.Int32 System.ParameterizedStrings_FormatParam::_int32
int32_t ____int32_0;
// System.String System.ParameterizedStrings_FormatParam::_string
String_t* ____string_1;
public:
inline static int32_t get_offset_of__int32_0() { return static_cast<int32_t>(offsetof(FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800, ____int32_0)); }
inline int32_t get__int32_0() const { return ____int32_0; }
inline int32_t* get_address_of__int32_0() { return &____int32_0; }
inline void set__int32_0(int32_t value)
{
____int32_0 = value;
}
inline static int32_t get_offset_of__string_1() { return static_cast<int32_t>(offsetof(FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800, ____string_1)); }
inline String_t* get__string_1() const { return ____string_1; }
inline String_t** get_address_of__string_1() { return &____string_1; }
inline void set__string_1(String_t* value)
{
____string_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____string_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.ParameterizedStrings/FormatParam
struct FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800_marshaled_pinvoke
{
int32_t ____int32_0;
char* ____string_1;
};
// Native definition for COM marshalling of System.ParameterizedStrings/FormatParam
struct FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800_marshaled_com
{
int32_t ____int32_0;
Il2CppChar* ____string_1;
};
// System.Reflection.CustomAttributeTypedArgument
struct CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8
{
public:
// System.Type System.Reflection.CustomAttributeTypedArgument::argumentType
Type_t * ___argumentType_0;
// System.Object System.Reflection.CustomAttributeTypedArgument::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_argumentType_0() { return static_cast<int32_t>(offsetof(CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8, ___argumentType_0)); }
inline Type_t * get_argumentType_0() const { return ___argumentType_0; }
inline Type_t ** get_address_of_argumentType_0() { return &___argumentType_0; }
inline void set_argumentType_0(Type_t * value)
{
___argumentType_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___argumentType_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Reflection.CustomAttributeTypedArgument
struct CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8_marshaled_pinvoke
{
Type_t * ___argumentType_0;
Il2CppIUnknown* ___value_1;
};
// Native definition for COM marshalling of System.Reflection.CustomAttributeTypedArgument
struct CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8_marshaled_com
{
Type_t * ___argumentType_0;
Il2CppIUnknown* ___value_1;
};
// System.Reflection.ParameterModifier
struct ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E
{
public:
// System.Boolean[] System.Reflection.ParameterModifier::_byRef
BooleanU5BU5D_t192C7579715690E25BD5EFED47F3E0FC9DCB2040* ____byRef_0;
public:
inline static int32_t get_offset_of__byRef_0() { return static_cast<int32_t>(offsetof(ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E, ____byRef_0)); }
inline BooleanU5BU5D_t192C7579715690E25BD5EFED47F3E0FC9DCB2040* get__byRef_0() const { return ____byRef_0; }
inline BooleanU5BU5D_t192C7579715690E25BD5EFED47F3E0FC9DCB2040** get_address_of__byRef_0() { return &____byRef_0; }
inline void set__byRef_0(BooleanU5BU5D_t192C7579715690E25BD5EFED47F3E0FC9DCB2040* value)
{
____byRef_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____byRef_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Reflection.ParameterModifier
struct ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E_marshaled_pinvoke
{
int32_t* ____byRef_0;
};
// Native definition for COM marshalling of System.Reflection.ParameterModifier
struct ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E_marshaled_com
{
int32_t* ____byRef_0;
};
// System.Resources.ResourceLocator
struct ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C
{
public:
// System.Object System.Resources.ResourceLocator::_value
RuntimeObject * ____value_0;
// System.Int32 System.Resources.ResourceLocator::_dataPos
int32_t ____dataPos_1;
public:
inline static int32_t get_offset_of__value_0() { return static_cast<int32_t>(offsetof(ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C, ____value_0)); }
inline RuntimeObject * get__value_0() const { return ____value_0; }
inline RuntimeObject ** get_address_of__value_0() { return &____value_0; }
inline void set__value_0(RuntimeObject * value)
{
____value_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____value_0), (void*)value);
}
inline static int32_t get_offset_of__dataPos_1() { return static_cast<int32_t>(offsetof(ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C, ____dataPos_1)); }
inline int32_t get__dataPos_1() const { return ____dataPos_1; }
inline int32_t* get_address_of__dataPos_1() { return &____dataPos_1; }
inline void set__dataPos_1(int32_t value)
{
____dataPos_1 = value;
}
};
// Native definition for P/Invoke marshalling of System.Resources.ResourceLocator
struct ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C_marshaled_pinvoke
{
Il2CppIUnknown* ____value_0;
int32_t ____dataPos_1;
};
// Native definition for COM marshalling of System.Resources.ResourceLocator
struct ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C_marshaled_com
{
Il2CppIUnknown* ____value_0;
int32_t ____dataPos_1;
};
// System.Runtime.CompilerServices.Ephemeron
struct Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA
{
public:
// System.Object System.Runtime.CompilerServices.Ephemeron::key
RuntimeObject * ___key_0;
// System.Object System.Runtime.CompilerServices.Ephemeron::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Runtime.CompilerServices.Ephemeron
struct Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA_marshaled_pinvoke
{
Il2CppIUnknown* ___key_0;
Il2CppIUnknown* ___value_1;
};
// Native definition for COM marshalling of System.Runtime.CompilerServices.Ephemeron
struct Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA_marshaled_com
{
Il2CppIUnknown* ___key_0;
Il2CppIUnknown* ___value_1;
};
// System.Runtime.InteropServices.GCHandle
struct GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3
{
public:
// System.Int32 System.Runtime.InteropServices.GCHandle::handle
int32_t ___handle_0;
public:
inline static int32_t get_offset_of_handle_0() { return static_cast<int32_t>(offsetof(GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3, ___handle_0)); }
inline int32_t get_handle_0() const { return ___handle_0; }
inline int32_t* get_address_of_handle_0() { return &___handle_0; }
inline void set_handle_0(int32_t value)
{
___handle_0 = value;
}
};
// System.SByte
struct SByte_t9070AEA2966184235653CB9B4D33B149CDA831DF
{
public:
// System.SByte System.SByte::m_value
int8_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(SByte_t9070AEA2966184235653CB9B4D33B149CDA831DF, ___m_value_0)); }
inline int8_t get_m_value_0() const { return ___m_value_0; }
inline int8_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int8_t value)
{
___m_value_0 = value;
}
};
// System.Single
struct Single_tDDDA9169C4E4E308AC6D7A824F9B28DC82204AE1
{
public:
// System.Single System.Single::m_value
float ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Single_tDDDA9169C4E4E308AC6D7A824F9B28DC82204AE1, ___m_value_0)); }
inline float get_m_value_0() const { return ___m_value_0; }
inline float* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(float value)
{
___m_value_0 = value;
}
};
// System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping
struct LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B
{
public:
// System.Char System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping::_chMin
Il2CppChar ____chMin_0;
// System.Char System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping::_chMax
Il2CppChar ____chMax_1;
// System.Int32 System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping::_lcOp
int32_t ____lcOp_2;
// System.Int32 System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping::_data
int32_t ____data_3;
public:
inline static int32_t get_offset_of__chMin_0() { return static_cast<int32_t>(offsetof(LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B, ____chMin_0)); }
inline Il2CppChar get__chMin_0() const { return ____chMin_0; }
inline Il2CppChar* get_address_of__chMin_0() { return &____chMin_0; }
inline void set__chMin_0(Il2CppChar value)
{
____chMin_0 = value;
}
inline static int32_t get_offset_of__chMax_1() { return static_cast<int32_t>(offsetof(LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B, ____chMax_1)); }
inline Il2CppChar get__chMax_1() const { return ____chMax_1; }
inline Il2CppChar* get_address_of__chMax_1() { return &____chMax_1; }
inline void set__chMax_1(Il2CppChar value)
{
____chMax_1 = value;
}
inline static int32_t get_offset_of__lcOp_2() { return static_cast<int32_t>(offsetof(LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B, ____lcOp_2)); }
inline int32_t get__lcOp_2() const { return ____lcOp_2; }
inline int32_t* get_address_of__lcOp_2() { return &____lcOp_2; }
inline void set__lcOp_2(int32_t value)
{
____lcOp_2 = value;
}
inline static int32_t get_offset_of__data_3() { return static_cast<int32_t>(offsetof(LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B, ____data_3)); }
inline int32_t get__data_3() const { return ____data_3; }
inline int32_t* get_address_of__data_3() { return &____data_3; }
inline void set__data_3(int32_t value)
{
____data_3 = value;
}
};
// Native definition for P/Invoke marshalling of System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping
struct LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B_marshaled_pinvoke
{
uint8_t ____chMin_0;
uint8_t ____chMax_1;
int32_t ____lcOp_2;
int32_t ____data_3;
};
// Native definition for COM marshalling of System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping
struct LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B_marshaled_com
{
uint8_t ____chMin_0;
uint8_t ____chMax_1;
int32_t ____lcOp_2;
int32_t ____data_3;
};
// System.Threading.AsyncLocalValueChangedArgs`1<System.Object>
struct AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D
{
public:
// T System.Threading.AsyncLocalValueChangedArgs`1::<PreviousValue>k__BackingField
RuntimeObject * ___U3CPreviousValueU3Ek__BackingField_0;
// T System.Threading.AsyncLocalValueChangedArgs`1::<CurrentValue>k__BackingField
RuntimeObject * ___U3CCurrentValueU3Ek__BackingField_1;
// System.Boolean System.Threading.AsyncLocalValueChangedArgs`1::<ThreadContextChanged>k__BackingField
bool ___U3CThreadContextChangedU3Ek__BackingField_2;
public:
inline static int32_t get_offset_of_U3CPreviousValueU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D, ___U3CPreviousValueU3Ek__BackingField_0)); }
inline RuntimeObject * get_U3CPreviousValueU3Ek__BackingField_0() const { return ___U3CPreviousValueU3Ek__BackingField_0; }
inline RuntimeObject ** get_address_of_U3CPreviousValueU3Ek__BackingField_0() { return &___U3CPreviousValueU3Ek__BackingField_0; }
inline void set_U3CPreviousValueU3Ek__BackingField_0(RuntimeObject * value)
{
___U3CPreviousValueU3Ek__BackingField_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CPreviousValueU3Ek__BackingField_0), (void*)value);
}
inline static int32_t get_offset_of_U3CCurrentValueU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D, ___U3CCurrentValueU3Ek__BackingField_1)); }
inline RuntimeObject * get_U3CCurrentValueU3Ek__BackingField_1() const { return ___U3CCurrentValueU3Ek__BackingField_1; }
inline RuntimeObject ** get_address_of_U3CCurrentValueU3Ek__BackingField_1() { return &___U3CCurrentValueU3Ek__BackingField_1; }
inline void set_U3CCurrentValueU3Ek__BackingField_1(RuntimeObject * value)
{
___U3CCurrentValueU3Ek__BackingField_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___U3CCurrentValueU3Ek__BackingField_1), (void*)value);
}
inline static int32_t get_offset_of_U3CThreadContextChangedU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D, ___U3CThreadContextChangedU3Ek__BackingField_2)); }
inline bool get_U3CThreadContextChangedU3Ek__BackingField_2() const { return ___U3CThreadContextChangedU3Ek__BackingField_2; }
inline bool* get_address_of_U3CThreadContextChangedU3Ek__BackingField_2() { return &___U3CThreadContextChangedU3Ek__BackingField_2; }
inline void set_U3CThreadContextChangedU3Ek__BackingField_2(bool value)
{
___U3CThreadContextChangedU3Ek__BackingField_2 = value;
}
};
// System.Threading.SparselyPopulatedArrayAddInfo`1<System.Threading.CancellationCallbackInfo>
struct SparselyPopulatedArrayAddInfo_1_t0A76BDD84EBF76BEF894419FC221D25BB3D4FBEE
{
public:
// System.Threading.SparselyPopulatedArrayFragment`1<T> System.Threading.SparselyPopulatedArrayAddInfo`1::m_source
SparselyPopulatedArrayFragment_1_tA54224D01E2FDC03AC2867CDDC8C53E17FA933D7 * ___m_source_0;
// System.Int32 System.Threading.SparselyPopulatedArrayAddInfo`1::m_index
int32_t ___m_index_1;
public:
inline static int32_t get_offset_of_m_source_0() { return static_cast<int32_t>(offsetof(SparselyPopulatedArrayAddInfo_1_t0A76BDD84EBF76BEF894419FC221D25BB3D4FBEE, ___m_source_0)); }
inline SparselyPopulatedArrayFragment_1_tA54224D01E2FDC03AC2867CDDC8C53E17FA933D7 * get_m_source_0() const { return ___m_source_0; }
inline SparselyPopulatedArrayFragment_1_tA54224D01E2FDC03AC2867CDDC8C53E17FA933D7 ** get_address_of_m_source_0() { return &___m_source_0; }
inline void set_m_source_0(SparselyPopulatedArrayFragment_1_tA54224D01E2FDC03AC2867CDDC8C53E17FA933D7 * value)
{
___m_source_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_source_0), (void*)value);
}
inline static int32_t get_offset_of_m_index_1() { return static_cast<int32_t>(offsetof(SparselyPopulatedArrayAddInfo_1_t0A76BDD84EBF76BEF894419FC221D25BB3D4FBEE, ___m_index_1)); }
inline int32_t get_m_index_1() const { return ___m_index_1; }
inline int32_t* get_address_of_m_index_1() { return &___m_index_1; }
inline void set_m_index_1(int32_t value)
{
___m_index_1 = value;
}
};
// System.UInt16
struct UInt16_tAE45CEF73BF720100519F6867F32145D075F928E
{
public:
// System.UInt16 System.UInt16::m_value
uint16_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(UInt16_tAE45CEF73BF720100519F6867F32145D075F928E, ___m_value_0)); }
inline uint16_t get_m_value_0() const { return ___m_value_0; }
inline uint16_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint16_t value)
{
___m_value_0 = value;
}
};
// System.UInt32
struct UInt32_t4980FA09003AFAAB5A6E361BA2748EA9A005709B
{
public:
// System.UInt32 System.UInt32::m_value
uint32_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(UInt32_t4980FA09003AFAAB5A6E361BA2748EA9A005709B, ___m_value_0)); }
inline uint32_t get_m_value_0() const { return ___m_value_0; }
inline uint32_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint32_t value)
{
___m_value_0 = value;
}
};
// System.UInt64
struct UInt64_tA02DF3B59C8FC4A849BD207DA11038CC64E4CB4E
{
public:
// System.UInt64 System.UInt64::m_value
uint64_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(UInt64_tA02DF3B59C8FC4A849BD207DA11038CC64E4CB4E, ___m_value_0)); }
inline uint64_t get_m_value_0() const { return ___m_value_0; }
inline uint64_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint64_t value)
{
___m_value_0 = value;
}
};
// System.UIntPtr
struct UIntPtr_t
{
public:
// System.Void* System.UIntPtr::_pointer
void* ____pointer_1;
public:
inline static int32_t get_offset_of__pointer_1() { return static_cast<int32_t>(offsetof(UIntPtr_t, ____pointer_1)); }
inline void* get__pointer_1() const { return ____pointer_1; }
inline void** get_address_of__pointer_1() { return &____pointer_1; }
inline void set__pointer_1(void* value)
{
____pointer_1 = value;
}
};
struct UIntPtr_t_StaticFields
{
public:
// System.UIntPtr System.UIntPtr::Zero
uintptr_t ___Zero_0;
public:
inline static int32_t get_offset_of_Zero_0() { return static_cast<int32_t>(offsetof(UIntPtr_t_StaticFields, ___Zero_0)); }
inline uintptr_t get_Zero_0() const { return ___Zero_0; }
inline uintptr_t* get_address_of_Zero_0() { return &___Zero_0; }
inline void set_Zero_0(uintptr_t value)
{
___Zero_0 = value;
}
};
// System.Void
struct Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017
{
public:
union
{
struct
{
};
uint8_t Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017__padding[1];
};
public:
};
// UnityEngine.BeforeRenderHelper_OrderBlock
struct OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727
{
public:
// System.Int32 UnityEngine.BeforeRenderHelper_OrderBlock::order
int32_t ___order_0;
// UnityEngine.Events.UnityAction UnityEngine.BeforeRenderHelper_OrderBlock::callback
UnityAction_tD19B26F1B2C048E38FD5801A33573BE01064CAF4 * ___callback_1;
public:
inline static int32_t get_offset_of_order_0() { return static_cast<int32_t>(offsetof(OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727, ___order_0)); }
inline int32_t get_order_0() const { return ___order_0; }
inline int32_t* get_address_of_order_0() { return &___order_0; }
inline void set_order_0(int32_t value)
{
___order_0 = value;
}
inline static int32_t get_offset_of_callback_1() { return static_cast<int32_t>(offsetof(OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727, ___callback_1)); }
inline UnityAction_tD19B26F1B2C048E38FD5801A33573BE01064CAF4 * get_callback_1() const { return ___callback_1; }
inline UnityAction_tD19B26F1B2C048E38FD5801A33573BE01064CAF4 ** get_address_of_callback_1() { return &___callback_1; }
inline void set_callback_1(UnityAction_tD19B26F1B2C048E38FD5801A33573BE01064CAF4 * value)
{
___callback_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___callback_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.BeforeRenderHelper/OrderBlock
struct OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727_marshaled_pinvoke
{
int32_t ___order_0;
Il2CppMethodPointer ___callback_1;
};
// Native definition for COM marshalling of UnityEngine.BeforeRenderHelper/OrderBlock
struct OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727_marshaled_com
{
int32_t ___order_0;
Il2CppMethodPointer ___callback_1;
};
// UnityEngine.Color
struct Color_t119BCA590009762C7223FDD3AF9706653AC84ED2
{
public:
// System.Single UnityEngine.Color::r
float ___r_0;
// System.Single UnityEngine.Color::g
float ___g_1;
// System.Single UnityEngine.Color::b
float ___b_2;
// System.Single UnityEngine.Color::a
float ___a_3;
public:
inline static int32_t get_offset_of_r_0() { return static_cast<int32_t>(offsetof(Color_t119BCA590009762C7223FDD3AF9706653AC84ED2, ___r_0)); }
inline float get_r_0() const { return ___r_0; }
inline float* get_address_of_r_0() { return &___r_0; }
inline void set_r_0(float value)
{
___r_0 = value;
}
inline static int32_t get_offset_of_g_1() { return static_cast<int32_t>(offsetof(Color_t119BCA590009762C7223FDD3AF9706653AC84ED2, ___g_1)); }
inline float get_g_1() const { return ___g_1; }
inline float* get_address_of_g_1() { return &___g_1; }
inline void set_g_1(float value)
{
___g_1 = value;
}
inline static int32_t get_offset_of_b_2() { return static_cast<int32_t>(offsetof(Color_t119BCA590009762C7223FDD3AF9706653AC84ED2, ___b_2)); }
inline float get_b_2() const { return ___b_2; }
inline float* get_address_of_b_2() { return &___b_2; }
inline void set_b_2(float value)
{
___b_2 = value;
}
inline static int32_t get_offset_of_a_3() { return static_cast<int32_t>(offsetof(Color_t119BCA590009762C7223FDD3AF9706653AC84ED2, ___a_3)); }
inline float get_a_3() const { return ___a_3; }
inline float* get_address_of_a_3() { return &___a_3; }
inline void set_a_3(float value)
{
___a_3 = value;
}
};
// UnityEngine.Color32
struct Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23
{
public:
union
{
#pragma pack(push, tp, 1)
struct
{
// System.Int32 UnityEngine.Color32::rgba
int32_t ___rgba_0;
};
#pragma pack(pop, tp)
struct
{
int32_t ___rgba_0_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
// System.Byte UnityEngine.Color32::r
uint8_t ___r_1;
};
#pragma pack(pop, tp)
struct
{
uint8_t ___r_1_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___g_2_OffsetPadding[1];
// System.Byte UnityEngine.Color32::g
uint8_t ___g_2;
};
#pragma pack(pop, tp)
struct
{
char ___g_2_OffsetPadding_forAlignmentOnly[1];
uint8_t ___g_2_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___b_3_OffsetPadding[2];
// System.Byte UnityEngine.Color32::b
uint8_t ___b_3;
};
#pragma pack(pop, tp)
struct
{
char ___b_3_OffsetPadding_forAlignmentOnly[2];
uint8_t ___b_3_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___a_4_OffsetPadding[3];
// System.Byte UnityEngine.Color32::a
uint8_t ___a_4;
};
#pragma pack(pop, tp)
struct
{
char ___a_4_OffsetPadding_forAlignmentOnly[3];
uint8_t ___a_4_forAlignmentOnly;
};
};
public:
inline static int32_t get_offset_of_rgba_0() { return static_cast<int32_t>(offsetof(Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23, ___rgba_0)); }
inline int32_t get_rgba_0() const { return ___rgba_0; }
inline int32_t* get_address_of_rgba_0() { return &___rgba_0; }
inline void set_rgba_0(int32_t value)
{
___rgba_0 = value;
}
inline static int32_t get_offset_of_r_1() { return static_cast<int32_t>(offsetof(Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23, ___r_1)); }
inline uint8_t get_r_1() const { return ___r_1; }
inline uint8_t* get_address_of_r_1() { return &___r_1; }
inline void set_r_1(uint8_t value)
{
___r_1 = value;
}
inline static int32_t get_offset_of_g_2() { return static_cast<int32_t>(offsetof(Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23, ___g_2)); }
inline uint8_t get_g_2() const { return ___g_2; }
inline uint8_t* get_address_of_g_2() { return &___g_2; }
inline void set_g_2(uint8_t value)
{
___g_2 = value;
}
inline static int32_t get_offset_of_b_3() { return static_cast<int32_t>(offsetof(Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23, ___b_3)); }
inline uint8_t get_b_3() const { return ___b_3; }
inline uint8_t* get_address_of_b_3() { return &___b_3; }
inline void set_b_3(uint8_t value)
{
___b_3 = value;
}
inline static int32_t get_offset_of_a_4() { return static_cast<int32_t>(offsetof(Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23, ___a_4)); }
inline uint8_t get_a_4() const { return ___a_4; }
inline uint8_t* get_address_of_a_4() { return &___a_4; }
inline void set_a_4(uint8_t value)
{
___a_4 = value;
}
};
// UnityEngine.Experimental.GlobalIllumination.LinearColor
struct LinearColor_tB8D05FA20CBA5254EA4D27D2B47D7B067FE506CD
{
public:
// System.Single UnityEngine.Experimental.GlobalIllumination.LinearColor::m_red
float ___m_red_0;
// System.Single UnityEngine.Experimental.GlobalIllumination.LinearColor::m_green
float ___m_green_1;
// System.Single UnityEngine.Experimental.GlobalIllumination.LinearColor::m_blue
float ___m_blue_2;
// System.Single UnityEngine.Experimental.GlobalIllumination.LinearColor::m_intensity
float ___m_intensity_3;
public:
inline static int32_t get_offset_of_m_red_0() { return static_cast<int32_t>(offsetof(LinearColor_tB8D05FA20CBA5254EA4D27D2B47D7B067FE506CD, ___m_red_0)); }
inline float get_m_red_0() const { return ___m_red_0; }
inline float* get_address_of_m_red_0() { return &___m_red_0; }
inline void set_m_red_0(float value)
{
___m_red_0 = value;
}
inline static int32_t get_offset_of_m_green_1() { return static_cast<int32_t>(offsetof(LinearColor_tB8D05FA20CBA5254EA4D27D2B47D7B067FE506CD, ___m_green_1)); }
inline float get_m_green_1() const { return ___m_green_1; }
inline float* get_address_of_m_green_1() { return &___m_green_1; }
inline void set_m_green_1(float value)
{
___m_green_1 = value;
}
inline static int32_t get_offset_of_m_blue_2() { return static_cast<int32_t>(offsetof(LinearColor_tB8D05FA20CBA5254EA4D27D2B47D7B067FE506CD, ___m_blue_2)); }
inline float get_m_blue_2() const { return ___m_blue_2; }
inline float* get_address_of_m_blue_2() { return &___m_blue_2; }
inline void set_m_blue_2(float value)
{
___m_blue_2 = value;
}
inline static int32_t get_offset_of_m_intensity_3() { return static_cast<int32_t>(offsetof(LinearColor_tB8D05FA20CBA5254EA4D27D2B47D7B067FE506CD, ___m_intensity_3)); }
inline float get_m_intensity_3() const { return ___m_intensity_3; }
inline float* get_address_of_m_intensity_3() { return &___m_intensity_3; }
inline void set_m_intensity_3(float value)
{
___m_intensity_3 = value;
}
};
// UnityEngine.Keyframe
struct Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74
{
public:
// System.Single UnityEngine.Keyframe::m_Time
float ___m_Time_0;
// System.Single UnityEngine.Keyframe::m_Value
float ___m_Value_1;
// System.Single UnityEngine.Keyframe::m_InTangent
float ___m_InTangent_2;
// System.Single UnityEngine.Keyframe::m_OutTangent
float ___m_OutTangent_3;
// System.Int32 UnityEngine.Keyframe::m_WeightedMode
int32_t ___m_WeightedMode_4;
// System.Single UnityEngine.Keyframe::m_InWeight
float ___m_InWeight_5;
// System.Single UnityEngine.Keyframe::m_OutWeight
float ___m_OutWeight_6;
public:
inline static int32_t get_offset_of_m_Time_0() { return static_cast<int32_t>(offsetof(Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74, ___m_Time_0)); }
inline float get_m_Time_0() const { return ___m_Time_0; }
inline float* get_address_of_m_Time_0() { return &___m_Time_0; }
inline void set_m_Time_0(float value)
{
___m_Time_0 = value;
}
inline static int32_t get_offset_of_m_Value_1() { return static_cast<int32_t>(offsetof(Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74, ___m_Value_1)); }
inline float get_m_Value_1() const { return ___m_Value_1; }
inline float* get_address_of_m_Value_1() { return &___m_Value_1; }
inline void set_m_Value_1(float value)
{
___m_Value_1 = value;
}
inline static int32_t get_offset_of_m_InTangent_2() { return static_cast<int32_t>(offsetof(Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74, ___m_InTangent_2)); }
inline float get_m_InTangent_2() const { return ___m_InTangent_2; }
inline float* get_address_of_m_InTangent_2() { return &___m_InTangent_2; }
inline void set_m_InTangent_2(float value)
{
___m_InTangent_2 = value;
}
inline static int32_t get_offset_of_m_OutTangent_3() { return static_cast<int32_t>(offsetof(Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74, ___m_OutTangent_3)); }
inline float get_m_OutTangent_3() const { return ___m_OutTangent_3; }
inline float* get_address_of_m_OutTangent_3() { return &___m_OutTangent_3; }
inline void set_m_OutTangent_3(float value)
{
___m_OutTangent_3 = value;
}
inline static int32_t get_offset_of_m_WeightedMode_4() { return static_cast<int32_t>(offsetof(Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74, ___m_WeightedMode_4)); }
inline int32_t get_m_WeightedMode_4() const { return ___m_WeightedMode_4; }
inline int32_t* get_address_of_m_WeightedMode_4() { return &___m_WeightedMode_4; }
inline void set_m_WeightedMode_4(int32_t value)
{
___m_WeightedMode_4 = value;
}
inline static int32_t get_offset_of_m_InWeight_5() { return static_cast<int32_t>(offsetof(Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74, ___m_InWeight_5)); }
inline float get_m_InWeight_5() const { return ___m_InWeight_5; }
inline float* get_address_of_m_InWeight_5() { return &___m_InWeight_5; }
inline void set_m_InWeight_5(float value)
{
___m_InWeight_5 = value;
}
inline static int32_t get_offset_of_m_OutWeight_6() { return static_cast<int32_t>(offsetof(Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74, ___m_OutWeight_6)); }
inline float get_m_OutWeight_6() const { return ___m_OutWeight_6; }
inline float* get_address_of_m_OutWeight_6() { return &___m_OutWeight_6; }
inline void set_m_OutWeight_6(float value)
{
___m_OutWeight_6 = value;
}
};
// UnityEngine.Quaternion
struct Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357
{
public:
// System.Single UnityEngine.Quaternion::x
float ___x_0;
// System.Single UnityEngine.Quaternion::y
float ___y_1;
// System.Single UnityEngine.Quaternion::z
float ___z_2;
// System.Single UnityEngine.Quaternion::w
float ___w_3;
public:
inline static int32_t get_offset_of_x_0() { return static_cast<int32_t>(offsetof(Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357, ___x_0)); }
inline float get_x_0() const { return ___x_0; }
inline float* get_address_of_x_0() { return &___x_0; }
inline void set_x_0(float value)
{
___x_0 = value;
}
inline static int32_t get_offset_of_y_1() { return static_cast<int32_t>(offsetof(Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357, ___y_1)); }
inline float get_y_1() const { return ___y_1; }
inline float* get_address_of_y_1() { return &___y_1; }
inline void set_y_1(float value)
{
___y_1 = value;
}
inline static int32_t get_offset_of_z_2() { return static_cast<int32_t>(offsetof(Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357, ___z_2)); }
inline float get_z_2() const { return ___z_2; }
inline float* get_address_of_z_2() { return &___z_2; }
inline void set_z_2(float value)
{
___z_2 = value;
}
inline static int32_t get_offset_of_w_3() { return static_cast<int32_t>(offsetof(Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357, ___w_3)); }
inline float get_w_3() const { return ___w_3; }
inline float* get_address_of_w_3() { return &___w_3; }
inline void set_w_3(float value)
{
___w_3 = value;
}
};
struct Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357_StaticFields
{
public:
// UnityEngine.Quaternion UnityEngine.Quaternion::identityQuaternion
Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357 ___identityQuaternion_4;
public:
inline static int32_t get_offset_of_identityQuaternion_4() { return static_cast<int32_t>(offsetof(Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357_StaticFields, ___identityQuaternion_4)); }
inline Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357 get_identityQuaternion_4() const { return ___identityQuaternion_4; }
inline Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357 * get_address_of_identityQuaternion_4() { return &___identityQuaternion_4; }
inline void set_identityQuaternion_4(Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357 value)
{
___identityQuaternion_4 = value;
}
};
// UnityEngine.Rendering.BatchVisibility
struct BatchVisibility_t56334E279A62622BD0640403186E9A1017CF3062
{
public:
// System.Int32 UnityEngine.Rendering.BatchVisibility::offset
int32_t ___offset_0;
// System.Int32 UnityEngine.Rendering.BatchVisibility::instancesCount
int32_t ___instancesCount_1;
// System.Int32 UnityEngine.Rendering.BatchVisibility::visibleCount
int32_t ___visibleCount_2;
public:
inline static int32_t get_offset_of_offset_0() { return static_cast<int32_t>(offsetof(BatchVisibility_t56334E279A62622BD0640403186E9A1017CF3062, ___offset_0)); }
inline int32_t get_offset_0() const { return ___offset_0; }
inline int32_t* get_address_of_offset_0() { return &___offset_0; }
inline void set_offset_0(int32_t value)
{
___offset_0 = value;
}
inline static int32_t get_offset_of_instancesCount_1() { return static_cast<int32_t>(offsetof(BatchVisibility_t56334E279A62622BD0640403186E9A1017CF3062, ___instancesCount_1)); }
inline int32_t get_instancesCount_1() const { return ___instancesCount_1; }
inline int32_t* get_address_of_instancesCount_1() { return &___instancesCount_1; }
inline void set_instancesCount_1(int32_t value)
{
___instancesCount_1 = value;
}
inline static int32_t get_offset_of_visibleCount_2() { return static_cast<int32_t>(offsetof(BatchVisibility_t56334E279A62622BD0640403186E9A1017CF3062, ___visibleCount_2)); }
inline int32_t get_visibleCount_2() const { return ___visibleCount_2; }
inline int32_t* get_address_of_visibleCount_2() { return &___visibleCount_2; }
inline void set_visibleCount_2(int32_t value)
{
___visibleCount_2 = value;
}
};
// UnityEngine.SendMouseEvents_HitInfo
struct HitInfo_t2B010E637D28B522E704FDA56FAE6DA9979D8746
{
public:
// UnityEngine.GameObject UnityEngine.SendMouseEvents_HitInfo::target
GameObject_tBD1244AD56B4E59AAD76E5E7C9282EC5CE434F0F * ___target_0;
// UnityEngine.Camera UnityEngine.SendMouseEvents_HitInfo::camera
Camera_t48B2B9ECB3CE6108A98BF949A1CECF0FE3421F34 * ___camera_1;
public:
inline static int32_t get_offset_of_target_0() { return static_cast<int32_t>(offsetof(HitInfo_t2B010E637D28B522E704FDA56FAE6DA9979D8746, ___target_0)); }
inline GameObject_tBD1244AD56B4E59AAD76E5E7C9282EC5CE434F0F * get_target_0() const { return ___target_0; }
inline GameObject_tBD1244AD56B4E59AAD76E5E7C9282EC5CE434F0F ** get_address_of_target_0() { return &___target_0; }
inline void set_target_0(GameObject_tBD1244AD56B4E59AAD76E5E7C9282EC5CE434F0F * value)
{
___target_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___target_0), (void*)value);
}
inline static int32_t get_offset_of_camera_1() { return static_cast<int32_t>(offsetof(HitInfo_t2B010E637D28B522E704FDA56FAE6DA9979D8746, ___camera_1)); }
inline Camera_t48B2B9ECB3CE6108A98BF949A1CECF0FE3421F34 * get_camera_1() const { return ___camera_1; }
inline Camera_t48B2B9ECB3CE6108A98BF949A1CECF0FE3421F34 ** get_address_of_camera_1() { return &___camera_1; }
inline void set_camera_1(Camera_t48B2B9ECB3CE6108A98BF949A1CECF0FE3421F34 * value)
{
___camera_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___camera_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.SendMouseEvents/HitInfo
struct HitInfo_t2B010E637D28B522E704FDA56FAE6DA9979D8746_marshaled_pinvoke
{
GameObject_tBD1244AD56B4E59AAD76E5E7C9282EC5CE434F0F * ___target_0;
Camera_t48B2B9ECB3CE6108A98BF949A1CECF0FE3421F34 * ___camera_1;
};
// Native definition for COM marshalling of UnityEngine.SendMouseEvents/HitInfo
struct HitInfo_t2B010E637D28B522E704FDA56FAE6DA9979D8746_marshaled_com
{
GameObject_tBD1244AD56B4E59AAD76E5E7C9282EC5CE434F0F * ___target_0;
Camera_t48B2B9ECB3CE6108A98BF949A1CECF0FE3421F34 * ___camera_1;
};
// UnityEngine.SocialPlatforms.GameCenter.GcAchievementData
struct GcAchievementData_t5CBCF44628981C91C76C552716A7D551670DCE55
{
public:
// System.String UnityEngine.SocialPlatforms.GameCenter.GcAchievementData::m_Identifier
String_t* ___m_Identifier_0;
// System.Double UnityEngine.SocialPlatforms.GameCenter.GcAchievementData::m_PercentCompleted
double ___m_PercentCompleted_1;
// System.Int32 UnityEngine.SocialPlatforms.GameCenter.GcAchievementData::m_Completed
int32_t ___m_Completed_2;
// System.Int32 UnityEngine.SocialPlatforms.GameCenter.GcAchievementData::m_Hidden
int32_t ___m_Hidden_3;
// System.Int32 UnityEngine.SocialPlatforms.GameCenter.GcAchievementData::m_LastReportedDate
int32_t ___m_LastReportedDate_4;
public:
inline static int32_t get_offset_of_m_Identifier_0() { return static_cast<int32_t>(offsetof(GcAchievementData_t5CBCF44628981C91C76C552716A7D551670DCE55, ___m_Identifier_0)); }
inline String_t* get_m_Identifier_0() const { return ___m_Identifier_0; }
inline String_t** get_address_of_m_Identifier_0() { return &___m_Identifier_0; }
inline void set_m_Identifier_0(String_t* value)
{
___m_Identifier_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_Identifier_0), (void*)value);
}
inline static int32_t get_offset_of_m_PercentCompleted_1() { return static_cast<int32_t>(offsetof(GcAchievementData_t5CBCF44628981C91C76C552716A7D551670DCE55, ___m_PercentCompleted_1)); }
inline double get_m_PercentCompleted_1() const { return ___m_PercentCompleted_1; }
inline double* get_address_of_m_PercentCompleted_1() { return &___m_PercentCompleted_1; }
inline void set_m_PercentCompleted_1(double value)
{
___m_PercentCompleted_1 = value;
}
inline static int32_t get_offset_of_m_Completed_2() { return static_cast<int32_t>(offsetof(GcAchievementData_t5CBCF44628981C91C76C552716A7D551670DCE55, ___m_Completed_2)); }
inline int32_t get_m_Completed_2() const { return ___m_Completed_2; }
inline int32_t* get_address_of_m_Completed_2() { return &___m_Completed_2; }
inline void set_m_Completed_2(int32_t value)
{
___m_Completed_2 = value;
}
inline static int32_t get_offset_of_m_Hidden_3() { return static_cast<int32_t>(offsetof(GcAchievementData_t5CBCF44628981C91C76C552716A7D551670DCE55, ___m_Hidden_3)); }
inline int32_t get_m_Hidden_3() const { return ___m_Hidden_3; }
inline int32_t* get_address_of_m_Hidden_3() { return &___m_Hidden_3; }
inline void set_m_Hidden_3(int32_t value)
{
___m_Hidden_3 = value;
}
inline static int32_t get_offset_of_m_LastReportedDate_4() { return static_cast<int32_t>(offsetof(GcAchievementData_t5CBCF44628981C91C76C552716A7D551670DCE55, ___m_LastReportedDate_4)); }
inline int32_t get_m_LastReportedDate_4() const { return ___m_LastReportedDate_4; }
inline int32_t* get_address_of_m_LastReportedDate_4() { return &___m_LastReportedDate_4; }
inline void set_m_LastReportedDate_4(int32_t value)
{
___m_LastReportedDate_4 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.SocialPlatforms.GameCenter.GcAchievementData
struct GcAchievementData_t5CBCF44628981C91C76C552716A7D551670DCE55_marshaled_pinvoke
{
char* ___m_Identifier_0;
double ___m_PercentCompleted_1;
int32_t ___m_Completed_2;
int32_t ___m_Hidden_3;
int32_t ___m_LastReportedDate_4;
};
// Native definition for COM marshalling of UnityEngine.SocialPlatforms.GameCenter.GcAchievementData
struct GcAchievementData_t5CBCF44628981C91C76C552716A7D551670DCE55_marshaled_com
{
Il2CppChar* ___m_Identifier_0;
double ___m_PercentCompleted_1;
int32_t ___m_Completed_2;
int32_t ___m_Hidden_3;
int32_t ___m_LastReportedDate_4;
};
// UnityEngine.SocialPlatforms.GameCenter.GcScoreData
struct GcScoreData_t45EF6CC4038C34CE5823D33D1978C5A3F2E0D09A
{
public:
// System.String UnityEngine.SocialPlatforms.GameCenter.GcScoreData::m_Category
String_t* ___m_Category_0;
// System.UInt32 UnityEngine.SocialPlatforms.GameCenter.GcScoreData::m_ValueLow
uint32_t ___m_ValueLow_1;
// System.Int32 UnityEngine.SocialPlatforms.GameCenter.GcScoreData::m_ValueHigh
int32_t ___m_ValueHigh_2;
// System.Int32 UnityEngine.SocialPlatforms.GameCenter.GcScoreData::m_Date
int32_t ___m_Date_3;
// System.String UnityEngine.SocialPlatforms.GameCenter.GcScoreData::m_FormattedValue
String_t* ___m_FormattedValue_4;
// System.String UnityEngine.SocialPlatforms.GameCenter.GcScoreData::m_PlayerID
String_t* ___m_PlayerID_5;
// System.Int32 UnityEngine.SocialPlatforms.GameCenter.GcScoreData::m_Rank
int32_t ___m_Rank_6;
public:
inline static int32_t get_offset_of_m_Category_0() { return static_cast<int32_t>(offsetof(GcScoreData_t45EF6CC4038C34CE5823D33D1978C5A3F2E0D09A, ___m_Category_0)); }
inline String_t* get_m_Category_0() const { return ___m_Category_0; }
inline String_t** get_address_of_m_Category_0() { return &___m_Category_0; }
inline void set_m_Category_0(String_t* value)
{
___m_Category_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_Category_0), (void*)value);
}
inline static int32_t get_offset_of_m_ValueLow_1() { return static_cast<int32_t>(offsetof(GcScoreData_t45EF6CC4038C34CE5823D33D1978C5A3F2E0D09A, ___m_ValueLow_1)); }
inline uint32_t get_m_ValueLow_1() const { return ___m_ValueLow_1; }
inline uint32_t* get_address_of_m_ValueLow_1() { return &___m_ValueLow_1; }
inline void set_m_ValueLow_1(uint32_t value)
{
___m_ValueLow_1 = value;
}
inline static int32_t get_offset_of_m_ValueHigh_2() { return static_cast<int32_t>(offsetof(GcScoreData_t45EF6CC4038C34CE5823D33D1978C5A3F2E0D09A, ___m_ValueHigh_2)); }
inline int32_t get_m_ValueHigh_2() const { return ___m_ValueHigh_2; }
inline int32_t* get_address_of_m_ValueHigh_2() { return &___m_ValueHigh_2; }
inline void set_m_ValueHigh_2(int32_t value)
{
___m_ValueHigh_2 = value;
}
inline static int32_t get_offset_of_m_Date_3() { return static_cast<int32_t>(offsetof(GcScoreData_t45EF6CC4038C34CE5823D33D1978C5A3F2E0D09A, ___m_Date_3)); }
inline int32_t get_m_Date_3() const { return ___m_Date_3; }
inline int32_t* get_address_of_m_Date_3() { return &___m_Date_3; }
inline void set_m_Date_3(int32_t value)
{
___m_Date_3 = value;
}
inline static int32_t get_offset_of_m_FormattedValue_4() { return static_cast<int32_t>(offsetof(GcScoreData_t45EF6CC4038C34CE5823D33D1978C5A3F2E0D09A, ___m_FormattedValue_4)); }
inline String_t* get_m_FormattedValue_4() const { return ___m_FormattedValue_4; }
inline String_t** get_address_of_m_FormattedValue_4() { return &___m_FormattedValue_4; }
inline void set_m_FormattedValue_4(String_t* value)
{
___m_FormattedValue_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_FormattedValue_4), (void*)value);
}
inline static int32_t get_offset_of_m_PlayerID_5() { return static_cast<int32_t>(offsetof(GcScoreData_t45EF6CC4038C34CE5823D33D1978C5A3F2E0D09A, ___m_PlayerID_5)); }
inline String_t* get_m_PlayerID_5() const { return ___m_PlayerID_5; }
inline String_t** get_address_of_m_PlayerID_5() { return &___m_PlayerID_5; }
inline void set_m_PlayerID_5(String_t* value)
{
___m_PlayerID_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_PlayerID_5), (void*)value);
}
inline static int32_t get_offset_of_m_Rank_6() { return static_cast<int32_t>(offsetof(GcScoreData_t45EF6CC4038C34CE5823D33D1978C5A3F2E0D09A, ___m_Rank_6)); }
inline int32_t get_m_Rank_6() const { return ___m_Rank_6; }
inline int32_t* get_address_of_m_Rank_6() { return &___m_Rank_6; }
inline void set_m_Rank_6(int32_t value)
{
___m_Rank_6 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.SocialPlatforms.GameCenter.GcScoreData
struct GcScoreData_t45EF6CC4038C34CE5823D33D1978C5A3F2E0D09A_marshaled_pinvoke
{
char* ___m_Category_0;
uint32_t ___m_ValueLow_1;
int32_t ___m_ValueHigh_2;
int32_t ___m_Date_3;
char* ___m_FormattedValue_4;
char* ___m_PlayerID_5;
int32_t ___m_Rank_6;
};
// Native definition for COM marshalling of UnityEngine.SocialPlatforms.GameCenter.GcScoreData
struct GcScoreData_t45EF6CC4038C34CE5823D33D1978C5A3F2E0D09A_marshaled_com
{
Il2CppChar* ___m_Category_0;
uint32_t ___m_ValueLow_1;
int32_t ___m_ValueHigh_2;
int32_t ___m_Date_3;
Il2CppChar* ___m_FormattedValue_4;
Il2CppChar* ___m_PlayerID_5;
int32_t ___m_Rank_6;
};
// UnityEngine.UI.SpriteState
struct SpriteState_t58B9DD66A79CD69AB4CFC3AD0C41E45DC2192C0A
{
public:
// UnityEngine.Sprite UnityEngine.UI.SpriteState::m_HighlightedSprite
Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * ___m_HighlightedSprite_0;
// UnityEngine.Sprite UnityEngine.UI.SpriteState::m_PressedSprite
Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * ___m_PressedSprite_1;
// UnityEngine.Sprite UnityEngine.UI.SpriteState::m_SelectedSprite
Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * ___m_SelectedSprite_2;
// UnityEngine.Sprite UnityEngine.UI.SpriteState::m_DisabledSprite
Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * ___m_DisabledSprite_3;
public:
inline static int32_t get_offset_of_m_HighlightedSprite_0() { return static_cast<int32_t>(offsetof(SpriteState_t58B9DD66A79CD69AB4CFC3AD0C41E45DC2192C0A, ___m_HighlightedSprite_0)); }
inline Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * get_m_HighlightedSprite_0() const { return ___m_HighlightedSprite_0; }
inline Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 ** get_address_of_m_HighlightedSprite_0() { return &___m_HighlightedSprite_0; }
inline void set_m_HighlightedSprite_0(Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * value)
{
___m_HighlightedSprite_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_HighlightedSprite_0), (void*)value);
}
inline static int32_t get_offset_of_m_PressedSprite_1() { return static_cast<int32_t>(offsetof(SpriteState_t58B9DD66A79CD69AB4CFC3AD0C41E45DC2192C0A, ___m_PressedSprite_1)); }
inline Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * get_m_PressedSprite_1() const { return ___m_PressedSprite_1; }
inline Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 ** get_address_of_m_PressedSprite_1() { return &___m_PressedSprite_1; }
inline void set_m_PressedSprite_1(Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * value)
{
___m_PressedSprite_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_PressedSprite_1), (void*)value);
}
inline static int32_t get_offset_of_m_SelectedSprite_2() { return static_cast<int32_t>(offsetof(SpriteState_t58B9DD66A79CD69AB4CFC3AD0C41E45DC2192C0A, ___m_SelectedSprite_2)); }
inline Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * get_m_SelectedSprite_2() const { return ___m_SelectedSprite_2; }
inline Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 ** get_address_of_m_SelectedSprite_2() { return &___m_SelectedSprite_2; }
inline void set_m_SelectedSprite_2(Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * value)
{
___m_SelectedSprite_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_SelectedSprite_2), (void*)value);
}
inline static int32_t get_offset_of_m_DisabledSprite_3() { return static_cast<int32_t>(offsetof(SpriteState_t58B9DD66A79CD69AB4CFC3AD0C41E45DC2192C0A, ___m_DisabledSprite_3)); }
inline Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * get_m_DisabledSprite_3() const { return ___m_DisabledSprite_3; }
inline Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 ** get_address_of_m_DisabledSprite_3() { return &___m_DisabledSprite_3; }
inline void set_m_DisabledSprite_3(Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * value)
{
___m_DisabledSprite_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_DisabledSprite_3), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.UI.SpriteState
struct SpriteState_t58B9DD66A79CD69AB4CFC3AD0C41E45DC2192C0A_marshaled_pinvoke
{
Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * ___m_HighlightedSprite_0;
Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * ___m_PressedSprite_1;
Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * ___m_SelectedSprite_2;
Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * ___m_DisabledSprite_3;
};
// Native definition for COM marshalling of UnityEngine.UI.SpriteState
struct SpriteState_t58B9DD66A79CD69AB4CFC3AD0C41E45DC2192C0A_marshaled_com
{
Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * ___m_HighlightedSprite_0;
Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * ___m_PressedSprite_1;
Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * ___m_SelectedSprite_2;
Sprite_tCA09498D612D08DE668653AF1E9C12BF53434198 * ___m_DisabledSprite_3;
};
// UnityEngine.UILineInfo
struct UILineInfo_t0AF27251CA07CEE2BC0C1FEF752245596B8033E6
{
public:
// System.Int32 UnityEngine.UILineInfo::startCharIdx
int32_t ___startCharIdx_0;
// System.Int32 UnityEngine.UILineInfo::height
int32_t ___height_1;
// System.Single UnityEngine.UILineInfo::topY
float ___topY_2;
// System.Single UnityEngine.UILineInfo::leading
float ___leading_3;
public:
inline static int32_t get_offset_of_startCharIdx_0() { return static_cast<int32_t>(offsetof(UILineInfo_t0AF27251CA07CEE2BC0C1FEF752245596B8033E6, ___startCharIdx_0)); }
inline int32_t get_startCharIdx_0() const { return ___startCharIdx_0; }
inline int32_t* get_address_of_startCharIdx_0() { return &___startCharIdx_0; }
inline void set_startCharIdx_0(int32_t value)
{
___startCharIdx_0 = value;
}
inline static int32_t get_offset_of_height_1() { return static_cast<int32_t>(offsetof(UILineInfo_t0AF27251CA07CEE2BC0C1FEF752245596B8033E6, ___height_1)); }
inline int32_t get_height_1() const { return ___height_1; }
inline int32_t* get_address_of_height_1() { return &___height_1; }
inline void set_height_1(int32_t value)
{
___height_1 = value;
}
inline static int32_t get_offset_of_topY_2() { return static_cast<int32_t>(offsetof(UILineInfo_t0AF27251CA07CEE2BC0C1FEF752245596B8033E6, ___topY_2)); }
inline float get_topY_2() const { return ___topY_2; }
inline float* get_address_of_topY_2() { return &___topY_2; }
inline void set_topY_2(float value)
{
___topY_2 = value;
}
inline static int32_t get_offset_of_leading_3() { return static_cast<int32_t>(offsetof(UILineInfo_t0AF27251CA07CEE2BC0C1FEF752245596B8033E6, ___leading_3)); }
inline float get_leading_3() const { return ___leading_3; }
inline float* get_address_of_leading_3() { return &___leading_3; }
inline void set_leading_3(float value)
{
___leading_3 = value;
}
};
// UnityEngine.UnitySynchronizationContext_WorkRequest
struct WorkRequest_t0247B62D135204EAA95FC0B2EC829CB27B433F94
{
public:
// System.Threading.SendOrPostCallback UnityEngine.UnitySynchronizationContext_WorkRequest::m_DelagateCallback
SendOrPostCallback_t3F9C0164860E4AA5138DF8B4488DFB0D33147F01 * ___m_DelagateCallback_0;
// System.Object UnityEngine.UnitySynchronizationContext_WorkRequest::m_DelagateState
RuntimeObject * ___m_DelagateState_1;
// System.Threading.ManualResetEvent UnityEngine.UnitySynchronizationContext_WorkRequest::m_WaitHandle
ManualResetEvent_tDFAF117B200ECA4CCF4FD09593F949A016D55408 * ___m_WaitHandle_2;
public:
inline static int32_t get_offset_of_m_DelagateCallback_0() { return static_cast<int32_t>(offsetof(WorkRequest_t0247B62D135204EAA95FC0B2EC829CB27B433F94, ___m_DelagateCallback_0)); }
inline SendOrPostCallback_t3F9C0164860E4AA5138DF8B4488DFB0D33147F01 * get_m_DelagateCallback_0() const { return ___m_DelagateCallback_0; }
inline SendOrPostCallback_t3F9C0164860E4AA5138DF8B4488DFB0D33147F01 ** get_address_of_m_DelagateCallback_0() { return &___m_DelagateCallback_0; }
inline void set_m_DelagateCallback_0(SendOrPostCallback_t3F9C0164860E4AA5138DF8B4488DFB0D33147F01 * value)
{
___m_DelagateCallback_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_DelagateCallback_0), (void*)value);
}
inline static int32_t get_offset_of_m_DelagateState_1() { return static_cast<int32_t>(offsetof(WorkRequest_t0247B62D135204EAA95FC0B2EC829CB27B433F94, ___m_DelagateState_1)); }
inline RuntimeObject * get_m_DelagateState_1() const { return ___m_DelagateState_1; }
inline RuntimeObject ** get_address_of_m_DelagateState_1() { return &___m_DelagateState_1; }
inline void set_m_DelagateState_1(RuntimeObject * value)
{
___m_DelagateState_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_DelagateState_1), (void*)value);
}
inline static int32_t get_offset_of_m_WaitHandle_2() { return static_cast<int32_t>(offsetof(WorkRequest_t0247B62D135204EAA95FC0B2EC829CB27B433F94, ___m_WaitHandle_2)); }
inline ManualResetEvent_tDFAF117B200ECA4CCF4FD09593F949A016D55408 * get_m_WaitHandle_2() const { return ___m_WaitHandle_2; }
inline ManualResetEvent_tDFAF117B200ECA4CCF4FD09593F949A016D55408 ** get_address_of_m_WaitHandle_2() { return &___m_WaitHandle_2; }
inline void set_m_WaitHandle_2(ManualResetEvent_tDFAF117B200ECA4CCF4FD09593F949A016D55408 * value)
{
___m_WaitHandle_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_WaitHandle_2), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.UnitySynchronizationContext/WorkRequest
struct WorkRequest_t0247B62D135204EAA95FC0B2EC829CB27B433F94_marshaled_pinvoke
{
Il2CppMethodPointer ___m_DelagateCallback_0;
Il2CppIUnknown* ___m_DelagateState_1;
ManualResetEvent_tDFAF117B200ECA4CCF4FD09593F949A016D55408 * ___m_WaitHandle_2;
};
// Native definition for COM marshalling of UnityEngine.UnitySynchronizationContext/WorkRequest
struct WorkRequest_t0247B62D135204EAA95FC0B2EC829CB27B433F94_marshaled_com
{
Il2CppMethodPointer ___m_DelagateCallback_0;
Il2CppIUnknown* ___m_DelagateState_1;
ManualResetEvent_tDFAF117B200ECA4CCF4FD09593F949A016D55408 * ___m_WaitHandle_2;
};
// UnityEngine.Vector2
struct Vector2_tA85D2DD88578276CA8A8796756458277E72D073D
{
public:
// System.Single UnityEngine.Vector2::x
float ___x_0;
// System.Single UnityEngine.Vector2::y
float ___y_1;
public:
inline static int32_t get_offset_of_x_0() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D, ___x_0)); }
inline float get_x_0() const { return ___x_0; }
inline float* get_address_of_x_0() { return &___x_0; }
inline void set_x_0(float value)
{
___x_0 = value;
}
inline static int32_t get_offset_of_y_1() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D, ___y_1)); }
inline float get_y_1() const { return ___y_1; }
inline float* get_address_of_y_1() { return &___y_1; }
inline void set_y_1(float value)
{
___y_1 = value;
}
};
struct Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields
{
public:
// UnityEngine.Vector2 UnityEngine.Vector2::zeroVector
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___zeroVector_2;
// UnityEngine.Vector2 UnityEngine.Vector2::oneVector
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___oneVector_3;
// UnityEngine.Vector2 UnityEngine.Vector2::upVector
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___upVector_4;
// UnityEngine.Vector2 UnityEngine.Vector2::downVector
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___downVector_5;
// UnityEngine.Vector2 UnityEngine.Vector2::leftVector
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___leftVector_6;
// UnityEngine.Vector2 UnityEngine.Vector2::rightVector
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___rightVector_7;
// UnityEngine.Vector2 UnityEngine.Vector2::positiveInfinityVector
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___positiveInfinityVector_8;
// UnityEngine.Vector2 UnityEngine.Vector2::negativeInfinityVector
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___negativeInfinityVector_9;
public:
inline static int32_t get_offset_of_zeroVector_2() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___zeroVector_2)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_zeroVector_2() const { return ___zeroVector_2; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_zeroVector_2() { return &___zeroVector_2; }
inline void set_zeroVector_2(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___zeroVector_2 = value;
}
inline static int32_t get_offset_of_oneVector_3() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___oneVector_3)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_oneVector_3() const { return ___oneVector_3; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_oneVector_3() { return &___oneVector_3; }
inline void set_oneVector_3(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___oneVector_3 = value;
}
inline static int32_t get_offset_of_upVector_4() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___upVector_4)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_upVector_4() const { return ___upVector_4; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_upVector_4() { return &___upVector_4; }
inline void set_upVector_4(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___upVector_4 = value;
}
inline static int32_t get_offset_of_downVector_5() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___downVector_5)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_downVector_5() const { return ___downVector_5; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_downVector_5() { return &___downVector_5; }
inline void set_downVector_5(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___downVector_5 = value;
}
inline static int32_t get_offset_of_leftVector_6() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___leftVector_6)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_leftVector_6() const { return ___leftVector_6; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_leftVector_6() { return &___leftVector_6; }
inline void set_leftVector_6(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___leftVector_6 = value;
}
inline static int32_t get_offset_of_rightVector_7() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___rightVector_7)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_rightVector_7() const { return ___rightVector_7; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_rightVector_7() { return &___rightVector_7; }
inline void set_rightVector_7(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___rightVector_7 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_8() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___positiveInfinityVector_8)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_positiveInfinityVector_8() const { return ___positiveInfinityVector_8; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_positiveInfinityVector_8() { return &___positiveInfinityVector_8; }
inline void set_positiveInfinityVector_8(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___positiveInfinityVector_8 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_9() { return static_cast<int32_t>(offsetof(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D_StaticFields, ___negativeInfinityVector_9)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_negativeInfinityVector_9() const { return ___negativeInfinityVector_9; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_negativeInfinityVector_9() { return &___negativeInfinityVector_9; }
inline void set_negativeInfinityVector_9(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___negativeInfinityVector_9 = value;
}
};
// UnityEngine.Vector3
struct Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720
{
public:
// System.Single UnityEngine.Vector3::x
float ___x_2;
// System.Single UnityEngine.Vector3::y
float ___y_3;
// System.Single UnityEngine.Vector3::z
float ___z_4;
public:
inline static int32_t get_offset_of_x_2() { return static_cast<int32_t>(offsetof(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720, ___x_2)); }
inline float get_x_2() const { return ___x_2; }
inline float* get_address_of_x_2() { return &___x_2; }
inline void set_x_2(float value)
{
___x_2 = value;
}
inline static int32_t get_offset_of_y_3() { return static_cast<int32_t>(offsetof(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720, ___y_3)); }
inline float get_y_3() const { return ___y_3; }
inline float* get_address_of_y_3() { return &___y_3; }
inline void set_y_3(float value)
{
___y_3 = value;
}
inline static int32_t get_offset_of_z_4() { return static_cast<int32_t>(offsetof(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720, ___z_4)); }
inline float get_z_4() const { return ___z_4; }
inline float* get_address_of_z_4() { return &___z_4; }
inline void set_z_4(float value)
{
___z_4 = value;
}
};
struct Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720_StaticFields
{
public:
// UnityEngine.Vector3 UnityEngine.Vector3::zeroVector
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___zeroVector_5;
// UnityEngine.Vector3 UnityEngine.Vector3::oneVector
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___oneVector_6;
// UnityEngine.Vector3 UnityEngine.Vector3::upVector
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___upVector_7;
// UnityEngine.Vector3 UnityEngine.Vector3::downVector
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___downVector_8;
// UnityEngine.Vector3 UnityEngine.Vector3::leftVector
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___leftVector_9;
// UnityEngine.Vector3 UnityEngine.Vector3::rightVector
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___rightVector_10;
// UnityEngine.Vector3 UnityEngine.Vector3::forwardVector
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___forwardVector_11;
// UnityEngine.Vector3 UnityEngine.Vector3::backVector
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___backVector_12;
// UnityEngine.Vector3 UnityEngine.Vector3::positiveInfinityVector
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___positiveInfinityVector_13;
// UnityEngine.Vector3 UnityEngine.Vector3::negativeInfinityVector
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___negativeInfinityVector_14;
public:
inline static int32_t get_offset_of_zeroVector_5() { return static_cast<int32_t>(offsetof(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720_StaticFields, ___zeroVector_5)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_zeroVector_5() const { return ___zeroVector_5; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_zeroVector_5() { return &___zeroVector_5; }
inline void set_zeroVector_5(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___zeroVector_5 = value;
}
inline static int32_t get_offset_of_oneVector_6() { return static_cast<int32_t>(offsetof(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720_StaticFields, ___oneVector_6)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_oneVector_6() const { return ___oneVector_6; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_oneVector_6() { return &___oneVector_6; }
inline void set_oneVector_6(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___oneVector_6 = value;
}
inline static int32_t get_offset_of_upVector_7() { return static_cast<int32_t>(offsetof(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720_StaticFields, ___upVector_7)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_upVector_7() const { return ___upVector_7; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_upVector_7() { return &___upVector_7; }
inline void set_upVector_7(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___upVector_7 = value;
}
inline static int32_t get_offset_of_downVector_8() { return static_cast<int32_t>(offsetof(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720_StaticFields, ___downVector_8)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_downVector_8() const { return ___downVector_8; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_downVector_8() { return &___downVector_8; }
inline void set_downVector_8(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___downVector_8 = value;
}
inline static int32_t get_offset_of_leftVector_9() { return static_cast<int32_t>(offsetof(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720_StaticFields, ___leftVector_9)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_leftVector_9() const { return ___leftVector_9; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_leftVector_9() { return &___leftVector_9; }
inline void set_leftVector_9(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___leftVector_9 = value;
}
inline static int32_t get_offset_of_rightVector_10() { return static_cast<int32_t>(offsetof(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720_StaticFields, ___rightVector_10)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_rightVector_10() const { return ___rightVector_10; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_rightVector_10() { return &___rightVector_10; }
inline void set_rightVector_10(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___rightVector_10 = value;
}
inline static int32_t get_offset_of_forwardVector_11() { return static_cast<int32_t>(offsetof(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720_StaticFields, ___forwardVector_11)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_forwardVector_11() const { return ___forwardVector_11; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_forwardVector_11() { return &___forwardVector_11; }
inline void set_forwardVector_11(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___forwardVector_11 = value;
}
inline static int32_t get_offset_of_backVector_12() { return static_cast<int32_t>(offsetof(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720_StaticFields, ___backVector_12)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_backVector_12() const { return ___backVector_12; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_backVector_12() { return &___backVector_12; }
inline void set_backVector_12(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___backVector_12 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_13() { return static_cast<int32_t>(offsetof(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720_StaticFields, ___positiveInfinityVector_13)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_positiveInfinityVector_13() const { return ___positiveInfinityVector_13; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_positiveInfinityVector_13() { return &___positiveInfinityVector_13; }
inline void set_positiveInfinityVector_13(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___positiveInfinityVector_13 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_14() { return static_cast<int32_t>(offsetof(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720_StaticFields, ___negativeInfinityVector_14)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_negativeInfinityVector_14() const { return ___negativeInfinityVector_14; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_negativeInfinityVector_14() { return &___negativeInfinityVector_14; }
inline void set_negativeInfinityVector_14(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___negativeInfinityVector_14 = value;
}
};
// UnityEngine.Vector4
struct Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E
{
public:
// System.Single UnityEngine.Vector4::x
float ___x_1;
// System.Single UnityEngine.Vector4::y
float ___y_2;
// System.Single UnityEngine.Vector4::z
float ___z_3;
// System.Single UnityEngine.Vector4::w
float ___w_4;
public:
inline static int32_t get_offset_of_x_1() { return static_cast<int32_t>(offsetof(Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E, ___x_1)); }
inline float get_x_1() const { return ___x_1; }
inline float* get_address_of_x_1() { return &___x_1; }
inline void set_x_1(float value)
{
___x_1 = value;
}
inline static int32_t get_offset_of_y_2() { return static_cast<int32_t>(offsetof(Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E, ___y_2)); }
inline float get_y_2() const { return ___y_2; }
inline float* get_address_of_y_2() { return &___y_2; }
inline void set_y_2(float value)
{
___y_2 = value;
}
inline static int32_t get_offset_of_z_3() { return static_cast<int32_t>(offsetof(Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E, ___z_3)); }
inline float get_z_3() const { return ___z_3; }
inline float* get_address_of_z_3() { return &___z_3; }
inline void set_z_3(float value)
{
___z_3 = value;
}
inline static int32_t get_offset_of_w_4() { return static_cast<int32_t>(offsetof(Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E, ___w_4)); }
inline float get_w_4() const { return ___w_4; }
inline float* get_address_of_w_4() { return &___w_4; }
inline void set_w_4(float value)
{
___w_4 = value;
}
};
struct Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E_StaticFields
{
public:
// UnityEngine.Vector4 UnityEngine.Vector4::zeroVector
Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E ___zeroVector_5;
// UnityEngine.Vector4 UnityEngine.Vector4::oneVector
Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E ___oneVector_6;
// UnityEngine.Vector4 UnityEngine.Vector4::positiveInfinityVector
Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E ___positiveInfinityVector_7;
// UnityEngine.Vector4 UnityEngine.Vector4::negativeInfinityVector
Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E ___negativeInfinityVector_8;
public:
inline static int32_t get_offset_of_zeroVector_5() { return static_cast<int32_t>(offsetof(Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E_StaticFields, ___zeroVector_5)); }
inline Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E get_zeroVector_5() const { return ___zeroVector_5; }
inline Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E * get_address_of_zeroVector_5() { return &___zeroVector_5; }
inline void set_zeroVector_5(Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E value)
{
___zeroVector_5 = value;
}
inline static int32_t get_offset_of_oneVector_6() { return static_cast<int32_t>(offsetof(Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E_StaticFields, ___oneVector_6)); }
inline Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E get_oneVector_6() const { return ___oneVector_6; }
inline Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E * get_address_of_oneVector_6() { return &___oneVector_6; }
inline void set_oneVector_6(Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E value)
{
___oneVector_6 = value;
}
inline static int32_t get_offset_of_positiveInfinityVector_7() { return static_cast<int32_t>(offsetof(Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E_StaticFields, ___positiveInfinityVector_7)); }
inline Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E get_positiveInfinityVector_7() const { return ___positiveInfinityVector_7; }
inline Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E * get_address_of_positiveInfinityVector_7() { return &___positiveInfinityVector_7; }
inline void set_positiveInfinityVector_7(Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E value)
{
___positiveInfinityVector_7 = value;
}
inline static int32_t get_offset_of_negativeInfinityVector_8() { return static_cast<int32_t>(offsetof(Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E_StaticFields, ___negativeInfinityVector_8)); }
inline Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E get_negativeInfinityVector_8() const { return ___negativeInfinityVector_8; }
inline Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E * get_address_of_negativeInfinityVector_8() { return &___negativeInfinityVector_8; }
inline void set_negativeInfinityVector_8(Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E value)
{
___negativeInfinityVector_8 = value;
}
};
// System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>
struct Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D
{
public:
// System.Int32 System.Collections.Generic.Dictionary`2_Entry::hashCode
int32_t ___hashCode_0;
// System.Int32 System.Collections.Generic.Dictionary`2_Entry::next
int32_t ___next_1;
// TKey System.Collections.Generic.Dictionary`2_Entry::key
RuntimeObject * ___key_2;
// TValue System.Collections.Generic.Dictionary`2_Entry::value
ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C ___value_3;
public:
inline static int32_t get_offset_of_hashCode_0() { return static_cast<int32_t>(offsetof(Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D, ___hashCode_0)); }
inline int32_t get_hashCode_0() const { return ___hashCode_0; }
inline int32_t* get_address_of_hashCode_0() { return &___hashCode_0; }
inline void set_hashCode_0(int32_t value)
{
___hashCode_0 = value;
}
inline static int32_t get_offset_of_next_1() { return static_cast<int32_t>(offsetof(Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D, ___next_1)); }
inline int32_t get_next_1() const { return ___next_1; }
inline int32_t* get_address_of_next_1() { return &___next_1; }
inline void set_next_1(int32_t value)
{
___next_1 = value;
}
inline static int32_t get_offset_of_key_2() { return static_cast<int32_t>(offsetof(Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D, ___key_2)); }
inline RuntimeObject * get_key_2() const { return ___key_2; }
inline RuntimeObject ** get_address_of_key_2() { return &___key_2; }
inline void set_key_2(RuntimeObject * value)
{
___key_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_2), (void*)value);
}
inline static int32_t get_offset_of_value_3() { return static_cast<int32_t>(offsetof(Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D, ___value_3)); }
inline ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C get_value_3() const { return ___value_3; }
inline ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C * get_address_of_value_3() { return &___value_3; }
inline void set_value_3(ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C value)
{
___value_3 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___value_3))->____value_0), (void*)NULL);
}
};
// System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>
struct KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B, ___key_0)); }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 get_key_0() const { return ___key_0; }
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 * get_address_of_key_0() { return &___key_0; }
inline void set_key_0(DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>
struct KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
Guid_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
int32_t ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937, ___key_0)); }
inline Guid_t get_key_0() const { return ___key_0; }
inline Guid_t * get_address_of_key_0() { return &___key_0; }
inline void set_key_0(Guid_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937, ___value_1)); }
inline int32_t get_value_1() const { return ___value_1; }
inline int32_t* get_address_of_value_1() { return &___value_1; }
inline void set_value_1(int32_t value)
{
___value_1 = value;
}
};
// System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>
struct KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
Guid_t ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject * ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78, ___key_0)); }
inline Guid_t get_key_0() const { return ___key_0; }
inline Guid_t * get_address_of_key_0() { return &___key_0; }
inline void set_key_0(Guid_t value)
{
___key_0 = value;
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78, ___value_1)); }
inline RuntimeObject * get_value_1() const { return ___value_1; }
inline RuntimeObject ** get_address_of_value_1() { return &___value_1; }
inline void set_value_1(RuntimeObject * value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___value_1), (void*)value);
}
};
// System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>
struct KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6
{
public:
// TKey System.Collections.Generic.KeyValuePair`2::key
RuntimeObject * ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C ___value_1;
public:
inline static int32_t get_offset_of_key_0() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6, ___key_0)); }
inline RuntimeObject * get_key_0() const { return ___key_0; }
inline RuntimeObject ** get_address_of_key_0() { return &___key_0; }
inline void set_key_0(RuntimeObject * value)
{
___key_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___key_0), (void*)value);
}
inline static int32_t get_offset_of_value_1() { return static_cast<int32_t>(offsetof(KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6, ___value_1)); }
inline ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C get_value_1() const { return ___value_1; }
inline ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C * get_address_of_value_1() { return &___value_1; }
inline void set_value_1(ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C value)
{
___value_1 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___value_1))->____value_0), (void*)NULL);
}
};
// System.Delegate
struct Delegate_t : public RuntimeObject
{
public:
// System.IntPtr System.Delegate::method_ptr
Il2CppMethodPointer ___method_ptr_0;
// System.IntPtr System.Delegate::invoke_impl
intptr_t ___invoke_impl_1;
// System.Object System.Delegate::m_target
RuntimeObject * ___m_target_2;
// System.IntPtr System.Delegate::method
intptr_t ___method_3;
// System.IntPtr System.Delegate::delegate_trampoline
intptr_t ___delegate_trampoline_4;
// System.IntPtr System.Delegate::extra_arg
intptr_t ___extra_arg_5;
// System.IntPtr System.Delegate::method_code
intptr_t ___method_code_6;
// System.Reflection.MethodInfo System.Delegate::method_info
MethodInfo_t * ___method_info_7;
// System.Reflection.MethodInfo System.Delegate::original_method_info
MethodInfo_t * ___original_method_info_8;
// System.DelegateData System.Delegate::data
DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * ___data_9;
// System.Boolean System.Delegate::method_is_virtual
bool ___method_is_virtual_10;
public:
inline static int32_t get_offset_of_method_ptr_0() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_ptr_0)); }
inline Il2CppMethodPointer get_method_ptr_0() const { return ___method_ptr_0; }
inline Il2CppMethodPointer* get_address_of_method_ptr_0() { return &___method_ptr_0; }
inline void set_method_ptr_0(Il2CppMethodPointer value)
{
___method_ptr_0 = value;
}
inline static int32_t get_offset_of_invoke_impl_1() { return static_cast<int32_t>(offsetof(Delegate_t, ___invoke_impl_1)); }
inline intptr_t get_invoke_impl_1() const { return ___invoke_impl_1; }
inline intptr_t* get_address_of_invoke_impl_1() { return &___invoke_impl_1; }
inline void set_invoke_impl_1(intptr_t value)
{
___invoke_impl_1 = value;
}
inline static int32_t get_offset_of_m_target_2() { return static_cast<int32_t>(offsetof(Delegate_t, ___m_target_2)); }
inline RuntimeObject * get_m_target_2() const { return ___m_target_2; }
inline RuntimeObject ** get_address_of_m_target_2() { return &___m_target_2; }
inline void set_m_target_2(RuntimeObject * value)
{
___m_target_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_target_2), (void*)value);
}
inline static int32_t get_offset_of_method_3() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_3)); }
inline intptr_t get_method_3() const { return ___method_3; }
inline intptr_t* get_address_of_method_3() { return &___method_3; }
inline void set_method_3(intptr_t value)
{
___method_3 = value;
}
inline static int32_t get_offset_of_delegate_trampoline_4() { return static_cast<int32_t>(offsetof(Delegate_t, ___delegate_trampoline_4)); }
inline intptr_t get_delegate_trampoline_4() const { return ___delegate_trampoline_4; }
inline intptr_t* get_address_of_delegate_trampoline_4() { return &___delegate_trampoline_4; }
inline void set_delegate_trampoline_4(intptr_t value)
{
___delegate_trampoline_4 = value;
}
inline static int32_t get_offset_of_extra_arg_5() { return static_cast<int32_t>(offsetof(Delegate_t, ___extra_arg_5)); }
inline intptr_t get_extra_arg_5() const { return ___extra_arg_5; }
inline intptr_t* get_address_of_extra_arg_5() { return &___extra_arg_5; }
inline void set_extra_arg_5(intptr_t value)
{
___extra_arg_5 = value;
}
inline static int32_t get_offset_of_method_code_6() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_code_6)); }
inline intptr_t get_method_code_6() const { return ___method_code_6; }
inline intptr_t* get_address_of_method_code_6() { return &___method_code_6; }
inline void set_method_code_6(intptr_t value)
{
___method_code_6 = value;
}
inline static int32_t get_offset_of_method_info_7() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_info_7)); }
inline MethodInfo_t * get_method_info_7() const { return ___method_info_7; }
inline MethodInfo_t ** get_address_of_method_info_7() { return &___method_info_7; }
inline void set_method_info_7(MethodInfo_t * value)
{
___method_info_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___method_info_7), (void*)value);
}
inline static int32_t get_offset_of_original_method_info_8() { return static_cast<int32_t>(offsetof(Delegate_t, ___original_method_info_8)); }
inline MethodInfo_t * get_original_method_info_8() const { return ___original_method_info_8; }
inline MethodInfo_t ** get_address_of_original_method_info_8() { return &___original_method_info_8; }
inline void set_original_method_info_8(MethodInfo_t * value)
{
___original_method_info_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___original_method_info_8), (void*)value);
}
inline static int32_t get_offset_of_data_9() { return static_cast<int32_t>(offsetof(Delegate_t, ___data_9)); }
inline DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * get_data_9() const { return ___data_9; }
inline DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE ** get_address_of_data_9() { return &___data_9; }
inline void set_data_9(DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * value)
{
___data_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___data_9), (void*)value);
}
inline static int32_t get_offset_of_method_is_virtual_10() { return static_cast<int32_t>(offsetof(Delegate_t, ___method_is_virtual_10)); }
inline bool get_method_is_virtual_10() const { return ___method_is_virtual_10; }
inline bool* get_address_of_method_is_virtual_10() { return &___method_is_virtual_10; }
inline void set_method_is_virtual_10(bool value)
{
___method_is_virtual_10 = value;
}
};
// Native definition for P/Invoke marshalling of System.Delegate
struct Delegate_t_marshaled_pinvoke
{
intptr_t ___method_ptr_0;
intptr_t ___invoke_impl_1;
Il2CppIUnknown* ___m_target_2;
intptr_t ___method_3;
intptr_t ___delegate_trampoline_4;
intptr_t ___extra_arg_5;
intptr_t ___method_code_6;
MethodInfo_t * ___method_info_7;
MethodInfo_t * ___original_method_info_8;
DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * ___data_9;
int32_t ___method_is_virtual_10;
};
// Native definition for COM marshalling of System.Delegate
struct Delegate_t_marshaled_com
{
intptr_t ___method_ptr_0;
intptr_t ___invoke_impl_1;
Il2CppIUnknown* ___m_target_2;
intptr_t ___method_3;
intptr_t ___delegate_trampoline_4;
intptr_t ___extra_arg_5;
intptr_t ___method_code_6;
MethodInfo_t * ___method_info_7;
MethodInfo_t * ___original_method_info_8;
DelegateData_t1BF9F691B56DAE5F8C28C5E084FDE94F15F27BBE * ___data_9;
int32_t ___method_is_virtual_10;
};
// System.Diagnostics.Tracing.EventActivityOptions
struct EventActivityOptions_t929DC56692200C1AE8FD9194A2510B6149D69168
{
public:
// System.Int32 System.Diagnostics.Tracing.EventActivityOptions::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(EventActivityOptions_t929DC56692200C1AE8FD9194A2510B6149D69168, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Diagnostics.Tracing.EventTags
struct EventTags_t886E6B89C75F05A5BA40FBC96790AA6C5F24A712
{
public:
// System.Int32 System.Diagnostics.Tracing.EventTags::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(EventTags_t886E6B89C75F05A5BA40FBC96790AA6C5F24A712, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Exception
struct Exception_t : public RuntimeObject
{
public:
// System.String System.Exception::_className
String_t* ____className_1;
// System.String System.Exception::_message
String_t* ____message_2;
// System.Collections.IDictionary System.Exception::_data
RuntimeObject* ____data_3;
// System.Exception System.Exception::_innerException
Exception_t * ____innerException_4;
// System.String System.Exception::_helpURL
String_t* ____helpURL_5;
// System.Object System.Exception::_stackTrace
RuntimeObject * ____stackTrace_6;
// System.String System.Exception::_stackTraceString
String_t* ____stackTraceString_7;
// System.String System.Exception::_remoteStackTraceString
String_t* ____remoteStackTraceString_8;
// System.Int32 System.Exception::_remoteStackIndex
int32_t ____remoteStackIndex_9;
// System.Object System.Exception::_dynamicMethods
RuntimeObject * ____dynamicMethods_10;
// System.Int32 System.Exception::_HResult
int32_t ____HResult_11;
// System.String System.Exception::_source
String_t* ____source_12;
// System.Runtime.Serialization.SafeSerializationManager System.Exception::_safeSerializationManager
SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * ____safeSerializationManager_13;
// System.Diagnostics.StackTrace[] System.Exception::captured_traces
StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* ___captured_traces_14;
// System.IntPtr[] System.Exception::native_trace_ips
IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* ___native_trace_ips_15;
public:
inline static int32_t get_offset_of__className_1() { return static_cast<int32_t>(offsetof(Exception_t, ____className_1)); }
inline String_t* get__className_1() const { return ____className_1; }
inline String_t** get_address_of__className_1() { return &____className_1; }
inline void set__className_1(String_t* value)
{
____className_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____className_1), (void*)value);
}
inline static int32_t get_offset_of__message_2() { return static_cast<int32_t>(offsetof(Exception_t, ____message_2)); }
inline String_t* get__message_2() const { return ____message_2; }
inline String_t** get_address_of__message_2() { return &____message_2; }
inline void set__message_2(String_t* value)
{
____message_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&____message_2), (void*)value);
}
inline static int32_t get_offset_of__data_3() { return static_cast<int32_t>(offsetof(Exception_t, ____data_3)); }
inline RuntimeObject* get__data_3() const { return ____data_3; }
inline RuntimeObject** get_address_of__data_3() { return &____data_3; }
inline void set__data_3(RuntimeObject* value)
{
____data_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&____data_3), (void*)value);
}
inline static int32_t get_offset_of__innerException_4() { return static_cast<int32_t>(offsetof(Exception_t, ____innerException_4)); }
inline Exception_t * get__innerException_4() const { return ____innerException_4; }
inline Exception_t ** get_address_of__innerException_4() { return &____innerException_4; }
inline void set__innerException_4(Exception_t * value)
{
____innerException_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&____innerException_4), (void*)value);
}
inline static int32_t get_offset_of__helpURL_5() { return static_cast<int32_t>(offsetof(Exception_t, ____helpURL_5)); }
inline String_t* get__helpURL_5() const { return ____helpURL_5; }
inline String_t** get_address_of__helpURL_5() { return &____helpURL_5; }
inline void set__helpURL_5(String_t* value)
{
____helpURL_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&____helpURL_5), (void*)value);
}
inline static int32_t get_offset_of__stackTrace_6() { return static_cast<int32_t>(offsetof(Exception_t, ____stackTrace_6)); }
inline RuntimeObject * get__stackTrace_6() const { return ____stackTrace_6; }
inline RuntimeObject ** get_address_of__stackTrace_6() { return &____stackTrace_6; }
inline void set__stackTrace_6(RuntimeObject * value)
{
____stackTrace_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&____stackTrace_6), (void*)value);
}
inline static int32_t get_offset_of__stackTraceString_7() { return static_cast<int32_t>(offsetof(Exception_t, ____stackTraceString_7)); }
inline String_t* get__stackTraceString_7() const { return ____stackTraceString_7; }
inline String_t** get_address_of__stackTraceString_7() { return &____stackTraceString_7; }
inline void set__stackTraceString_7(String_t* value)
{
____stackTraceString_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&____stackTraceString_7), (void*)value);
}
inline static int32_t get_offset_of__remoteStackTraceString_8() { return static_cast<int32_t>(offsetof(Exception_t, ____remoteStackTraceString_8)); }
inline String_t* get__remoteStackTraceString_8() const { return ____remoteStackTraceString_8; }
inline String_t** get_address_of__remoteStackTraceString_8() { return &____remoteStackTraceString_8; }
inline void set__remoteStackTraceString_8(String_t* value)
{
____remoteStackTraceString_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&____remoteStackTraceString_8), (void*)value);
}
inline static int32_t get_offset_of__remoteStackIndex_9() { return static_cast<int32_t>(offsetof(Exception_t, ____remoteStackIndex_9)); }
inline int32_t get__remoteStackIndex_9() const { return ____remoteStackIndex_9; }
inline int32_t* get_address_of__remoteStackIndex_9() { return &____remoteStackIndex_9; }
inline void set__remoteStackIndex_9(int32_t value)
{
____remoteStackIndex_9 = value;
}
inline static int32_t get_offset_of__dynamicMethods_10() { return static_cast<int32_t>(offsetof(Exception_t, ____dynamicMethods_10)); }
inline RuntimeObject * get__dynamicMethods_10() const { return ____dynamicMethods_10; }
inline RuntimeObject ** get_address_of__dynamicMethods_10() { return &____dynamicMethods_10; }
inline void set__dynamicMethods_10(RuntimeObject * value)
{
____dynamicMethods_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&____dynamicMethods_10), (void*)value);
}
inline static int32_t get_offset_of__HResult_11() { return static_cast<int32_t>(offsetof(Exception_t, ____HResult_11)); }
inline int32_t get__HResult_11() const { return ____HResult_11; }
inline int32_t* get_address_of__HResult_11() { return &____HResult_11; }
inline void set__HResult_11(int32_t value)
{
____HResult_11 = value;
}
inline static int32_t get_offset_of__source_12() { return static_cast<int32_t>(offsetof(Exception_t, ____source_12)); }
inline String_t* get__source_12() const { return ____source_12; }
inline String_t** get_address_of__source_12() { return &____source_12; }
inline void set__source_12(String_t* value)
{
____source_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&____source_12), (void*)value);
}
inline static int32_t get_offset_of__safeSerializationManager_13() { return static_cast<int32_t>(offsetof(Exception_t, ____safeSerializationManager_13)); }
inline SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * get__safeSerializationManager_13() const { return ____safeSerializationManager_13; }
inline SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 ** get_address_of__safeSerializationManager_13() { return &____safeSerializationManager_13; }
inline void set__safeSerializationManager_13(SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * value)
{
____safeSerializationManager_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&____safeSerializationManager_13), (void*)value);
}
inline static int32_t get_offset_of_captured_traces_14() { return static_cast<int32_t>(offsetof(Exception_t, ___captured_traces_14)); }
inline StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* get_captured_traces_14() const { return ___captured_traces_14; }
inline StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196** get_address_of_captured_traces_14() { return &___captured_traces_14; }
inline void set_captured_traces_14(StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* value)
{
___captured_traces_14 = value;
Il2CppCodeGenWriteBarrier((void**)(&___captured_traces_14), (void*)value);
}
inline static int32_t get_offset_of_native_trace_ips_15() { return static_cast<int32_t>(offsetof(Exception_t, ___native_trace_ips_15)); }
inline IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* get_native_trace_ips_15() const { return ___native_trace_ips_15; }
inline IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD** get_address_of_native_trace_ips_15() { return &___native_trace_ips_15; }
inline void set_native_trace_ips_15(IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* value)
{
___native_trace_ips_15 = value;
Il2CppCodeGenWriteBarrier((void**)(&___native_trace_ips_15), (void*)value);
}
};
struct Exception_t_StaticFields
{
public:
// System.Object System.Exception::s_EDILock
RuntimeObject * ___s_EDILock_0;
public:
inline static int32_t get_offset_of_s_EDILock_0() { return static_cast<int32_t>(offsetof(Exception_t_StaticFields, ___s_EDILock_0)); }
inline RuntimeObject * get_s_EDILock_0() const { return ___s_EDILock_0; }
inline RuntimeObject ** get_address_of_s_EDILock_0() { return &___s_EDILock_0; }
inline void set_s_EDILock_0(RuntimeObject * value)
{
___s_EDILock_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_EDILock_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Exception
struct Exception_t_marshaled_pinvoke
{
char* ____className_1;
char* ____message_2;
RuntimeObject* ____data_3;
Exception_t_marshaled_pinvoke* ____innerException_4;
char* ____helpURL_5;
Il2CppIUnknown* ____stackTrace_6;
char* ____stackTraceString_7;
char* ____remoteStackTraceString_8;
int32_t ____remoteStackIndex_9;
Il2CppIUnknown* ____dynamicMethods_10;
int32_t ____HResult_11;
char* ____source_12;
SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * ____safeSerializationManager_13;
StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* ___captured_traces_14;
Il2CppSafeArray/*NONE*/* ___native_trace_ips_15;
};
// Native definition for COM marshalling of System.Exception
struct Exception_t_marshaled_com
{
Il2CppChar* ____className_1;
Il2CppChar* ____message_2;
RuntimeObject* ____data_3;
Exception_t_marshaled_com* ____innerException_4;
Il2CppChar* ____helpURL_5;
Il2CppIUnknown* ____stackTrace_6;
Il2CppChar* ____stackTraceString_7;
Il2CppChar* ____remoteStackTraceString_8;
int32_t ____remoteStackIndex_9;
Il2CppIUnknown* ____dynamicMethods_10;
int32_t ____HResult_11;
Il2CppChar* ____source_12;
SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * ____safeSerializationManager_13;
StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* ___captured_traces_14;
Il2CppSafeArray/*NONE*/* ___native_trace_ips_15;
};
// System.Int32Enum
struct Int32Enum_t6312CE4586C17FE2E2E513D2E7655B574F10FDCD
{
public:
// System.Int32 System.Int32Enum::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Int32Enum_t6312CE4586C17FE2E2E513D2E7655B574F10FDCD, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Reflection.CustomAttributeNamedArgument
struct CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E
{
public:
// System.Reflection.CustomAttributeTypedArgument System.Reflection.CustomAttributeNamedArgument::typedArgument
CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 ___typedArgument_0;
// System.Reflection.MemberInfo System.Reflection.CustomAttributeNamedArgument::memberInfo
MemberInfo_t * ___memberInfo_1;
public:
inline static int32_t get_offset_of_typedArgument_0() { return static_cast<int32_t>(offsetof(CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E, ___typedArgument_0)); }
inline CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 get_typedArgument_0() const { return ___typedArgument_0; }
inline CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 * get_address_of_typedArgument_0() { return &___typedArgument_0; }
inline void set_typedArgument_0(CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 value)
{
___typedArgument_0 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___typedArgument_0))->___argumentType_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&(((&___typedArgument_0))->___value_1), (void*)NULL);
#endif
}
inline static int32_t get_offset_of_memberInfo_1() { return static_cast<int32_t>(offsetof(CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E, ___memberInfo_1)); }
inline MemberInfo_t * get_memberInfo_1() const { return ___memberInfo_1; }
inline MemberInfo_t ** get_address_of_memberInfo_1() { return &___memberInfo_1; }
inline void set_memberInfo_1(MemberInfo_t * value)
{
___memberInfo_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___memberInfo_1), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Reflection.CustomAttributeNamedArgument
struct CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E_marshaled_pinvoke
{
CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8_marshaled_pinvoke ___typedArgument_0;
MemberInfo_t * ___memberInfo_1;
};
// Native definition for COM marshalling of System.Reflection.CustomAttributeNamedArgument
struct CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E_marshaled_com
{
CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8_marshaled_com ___typedArgument_0;
MemberInfo_t * ___memberInfo_1;
};
// System.Threading.CancellationTokenRegistration
struct CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2
{
public:
// System.Threading.CancellationCallbackInfo System.Threading.CancellationTokenRegistration::m_callbackInfo
CancellationCallbackInfo_t8CDEA0AA9C9D1A2321FE2F88878F4B5E0901CF36 * ___m_callbackInfo_0;
// System.Threading.SparselyPopulatedArrayAddInfo`1<System.Threading.CancellationCallbackInfo> System.Threading.CancellationTokenRegistration::m_registrationInfo
SparselyPopulatedArrayAddInfo_1_t0A76BDD84EBF76BEF894419FC221D25BB3D4FBEE ___m_registrationInfo_1;
public:
inline static int32_t get_offset_of_m_callbackInfo_0() { return static_cast<int32_t>(offsetof(CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2, ___m_callbackInfo_0)); }
inline CancellationCallbackInfo_t8CDEA0AA9C9D1A2321FE2F88878F4B5E0901CF36 * get_m_callbackInfo_0() const { return ___m_callbackInfo_0; }
inline CancellationCallbackInfo_t8CDEA0AA9C9D1A2321FE2F88878F4B5E0901CF36 ** get_address_of_m_callbackInfo_0() { return &___m_callbackInfo_0; }
inline void set_m_callbackInfo_0(CancellationCallbackInfo_t8CDEA0AA9C9D1A2321FE2F88878F4B5E0901CF36 * value)
{
___m_callbackInfo_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_callbackInfo_0), (void*)value);
}
inline static int32_t get_offset_of_m_registrationInfo_1() { return static_cast<int32_t>(offsetof(CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2, ___m_registrationInfo_1)); }
inline SparselyPopulatedArrayAddInfo_1_t0A76BDD84EBF76BEF894419FC221D25BB3D4FBEE get_m_registrationInfo_1() const { return ___m_registrationInfo_1; }
inline SparselyPopulatedArrayAddInfo_1_t0A76BDD84EBF76BEF894419FC221D25BB3D4FBEE * get_address_of_m_registrationInfo_1() { return &___m_registrationInfo_1; }
inline void set_m_registrationInfo_1(SparselyPopulatedArrayAddInfo_1_t0A76BDD84EBF76BEF894419FC221D25BB3D4FBEE value)
{
___m_registrationInfo_1 = value;
Il2CppCodeGenWriteBarrier((void**)&(((&___m_registrationInfo_1))->___m_source_0), (void*)NULL);
}
};
// Native definition for P/Invoke marshalling of System.Threading.CancellationTokenRegistration
struct CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2_marshaled_pinvoke
{
CancellationCallbackInfo_t8CDEA0AA9C9D1A2321FE2F88878F4B5E0901CF36 * ___m_callbackInfo_0;
SparselyPopulatedArrayAddInfo_1_t0A76BDD84EBF76BEF894419FC221D25BB3D4FBEE ___m_registrationInfo_1;
};
// Native definition for COM marshalling of System.Threading.CancellationTokenRegistration
struct CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2_marshaled_com
{
CancellationCallbackInfo_t8CDEA0AA9C9D1A2321FE2F88878F4B5E0901CF36 * ___m_callbackInfo_0;
SparselyPopulatedArrayAddInfo_1_t0A76BDD84EBF76BEF894419FC221D25BB3D4FBEE ___m_registrationInfo_1;
};
// System.TimeSpan
struct TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4
{
public:
// System.Int64 System.TimeSpan::_ticks
int64_t ____ticks_3;
public:
inline static int32_t get_offset_of__ticks_3() { return static_cast<int32_t>(offsetof(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4, ____ticks_3)); }
inline int64_t get__ticks_3() const { return ____ticks_3; }
inline int64_t* get_address_of__ticks_3() { return &____ticks_3; }
inline void set__ticks_3(int64_t value)
{
____ticks_3 = value;
}
};
struct TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4_StaticFields
{
public:
// System.TimeSpan System.TimeSpan::Zero
TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 ___Zero_0;
// System.TimeSpan System.TimeSpan::MaxValue
TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 ___MaxValue_1;
// System.TimeSpan System.TimeSpan::MinValue
TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 ___MinValue_2;
// System.Boolean modreq(System.Runtime.CompilerServices.IsVolatile) System.TimeSpan::_legacyConfigChecked
bool ____legacyConfigChecked_4;
// System.Boolean modreq(System.Runtime.CompilerServices.IsVolatile) System.TimeSpan::_legacyMode
bool ____legacyMode_5;
public:
inline static int32_t get_offset_of_Zero_0() { return static_cast<int32_t>(offsetof(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4_StaticFields, ___Zero_0)); }
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 get_Zero_0() const { return ___Zero_0; }
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 * get_address_of_Zero_0() { return &___Zero_0; }
inline void set_Zero_0(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 value)
{
___Zero_0 = value;
}
inline static int32_t get_offset_of_MaxValue_1() { return static_cast<int32_t>(offsetof(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4_StaticFields, ___MaxValue_1)); }
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 get_MaxValue_1() const { return ___MaxValue_1; }
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 * get_address_of_MaxValue_1() { return &___MaxValue_1; }
inline void set_MaxValue_1(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 value)
{
___MaxValue_1 = value;
}
inline static int32_t get_offset_of_MinValue_2() { return static_cast<int32_t>(offsetof(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4_StaticFields, ___MinValue_2)); }
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 get_MinValue_2() const { return ___MinValue_2; }
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 * get_address_of_MinValue_2() { return &___MinValue_2; }
inline void set_MinValue_2(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 value)
{
___MinValue_2 = value;
}
inline static int32_t get_offset_of__legacyConfigChecked_4() { return static_cast<int32_t>(offsetof(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4_StaticFields, ____legacyConfigChecked_4)); }
inline bool get__legacyConfigChecked_4() const { return ____legacyConfigChecked_4; }
inline bool* get_address_of__legacyConfigChecked_4() { return &____legacyConfigChecked_4; }
inline void set__legacyConfigChecked_4(bool value)
{
____legacyConfigChecked_4 = value;
}
inline static int32_t get_offset_of__legacyMode_5() { return static_cast<int32_t>(offsetof(TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4_StaticFields, ____legacyMode_5)); }
inline bool get__legacyMode_5() const { return ____legacyMode_5; }
inline bool* get_address_of__legacyMode_5() { return &____legacyMode_5; }
inline void set__legacyMode_5(bool value)
{
____legacyMode_5 = value;
}
};
// Unity.Collections.Allocator
struct Allocator_t62A091275262E7067EAAD565B67764FA877D58D6
{
public:
// System.Int32 Unity.Collections.Allocator::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Allocator_t62A091275262E7067EAAD565B67764FA877D58D6, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.EventSystems.RaycastResult
struct RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91
{
public:
// UnityEngine.GameObject UnityEngine.EventSystems.RaycastResult::m_GameObject
GameObject_tBD1244AD56B4E59AAD76E5E7C9282EC5CE434F0F * ___m_GameObject_0;
// UnityEngine.EventSystems.BaseRaycaster UnityEngine.EventSystems.RaycastResult::module
BaseRaycaster_tC7F6105A89F54A38FBFC2659901855FDBB0E3966 * ___module_1;
// System.Single UnityEngine.EventSystems.RaycastResult::distance
float ___distance_2;
// System.Single UnityEngine.EventSystems.RaycastResult::index
float ___index_3;
// System.Int32 UnityEngine.EventSystems.RaycastResult::depth
int32_t ___depth_4;
// System.Int32 UnityEngine.EventSystems.RaycastResult::sortingLayer
int32_t ___sortingLayer_5;
// System.Int32 UnityEngine.EventSystems.RaycastResult::sortingOrder
int32_t ___sortingOrder_6;
// UnityEngine.Vector3 UnityEngine.EventSystems.RaycastResult::worldPosition
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___worldPosition_7;
// UnityEngine.Vector3 UnityEngine.EventSystems.RaycastResult::worldNormal
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___worldNormal_8;
// UnityEngine.Vector2 UnityEngine.EventSystems.RaycastResult::screenPosition
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___screenPosition_9;
// System.Int32 UnityEngine.EventSystems.RaycastResult::displayIndex
int32_t ___displayIndex_10;
public:
inline static int32_t get_offset_of_m_GameObject_0() { return static_cast<int32_t>(offsetof(RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91, ___m_GameObject_0)); }
inline GameObject_tBD1244AD56B4E59AAD76E5E7C9282EC5CE434F0F * get_m_GameObject_0() const { return ___m_GameObject_0; }
inline GameObject_tBD1244AD56B4E59AAD76E5E7C9282EC5CE434F0F ** get_address_of_m_GameObject_0() { return &___m_GameObject_0; }
inline void set_m_GameObject_0(GameObject_tBD1244AD56B4E59AAD76E5E7C9282EC5CE434F0F * value)
{
___m_GameObject_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_GameObject_0), (void*)value);
}
inline static int32_t get_offset_of_module_1() { return static_cast<int32_t>(offsetof(RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91, ___module_1)); }
inline BaseRaycaster_tC7F6105A89F54A38FBFC2659901855FDBB0E3966 * get_module_1() const { return ___module_1; }
inline BaseRaycaster_tC7F6105A89F54A38FBFC2659901855FDBB0E3966 ** get_address_of_module_1() { return &___module_1; }
inline void set_module_1(BaseRaycaster_tC7F6105A89F54A38FBFC2659901855FDBB0E3966 * value)
{
___module_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___module_1), (void*)value);
}
inline static int32_t get_offset_of_distance_2() { return static_cast<int32_t>(offsetof(RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91, ___distance_2)); }
inline float get_distance_2() const { return ___distance_2; }
inline float* get_address_of_distance_2() { return &___distance_2; }
inline void set_distance_2(float value)
{
___distance_2 = value;
}
inline static int32_t get_offset_of_index_3() { return static_cast<int32_t>(offsetof(RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91, ___index_3)); }
inline float get_index_3() const { return ___index_3; }
inline float* get_address_of_index_3() { return &___index_3; }
inline void set_index_3(float value)
{
___index_3 = value;
}
inline static int32_t get_offset_of_depth_4() { return static_cast<int32_t>(offsetof(RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91, ___depth_4)); }
inline int32_t get_depth_4() const { return ___depth_4; }
inline int32_t* get_address_of_depth_4() { return &___depth_4; }
inline void set_depth_4(int32_t value)
{
___depth_4 = value;
}
inline static int32_t get_offset_of_sortingLayer_5() { return static_cast<int32_t>(offsetof(RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91, ___sortingLayer_5)); }
inline int32_t get_sortingLayer_5() const { return ___sortingLayer_5; }
inline int32_t* get_address_of_sortingLayer_5() { return &___sortingLayer_5; }
inline void set_sortingLayer_5(int32_t value)
{
___sortingLayer_5 = value;
}
inline static int32_t get_offset_of_sortingOrder_6() { return static_cast<int32_t>(offsetof(RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91, ___sortingOrder_6)); }
inline int32_t get_sortingOrder_6() const { return ___sortingOrder_6; }
inline int32_t* get_address_of_sortingOrder_6() { return &___sortingOrder_6; }
inline void set_sortingOrder_6(int32_t value)
{
___sortingOrder_6 = value;
}
inline static int32_t get_offset_of_worldPosition_7() { return static_cast<int32_t>(offsetof(RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91, ___worldPosition_7)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_worldPosition_7() const { return ___worldPosition_7; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_worldPosition_7() { return &___worldPosition_7; }
inline void set_worldPosition_7(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___worldPosition_7 = value;
}
inline static int32_t get_offset_of_worldNormal_8() { return static_cast<int32_t>(offsetof(RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91, ___worldNormal_8)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_worldNormal_8() const { return ___worldNormal_8; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_worldNormal_8() { return &___worldNormal_8; }
inline void set_worldNormal_8(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___worldNormal_8 = value;
}
inline static int32_t get_offset_of_screenPosition_9() { return static_cast<int32_t>(offsetof(RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91, ___screenPosition_9)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_screenPosition_9() const { return ___screenPosition_9; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_screenPosition_9() { return &___screenPosition_9; }
inline void set_screenPosition_9(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___screenPosition_9 = value;
}
inline static int32_t get_offset_of_displayIndex_10() { return static_cast<int32_t>(offsetof(RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91, ___displayIndex_10)); }
inline int32_t get_displayIndex_10() const { return ___displayIndex_10; }
inline int32_t* get_address_of_displayIndex_10() { return &___displayIndex_10; }
inline void set_displayIndex_10(int32_t value)
{
___displayIndex_10 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.EventSystems.RaycastResult
struct RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91_marshaled_pinvoke
{
GameObject_tBD1244AD56B4E59AAD76E5E7C9282EC5CE434F0F * ___m_GameObject_0;
BaseRaycaster_tC7F6105A89F54A38FBFC2659901855FDBB0E3966 * ___module_1;
float ___distance_2;
float ___index_3;
int32_t ___depth_4;
int32_t ___sortingLayer_5;
int32_t ___sortingOrder_6;
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___worldPosition_7;
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___worldNormal_8;
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___screenPosition_9;
int32_t ___displayIndex_10;
};
// Native definition for COM marshalling of UnityEngine.EventSystems.RaycastResult
struct RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91_marshaled_com
{
GameObject_tBD1244AD56B4E59AAD76E5E7C9282EC5CE434F0F * ___m_GameObject_0;
BaseRaycaster_tC7F6105A89F54A38FBFC2659901855FDBB0E3966 * ___module_1;
float ___distance_2;
float ___index_3;
int32_t ___depth_4;
int32_t ___sortingLayer_5;
int32_t ___sortingOrder_6;
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___worldPosition_7;
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___worldNormal_8;
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___screenPosition_9;
int32_t ___displayIndex_10;
};
// UnityEngine.Experimental.GlobalIllumination.FalloffType
struct FalloffType_t7875E80627449B25D89C044D11A2BA22AB4996E9
{
public:
// System.Byte UnityEngine.Experimental.GlobalIllumination.FalloffType::value__
uint8_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(FalloffType_t7875E80627449B25D89C044D11A2BA22AB4996E9, ___value___2)); }
inline uint8_t get_value___2() const { return ___value___2; }
inline uint8_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint8_t value)
{
___value___2 = value;
}
};
// UnityEngine.Experimental.GlobalIllumination.LightMode
struct LightMode_t2EFF26B7FB14FB7D2ACF550C591375B5A95A854A
{
public:
// System.Byte UnityEngine.Experimental.GlobalIllumination.LightMode::value__
uint8_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(LightMode_t2EFF26B7FB14FB7D2ACF550C591375B5A95A854A, ___value___2)); }
inline uint8_t get_value___2() const { return ___value___2; }
inline uint8_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint8_t value)
{
___value___2 = value;
}
};
// UnityEngine.Experimental.GlobalIllumination.LightType
struct LightType_t684FE1E4FB26D1A27EFCDB36446F55984C414E88
{
public:
// System.Byte UnityEngine.Experimental.GlobalIllumination.LightType::value__
uint8_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(LightType_t684FE1E4FB26D1A27EFCDB36446F55984C414E88, ___value___2)); }
inline uint8_t get_value___2() const { return ___value___2; }
inline uint8_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(uint8_t value)
{
___value___2 = value;
}
};
// UnityEngine.LowLevel.PlayerLoopSystem
struct PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93
{
public:
// System.Type UnityEngine.LowLevel.PlayerLoopSystem::type
Type_t * ___type_0;
// UnityEngine.LowLevel.PlayerLoopSystem[] UnityEngine.LowLevel.PlayerLoopSystem::subSystemList
PlayerLoopSystemU5BU5D_tA93C9CA08EF430375F9D4356DD0963BAEE961B77* ___subSystemList_1;
// UnityEngine.LowLevel.PlayerLoopSystem_UpdateFunction UnityEngine.LowLevel.PlayerLoopSystem::updateDelegate
UpdateFunction_tD84FFC4AEE25C3DEBD3AB85700E096090FC7995E * ___updateDelegate_2;
// System.IntPtr UnityEngine.LowLevel.PlayerLoopSystem::updateFunction
intptr_t ___updateFunction_3;
// System.IntPtr UnityEngine.LowLevel.PlayerLoopSystem::loopConditionFunction
intptr_t ___loopConditionFunction_4;
public:
inline static int32_t get_offset_of_type_0() { return static_cast<int32_t>(offsetof(PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93, ___type_0)); }
inline Type_t * get_type_0() const { return ___type_0; }
inline Type_t ** get_address_of_type_0() { return &___type_0; }
inline void set_type_0(Type_t * value)
{
___type_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___type_0), (void*)value);
}
inline static int32_t get_offset_of_subSystemList_1() { return static_cast<int32_t>(offsetof(PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93, ___subSystemList_1)); }
inline PlayerLoopSystemU5BU5D_tA93C9CA08EF430375F9D4356DD0963BAEE961B77* get_subSystemList_1() const { return ___subSystemList_1; }
inline PlayerLoopSystemU5BU5D_tA93C9CA08EF430375F9D4356DD0963BAEE961B77** get_address_of_subSystemList_1() { return &___subSystemList_1; }
inline void set_subSystemList_1(PlayerLoopSystemU5BU5D_tA93C9CA08EF430375F9D4356DD0963BAEE961B77* value)
{
___subSystemList_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___subSystemList_1), (void*)value);
}
inline static int32_t get_offset_of_updateDelegate_2() { return static_cast<int32_t>(offsetof(PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93, ___updateDelegate_2)); }
inline UpdateFunction_tD84FFC4AEE25C3DEBD3AB85700E096090FC7995E * get_updateDelegate_2() const { return ___updateDelegate_2; }
inline UpdateFunction_tD84FFC4AEE25C3DEBD3AB85700E096090FC7995E ** get_address_of_updateDelegate_2() { return &___updateDelegate_2; }
inline void set_updateDelegate_2(UpdateFunction_tD84FFC4AEE25C3DEBD3AB85700E096090FC7995E * value)
{
___updateDelegate_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___updateDelegate_2), (void*)value);
}
inline static int32_t get_offset_of_updateFunction_3() { return static_cast<int32_t>(offsetof(PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93, ___updateFunction_3)); }
inline intptr_t get_updateFunction_3() const { return ___updateFunction_3; }
inline intptr_t* get_address_of_updateFunction_3() { return &___updateFunction_3; }
inline void set_updateFunction_3(intptr_t value)
{
___updateFunction_3 = value;
}
inline static int32_t get_offset_of_loopConditionFunction_4() { return static_cast<int32_t>(offsetof(PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93, ___loopConditionFunction_4)); }
inline intptr_t get_loopConditionFunction_4() const { return ___loopConditionFunction_4; }
inline intptr_t* get_address_of_loopConditionFunction_4() { return &___loopConditionFunction_4; }
inline void set_loopConditionFunction_4(intptr_t value)
{
___loopConditionFunction_4 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.LowLevel.PlayerLoopSystem
struct PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93_marshaled_pinvoke
{
Type_t * ___type_0;
PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93_marshaled_pinvoke* ___subSystemList_1;
Il2CppMethodPointer ___updateDelegate_2;
intptr_t ___updateFunction_3;
intptr_t ___loopConditionFunction_4;
};
// Native definition for COM marshalling of UnityEngine.LowLevel.PlayerLoopSystem
struct PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93_marshaled_com
{
Type_t * ___type_0;
PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93_marshaled_com* ___subSystemList_1;
Il2CppMethodPointer ___updateDelegate_2;
intptr_t ___updateFunction_3;
intptr_t ___loopConditionFunction_4;
};
// UnityEngine.Object
struct Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0 : public RuntimeObject
{
public:
// System.IntPtr UnityEngine.Object::m_CachedPtr
intptr_t ___m_CachedPtr_0;
public:
inline static int32_t get_offset_of_m_CachedPtr_0() { return static_cast<int32_t>(offsetof(Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0, ___m_CachedPtr_0)); }
inline intptr_t get_m_CachedPtr_0() const { return ___m_CachedPtr_0; }
inline intptr_t* get_address_of_m_CachedPtr_0() { return &___m_CachedPtr_0; }
inline void set_m_CachedPtr_0(intptr_t value)
{
___m_CachedPtr_0 = value;
}
};
struct Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_StaticFields
{
public:
// System.Int32 UnityEngine.Object::OffsetOfInstanceIDInCPlusPlusObject
int32_t ___OffsetOfInstanceIDInCPlusPlusObject_1;
public:
inline static int32_t get_offset_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return static_cast<int32_t>(offsetof(Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_StaticFields, ___OffsetOfInstanceIDInCPlusPlusObject_1)); }
inline int32_t get_OffsetOfInstanceIDInCPlusPlusObject_1() const { return ___OffsetOfInstanceIDInCPlusPlusObject_1; }
inline int32_t* get_address_of_OffsetOfInstanceIDInCPlusPlusObject_1() { return &___OffsetOfInstanceIDInCPlusPlusObject_1; }
inline void set_OffsetOfInstanceIDInCPlusPlusObject_1(int32_t value)
{
___OffsetOfInstanceIDInCPlusPlusObject_1 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Object
struct Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_marshaled_pinvoke
{
intptr_t ___m_CachedPtr_0;
};
// Native definition for COM marshalling of UnityEngine.Object
struct Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_marshaled_com
{
intptr_t ___m_CachedPtr_0;
};
// UnityEngine.Plane
struct Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED
{
public:
// UnityEngine.Vector3 UnityEngine.Plane::m_Normal
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___m_Normal_0;
// System.Single UnityEngine.Plane::m_Distance
float ___m_Distance_1;
public:
inline static int32_t get_offset_of_m_Normal_0() { return static_cast<int32_t>(offsetof(Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED, ___m_Normal_0)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_m_Normal_0() const { return ___m_Normal_0; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_m_Normal_0() { return &___m_Normal_0; }
inline void set_m_Normal_0(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___m_Normal_0 = value;
}
inline static int32_t get_offset_of_m_Distance_1() { return static_cast<int32_t>(offsetof(Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED, ___m_Distance_1)); }
inline float get_m_Distance_1() const { return ___m_Distance_1; }
inline float* get_address_of_m_Distance_1() { return &___m_Distance_1; }
inline void set_m_Distance_1(float value)
{
___m_Distance_1 = value;
}
};
// UnityEngine.RaycastHit
struct RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3
{
public:
// UnityEngine.Vector3 UnityEngine.RaycastHit::m_Point
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___m_Point_0;
// UnityEngine.Vector3 UnityEngine.RaycastHit::m_Normal
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___m_Normal_1;
// System.UInt32 UnityEngine.RaycastHit::m_FaceID
uint32_t ___m_FaceID_2;
// System.Single UnityEngine.RaycastHit::m_Distance
float ___m_Distance_3;
// UnityEngine.Vector2 UnityEngine.RaycastHit::m_UV
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___m_UV_4;
// System.Int32 UnityEngine.RaycastHit::m_Collider
int32_t ___m_Collider_5;
public:
inline static int32_t get_offset_of_m_Point_0() { return static_cast<int32_t>(offsetof(RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3, ___m_Point_0)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_m_Point_0() const { return ___m_Point_0; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_m_Point_0() { return &___m_Point_0; }
inline void set_m_Point_0(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___m_Point_0 = value;
}
inline static int32_t get_offset_of_m_Normal_1() { return static_cast<int32_t>(offsetof(RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3, ___m_Normal_1)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_m_Normal_1() const { return ___m_Normal_1; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_m_Normal_1() { return &___m_Normal_1; }
inline void set_m_Normal_1(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___m_Normal_1 = value;
}
inline static int32_t get_offset_of_m_FaceID_2() { return static_cast<int32_t>(offsetof(RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3, ___m_FaceID_2)); }
inline uint32_t get_m_FaceID_2() const { return ___m_FaceID_2; }
inline uint32_t* get_address_of_m_FaceID_2() { return &___m_FaceID_2; }
inline void set_m_FaceID_2(uint32_t value)
{
___m_FaceID_2 = value;
}
inline static int32_t get_offset_of_m_Distance_3() { return static_cast<int32_t>(offsetof(RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3, ___m_Distance_3)); }
inline float get_m_Distance_3() const { return ___m_Distance_3; }
inline float* get_address_of_m_Distance_3() { return &___m_Distance_3; }
inline void set_m_Distance_3(float value)
{
___m_Distance_3 = value;
}
inline static int32_t get_offset_of_m_UV_4() { return static_cast<int32_t>(offsetof(RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3, ___m_UV_4)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_m_UV_4() const { return ___m_UV_4; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_m_UV_4() { return &___m_UV_4; }
inline void set_m_UV_4(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___m_UV_4 = value;
}
inline static int32_t get_offset_of_m_Collider_5() { return static_cast<int32_t>(offsetof(RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3, ___m_Collider_5)); }
inline int32_t get_m_Collider_5() const { return ___m_Collider_5; }
inline int32_t* get_address_of_m_Collider_5() { return &___m_Collider_5; }
inline void set_m_Collider_5(int32_t value)
{
___m_Collider_5 = value;
}
};
// UnityEngine.RaycastHit2D
struct RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE
{
public:
// UnityEngine.Vector2 UnityEngine.RaycastHit2D::m_Centroid
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___m_Centroid_0;
// UnityEngine.Vector2 UnityEngine.RaycastHit2D::m_Point
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___m_Point_1;
// UnityEngine.Vector2 UnityEngine.RaycastHit2D::m_Normal
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___m_Normal_2;
// System.Single UnityEngine.RaycastHit2D::m_Distance
float ___m_Distance_3;
// System.Single UnityEngine.RaycastHit2D::m_Fraction
float ___m_Fraction_4;
// System.Int32 UnityEngine.RaycastHit2D::m_Collider
int32_t ___m_Collider_5;
public:
inline static int32_t get_offset_of_m_Centroid_0() { return static_cast<int32_t>(offsetof(RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE, ___m_Centroid_0)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_m_Centroid_0() const { return ___m_Centroid_0; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_m_Centroid_0() { return &___m_Centroid_0; }
inline void set_m_Centroid_0(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___m_Centroid_0 = value;
}
inline static int32_t get_offset_of_m_Point_1() { return static_cast<int32_t>(offsetof(RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE, ___m_Point_1)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_m_Point_1() const { return ___m_Point_1; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_m_Point_1() { return &___m_Point_1; }
inline void set_m_Point_1(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___m_Point_1 = value;
}
inline static int32_t get_offset_of_m_Normal_2() { return static_cast<int32_t>(offsetof(RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE, ___m_Normal_2)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_m_Normal_2() const { return ___m_Normal_2; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_m_Normal_2() { return &___m_Normal_2; }
inline void set_m_Normal_2(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___m_Normal_2 = value;
}
inline static int32_t get_offset_of_m_Distance_3() { return static_cast<int32_t>(offsetof(RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE, ___m_Distance_3)); }
inline float get_m_Distance_3() const { return ___m_Distance_3; }
inline float* get_address_of_m_Distance_3() { return &___m_Distance_3; }
inline void set_m_Distance_3(float value)
{
___m_Distance_3 = value;
}
inline static int32_t get_offset_of_m_Fraction_4() { return static_cast<int32_t>(offsetof(RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE, ___m_Fraction_4)); }
inline float get_m_Fraction_4() const { return ___m_Fraction_4; }
inline float* get_address_of_m_Fraction_4() { return &___m_Fraction_4; }
inline void set_m_Fraction_4(float value)
{
___m_Fraction_4 = value;
}
inline static int32_t get_offset_of_m_Collider_5() { return static_cast<int32_t>(offsetof(RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE, ___m_Collider_5)); }
inline int32_t get_m_Collider_5() const { return ___m_Collider_5; }
inline int32_t* get_address_of_m_Collider_5() { return &___m_Collider_5; }
inline void set_m_Collider_5(int32_t value)
{
___m_Collider_5 = value;
}
};
// UnityEngine.TextureFormat
struct TextureFormat_t7C6B5101554065C47682E592D1E26079D4EC2DCE
{
public:
// System.Int32 UnityEngine.TextureFormat::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(TextureFormat_t7C6B5101554065C47682E592D1E26079D4EC2DCE, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.UI.ColorBlock
struct ColorBlock_t93B54DF6E8D65D24CEA9726CA745E48C53E3B1EA
{
public:
// UnityEngine.Color UnityEngine.UI.ColorBlock::m_NormalColor
Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 ___m_NormalColor_0;
// UnityEngine.Color UnityEngine.UI.ColorBlock::m_HighlightedColor
Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 ___m_HighlightedColor_1;
// UnityEngine.Color UnityEngine.UI.ColorBlock::m_PressedColor
Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 ___m_PressedColor_2;
// UnityEngine.Color UnityEngine.UI.ColorBlock::m_SelectedColor
Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 ___m_SelectedColor_3;
// UnityEngine.Color UnityEngine.UI.ColorBlock::m_DisabledColor
Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 ___m_DisabledColor_4;
// System.Single UnityEngine.UI.ColorBlock::m_ColorMultiplier
float ___m_ColorMultiplier_5;
// System.Single UnityEngine.UI.ColorBlock::m_FadeDuration
float ___m_FadeDuration_6;
public:
inline static int32_t get_offset_of_m_NormalColor_0() { return static_cast<int32_t>(offsetof(ColorBlock_t93B54DF6E8D65D24CEA9726CA745E48C53E3B1EA, ___m_NormalColor_0)); }
inline Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 get_m_NormalColor_0() const { return ___m_NormalColor_0; }
inline Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 * get_address_of_m_NormalColor_0() { return &___m_NormalColor_0; }
inline void set_m_NormalColor_0(Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 value)
{
___m_NormalColor_0 = value;
}
inline static int32_t get_offset_of_m_HighlightedColor_1() { return static_cast<int32_t>(offsetof(ColorBlock_t93B54DF6E8D65D24CEA9726CA745E48C53E3B1EA, ___m_HighlightedColor_1)); }
inline Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 get_m_HighlightedColor_1() const { return ___m_HighlightedColor_1; }
inline Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 * get_address_of_m_HighlightedColor_1() { return &___m_HighlightedColor_1; }
inline void set_m_HighlightedColor_1(Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 value)
{
___m_HighlightedColor_1 = value;
}
inline static int32_t get_offset_of_m_PressedColor_2() { return static_cast<int32_t>(offsetof(ColorBlock_t93B54DF6E8D65D24CEA9726CA745E48C53E3B1EA, ___m_PressedColor_2)); }
inline Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 get_m_PressedColor_2() const { return ___m_PressedColor_2; }
inline Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 * get_address_of_m_PressedColor_2() { return &___m_PressedColor_2; }
inline void set_m_PressedColor_2(Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 value)
{
___m_PressedColor_2 = value;
}
inline static int32_t get_offset_of_m_SelectedColor_3() { return static_cast<int32_t>(offsetof(ColorBlock_t93B54DF6E8D65D24CEA9726CA745E48C53E3B1EA, ___m_SelectedColor_3)); }
inline Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 get_m_SelectedColor_3() const { return ___m_SelectedColor_3; }
inline Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 * get_address_of_m_SelectedColor_3() { return &___m_SelectedColor_3; }
inline void set_m_SelectedColor_3(Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 value)
{
___m_SelectedColor_3 = value;
}
inline static int32_t get_offset_of_m_DisabledColor_4() { return static_cast<int32_t>(offsetof(ColorBlock_t93B54DF6E8D65D24CEA9726CA745E48C53E3B1EA, ___m_DisabledColor_4)); }
inline Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 get_m_DisabledColor_4() const { return ___m_DisabledColor_4; }
inline Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 * get_address_of_m_DisabledColor_4() { return &___m_DisabledColor_4; }
inline void set_m_DisabledColor_4(Color_t119BCA590009762C7223FDD3AF9706653AC84ED2 value)
{
___m_DisabledColor_4 = value;
}
inline static int32_t get_offset_of_m_ColorMultiplier_5() { return static_cast<int32_t>(offsetof(ColorBlock_t93B54DF6E8D65D24CEA9726CA745E48C53E3B1EA, ___m_ColorMultiplier_5)); }
inline float get_m_ColorMultiplier_5() const { return ___m_ColorMultiplier_5; }
inline float* get_address_of_m_ColorMultiplier_5() { return &___m_ColorMultiplier_5; }
inline void set_m_ColorMultiplier_5(float value)
{
___m_ColorMultiplier_5 = value;
}
inline static int32_t get_offset_of_m_FadeDuration_6() { return static_cast<int32_t>(offsetof(ColorBlock_t93B54DF6E8D65D24CEA9726CA745E48C53E3B1EA, ___m_FadeDuration_6)); }
inline float get_m_FadeDuration_6() const { return ___m_FadeDuration_6; }
inline float* get_address_of_m_FadeDuration_6() { return &___m_FadeDuration_6; }
inline void set_m_FadeDuration_6(float value)
{
___m_FadeDuration_6 = value;
}
};
// UnityEngine.UI.Navigation_Mode
struct Mode_t93F92BD50B147AE38D82BA33FA77FD247A59FE26
{
public:
// System.Int32 UnityEngine.UI.Navigation_Mode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(Mode_t93F92BD50B147AE38D82BA33FA77FD247A59FE26, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// UnityEngine.UICharInfo
struct UICharInfo_tB4C92043A686A600D36A92E3108F173C499E318A
{
public:
// UnityEngine.Vector2 UnityEngine.UICharInfo::cursorPos
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___cursorPos_0;
// System.Single UnityEngine.UICharInfo::charWidth
float ___charWidth_1;
public:
inline static int32_t get_offset_of_cursorPos_0() { return static_cast<int32_t>(offsetof(UICharInfo_tB4C92043A686A600D36A92E3108F173C499E318A, ___cursorPos_0)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_cursorPos_0() const { return ___cursorPos_0; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_cursorPos_0() { return &___cursorPos_0; }
inline void set_cursorPos_0(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___cursorPos_0 = value;
}
inline static int32_t get_offset_of_charWidth_1() { return static_cast<int32_t>(offsetof(UICharInfo_tB4C92043A686A600D36A92E3108F173C499E318A, ___charWidth_1)); }
inline float get_charWidth_1() const { return ___charWidth_1; }
inline float* get_address_of_charWidth_1() { return &___charWidth_1; }
inline void set_charWidth_1(float value)
{
___charWidth_1 = value;
}
};
// UnityEngine.UIVertex
struct UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577
{
public:
// UnityEngine.Vector3 UnityEngine.UIVertex::position
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___position_0;
// UnityEngine.Vector3 UnityEngine.UIVertex::normal
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___normal_1;
// UnityEngine.Vector4 UnityEngine.UIVertex::tangent
Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E ___tangent_2;
// UnityEngine.Color32 UnityEngine.UIVertex::color
Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 ___color_3;
// UnityEngine.Vector2 UnityEngine.UIVertex::uv0
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___uv0_4;
// UnityEngine.Vector2 UnityEngine.UIVertex::uv1
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___uv1_5;
// UnityEngine.Vector2 UnityEngine.UIVertex::uv2
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___uv2_6;
// UnityEngine.Vector2 UnityEngine.UIVertex::uv3
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D ___uv3_7;
public:
inline static int32_t get_offset_of_position_0() { return static_cast<int32_t>(offsetof(UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577, ___position_0)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_position_0() const { return ___position_0; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_position_0() { return &___position_0; }
inline void set_position_0(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___position_0 = value;
}
inline static int32_t get_offset_of_normal_1() { return static_cast<int32_t>(offsetof(UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577, ___normal_1)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_normal_1() const { return ___normal_1; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_normal_1() { return &___normal_1; }
inline void set_normal_1(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___normal_1 = value;
}
inline static int32_t get_offset_of_tangent_2() { return static_cast<int32_t>(offsetof(UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577, ___tangent_2)); }
inline Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E get_tangent_2() const { return ___tangent_2; }
inline Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E * get_address_of_tangent_2() { return &___tangent_2; }
inline void set_tangent_2(Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E value)
{
___tangent_2 = value;
}
inline static int32_t get_offset_of_color_3() { return static_cast<int32_t>(offsetof(UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577, ___color_3)); }
inline Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 get_color_3() const { return ___color_3; }
inline Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 * get_address_of_color_3() { return &___color_3; }
inline void set_color_3(Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 value)
{
___color_3 = value;
}
inline static int32_t get_offset_of_uv0_4() { return static_cast<int32_t>(offsetof(UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577, ___uv0_4)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_uv0_4() const { return ___uv0_4; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_uv0_4() { return &___uv0_4; }
inline void set_uv0_4(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___uv0_4 = value;
}
inline static int32_t get_offset_of_uv1_5() { return static_cast<int32_t>(offsetof(UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577, ___uv1_5)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_uv1_5() const { return ___uv1_5; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_uv1_5() { return &___uv1_5; }
inline void set_uv1_5(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___uv1_5 = value;
}
inline static int32_t get_offset_of_uv2_6() { return static_cast<int32_t>(offsetof(UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577, ___uv2_6)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_uv2_6() const { return ___uv2_6; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_uv2_6() { return &___uv2_6; }
inline void set_uv2_6(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___uv2_6 = value;
}
inline static int32_t get_offset_of_uv3_7() { return static_cast<int32_t>(offsetof(UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577, ___uv3_7)); }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D get_uv3_7() const { return ___uv3_7; }
inline Vector2_tA85D2DD88578276CA8A8796756458277E72D073D * get_address_of_uv3_7() { return &___uv3_7; }
inline void set_uv3_7(Vector2_tA85D2DD88578276CA8A8796756458277E72D073D value)
{
___uv3_7 = value;
}
};
struct UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577_StaticFields
{
public:
// UnityEngine.Color32 UnityEngine.UIVertex::s_DefaultColor
Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 ___s_DefaultColor_8;
// UnityEngine.Vector4 UnityEngine.UIVertex::s_DefaultTangent
Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E ___s_DefaultTangent_9;
// UnityEngine.UIVertex UnityEngine.UIVertex::simpleVert
UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577 ___simpleVert_10;
public:
inline static int32_t get_offset_of_s_DefaultColor_8() { return static_cast<int32_t>(offsetof(UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577_StaticFields, ___s_DefaultColor_8)); }
inline Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 get_s_DefaultColor_8() const { return ___s_DefaultColor_8; }
inline Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 * get_address_of_s_DefaultColor_8() { return &___s_DefaultColor_8; }
inline void set_s_DefaultColor_8(Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 value)
{
___s_DefaultColor_8 = value;
}
inline static int32_t get_offset_of_s_DefaultTangent_9() { return static_cast<int32_t>(offsetof(UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577_StaticFields, ___s_DefaultTangent_9)); }
inline Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E get_s_DefaultTangent_9() const { return ___s_DefaultTangent_9; }
inline Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E * get_address_of_s_DefaultTangent_9() { return &___s_DefaultTangent_9; }
inline void set_s_DefaultTangent_9(Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E value)
{
___s_DefaultTangent_9 = value;
}
inline static int32_t get_offset_of_simpleVert_10() { return static_cast<int32_t>(offsetof(UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577_StaticFields, ___simpleVert_10)); }
inline UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577 get_simpleVert_10() const { return ___simpleVert_10; }
inline UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577 * get_address_of_simpleVert_10() { return &___simpleVert_10; }
inline void set_simpleVert_10(UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577 value)
{
___simpleVert_10 = value;
}
};
// System.Diagnostics.Tracing.EventSource_EventMetadata
struct EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B
{
public:
// System.Diagnostics.Tracing.EventDescriptor System.Diagnostics.Tracing.EventSource_EventMetadata::Descriptor
EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E ___Descriptor_0;
// System.Diagnostics.Tracing.EventTags System.Diagnostics.Tracing.EventSource_EventMetadata::Tags
int32_t ___Tags_1;
// System.Boolean System.Diagnostics.Tracing.EventSource_EventMetadata::EnabledForAnyListener
bool ___EnabledForAnyListener_2;
// System.Boolean System.Diagnostics.Tracing.EventSource_EventMetadata::EnabledForETW
bool ___EnabledForETW_3;
// System.Boolean System.Diagnostics.Tracing.EventSource_EventMetadata::HasRelatedActivityID
bool ___HasRelatedActivityID_4;
// System.Byte System.Diagnostics.Tracing.EventSource_EventMetadata::TriggersActivityTracking
uint8_t ___TriggersActivityTracking_5;
// System.String System.Diagnostics.Tracing.EventSource_EventMetadata::Name
String_t* ___Name_6;
// System.String System.Diagnostics.Tracing.EventSource_EventMetadata::Message
String_t* ___Message_7;
// System.Reflection.ParameterInfo[] System.Diagnostics.Tracing.EventSource_EventMetadata::Parameters
ParameterInfoU5BU5D_t9F6F38E4A0B0A78E2F463D1B2C0031716CA7A694* ___Parameters_8;
// System.Diagnostics.Tracing.TraceLoggingEventTypes System.Diagnostics.Tracing.EventSource_EventMetadata::TraceLoggingEventTypes
TraceLoggingEventTypes_t9CC0B45F554DBE11BA54227A704E1AC027E5DD25 * ___TraceLoggingEventTypes_9;
// System.Diagnostics.Tracing.EventActivityOptions System.Diagnostics.Tracing.EventSource_EventMetadata::ActivityOptions
int32_t ___ActivityOptions_10;
public:
inline static int32_t get_offset_of_Descriptor_0() { return static_cast<int32_t>(offsetof(EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B, ___Descriptor_0)); }
inline EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E get_Descriptor_0() const { return ___Descriptor_0; }
inline EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E * get_address_of_Descriptor_0() { return &___Descriptor_0; }
inline void set_Descriptor_0(EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E value)
{
___Descriptor_0 = value;
}
inline static int32_t get_offset_of_Tags_1() { return static_cast<int32_t>(offsetof(EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B, ___Tags_1)); }
inline int32_t get_Tags_1() const { return ___Tags_1; }
inline int32_t* get_address_of_Tags_1() { return &___Tags_1; }
inline void set_Tags_1(int32_t value)
{
___Tags_1 = value;
}
inline static int32_t get_offset_of_EnabledForAnyListener_2() { return static_cast<int32_t>(offsetof(EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B, ___EnabledForAnyListener_2)); }
inline bool get_EnabledForAnyListener_2() const { return ___EnabledForAnyListener_2; }
inline bool* get_address_of_EnabledForAnyListener_2() { return &___EnabledForAnyListener_2; }
inline void set_EnabledForAnyListener_2(bool value)
{
___EnabledForAnyListener_2 = value;
}
inline static int32_t get_offset_of_EnabledForETW_3() { return static_cast<int32_t>(offsetof(EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B, ___EnabledForETW_3)); }
inline bool get_EnabledForETW_3() const { return ___EnabledForETW_3; }
inline bool* get_address_of_EnabledForETW_3() { return &___EnabledForETW_3; }
inline void set_EnabledForETW_3(bool value)
{
___EnabledForETW_3 = value;
}
inline static int32_t get_offset_of_HasRelatedActivityID_4() { return static_cast<int32_t>(offsetof(EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B, ___HasRelatedActivityID_4)); }
inline bool get_HasRelatedActivityID_4() const { return ___HasRelatedActivityID_4; }
inline bool* get_address_of_HasRelatedActivityID_4() { return &___HasRelatedActivityID_4; }
inline void set_HasRelatedActivityID_4(bool value)
{
___HasRelatedActivityID_4 = value;
}
inline static int32_t get_offset_of_TriggersActivityTracking_5() { return static_cast<int32_t>(offsetof(EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B, ___TriggersActivityTracking_5)); }
inline uint8_t get_TriggersActivityTracking_5() const { return ___TriggersActivityTracking_5; }
inline uint8_t* get_address_of_TriggersActivityTracking_5() { return &___TriggersActivityTracking_5; }
inline void set_TriggersActivityTracking_5(uint8_t value)
{
___TriggersActivityTracking_5 = value;
}
inline static int32_t get_offset_of_Name_6() { return static_cast<int32_t>(offsetof(EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B, ___Name_6)); }
inline String_t* get_Name_6() const { return ___Name_6; }
inline String_t** get_address_of_Name_6() { return &___Name_6; }
inline void set_Name_6(String_t* value)
{
___Name_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Name_6), (void*)value);
}
inline static int32_t get_offset_of_Message_7() { return static_cast<int32_t>(offsetof(EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B, ___Message_7)); }
inline String_t* get_Message_7() const { return ___Message_7; }
inline String_t** get_address_of_Message_7() { return &___Message_7; }
inline void set_Message_7(String_t* value)
{
___Message_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Message_7), (void*)value);
}
inline static int32_t get_offset_of_Parameters_8() { return static_cast<int32_t>(offsetof(EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B, ___Parameters_8)); }
inline ParameterInfoU5BU5D_t9F6F38E4A0B0A78E2F463D1B2C0031716CA7A694* get_Parameters_8() const { return ___Parameters_8; }
inline ParameterInfoU5BU5D_t9F6F38E4A0B0A78E2F463D1B2C0031716CA7A694** get_address_of_Parameters_8() { return &___Parameters_8; }
inline void set_Parameters_8(ParameterInfoU5BU5D_t9F6F38E4A0B0A78E2F463D1B2C0031716CA7A694* value)
{
___Parameters_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Parameters_8), (void*)value);
}
inline static int32_t get_offset_of_TraceLoggingEventTypes_9() { return static_cast<int32_t>(offsetof(EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B, ___TraceLoggingEventTypes_9)); }
inline TraceLoggingEventTypes_t9CC0B45F554DBE11BA54227A704E1AC027E5DD25 * get_TraceLoggingEventTypes_9() const { return ___TraceLoggingEventTypes_9; }
inline TraceLoggingEventTypes_t9CC0B45F554DBE11BA54227A704E1AC027E5DD25 ** get_address_of_TraceLoggingEventTypes_9() { return &___TraceLoggingEventTypes_9; }
inline void set_TraceLoggingEventTypes_9(TraceLoggingEventTypes_t9CC0B45F554DBE11BA54227A704E1AC027E5DD25 * value)
{
___TraceLoggingEventTypes_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___TraceLoggingEventTypes_9), (void*)value);
}
inline static int32_t get_offset_of_ActivityOptions_10() { return static_cast<int32_t>(offsetof(EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B, ___ActivityOptions_10)); }
inline int32_t get_ActivityOptions_10() const { return ___ActivityOptions_10; }
inline int32_t* get_address_of_ActivityOptions_10() { return &___ActivityOptions_10; }
inline void set_ActivityOptions_10(int32_t value)
{
___ActivityOptions_10 = value;
}
};
// Native definition for P/Invoke marshalling of System.Diagnostics.Tracing.EventSource/EventMetadata
struct EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B_marshaled_pinvoke
{
EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E ___Descriptor_0;
int32_t ___Tags_1;
int32_t ___EnabledForAnyListener_2;
int32_t ___EnabledForETW_3;
int32_t ___HasRelatedActivityID_4;
uint8_t ___TriggersActivityTracking_5;
char* ___Name_6;
char* ___Message_7;
ParameterInfo_t37AB8D79D44E14C48CDA9004CB696E240C3FD4DB_marshaled_pinvoke** ___Parameters_8;
TraceLoggingEventTypes_t9CC0B45F554DBE11BA54227A704E1AC027E5DD25 * ___TraceLoggingEventTypes_9;
int32_t ___ActivityOptions_10;
};
// Native definition for COM marshalling of System.Diagnostics.Tracing.EventSource/EventMetadata
struct EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B_marshaled_com
{
EventDescriptor_t0DB21DFB13157AE81D79A01C853DF3729072B38E ___Descriptor_0;
int32_t ___Tags_1;
int32_t ___EnabledForAnyListener_2;
int32_t ___EnabledForETW_3;
int32_t ___HasRelatedActivityID_4;
uint8_t ___TriggersActivityTracking_5;
Il2CppChar* ___Name_6;
Il2CppChar* ___Message_7;
ParameterInfo_t37AB8D79D44E14C48CDA9004CB696E240C3FD4DB_marshaled_com** ___Parameters_8;
TraceLoggingEventTypes_t9CC0B45F554DBE11BA54227A704E1AC027E5DD25 * ___TraceLoggingEventTypes_9;
int32_t ___ActivityOptions_10;
};
// System.MulticastDelegate
struct MulticastDelegate_t : public Delegate_t
{
public:
// System.Delegate[] System.MulticastDelegate::delegates
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* ___delegates_11;
public:
inline static int32_t get_offset_of_delegates_11() { return static_cast<int32_t>(offsetof(MulticastDelegate_t, ___delegates_11)); }
inline DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* get_delegates_11() const { return ___delegates_11; }
inline DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86** get_address_of_delegates_11() { return &___delegates_11; }
inline void set_delegates_11(DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* value)
{
___delegates_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___delegates_11), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.MulticastDelegate
struct MulticastDelegate_t_marshaled_pinvoke : public Delegate_t_marshaled_pinvoke
{
Delegate_t_marshaled_pinvoke** ___delegates_11;
};
// Native definition for COM marshalling of System.MulticastDelegate
struct MulticastDelegate_t_marshaled_com : public Delegate_t_marshaled_com
{
Delegate_t_marshaled_com** ___delegates_11;
};
// System.SystemException
struct SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782 : public Exception_t
{
public:
public:
};
// Unity.Collections.NativeArray`1<System.Byte>
struct NativeArray_1_tB942A78CFAC276F95E8B08EBB94DF670FFAA0405
{
public:
// System.Void* Unity.Collections.NativeArray`1::m_Buffer
void* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeArray`1::m_Length
int32_t ___m_Length_1;
// Unity.Collections.Allocator Unity.Collections.NativeArray`1::m_AllocatorLabel
int32_t ___m_AllocatorLabel_2;
public:
inline static int32_t get_offset_of_m_Buffer_0() { return static_cast<int32_t>(offsetof(NativeArray_1_tB942A78CFAC276F95E8B08EBB94DF670FFAA0405, ___m_Buffer_0)); }
inline void* get_m_Buffer_0() const { return ___m_Buffer_0; }
inline void** get_address_of_m_Buffer_0() { return &___m_Buffer_0; }
inline void set_m_Buffer_0(void* value)
{
___m_Buffer_0 = value;
}
inline static int32_t get_offset_of_m_Length_1() { return static_cast<int32_t>(offsetof(NativeArray_1_tB942A78CFAC276F95E8B08EBB94DF670FFAA0405, ___m_Length_1)); }
inline int32_t get_m_Length_1() const { return ___m_Length_1; }
inline int32_t* get_address_of_m_Length_1() { return &___m_Length_1; }
inline void set_m_Length_1(int32_t value)
{
___m_Length_1 = value;
}
inline static int32_t get_offset_of_m_AllocatorLabel_2() { return static_cast<int32_t>(offsetof(NativeArray_1_tB942A78CFAC276F95E8B08EBB94DF670FFAA0405, ___m_AllocatorLabel_2)); }
inline int32_t get_m_AllocatorLabel_2() const { return ___m_AllocatorLabel_2; }
inline int32_t* get_address_of_m_AllocatorLabel_2() { return &___m_AllocatorLabel_2; }
inline void set_m_AllocatorLabel_2(int32_t value)
{
___m_AllocatorLabel_2 = value;
}
};
// Native definition for P/Invoke marshalling of Unity.Collections.NativeArray`1
#ifndef NativeArray_1_t350F3793D2FE9D9CD5A50725BE978ED846FE3098_marshaled_pinvoke_define
#define NativeArray_1_t350F3793D2FE9D9CD5A50725BE978ED846FE3098_marshaled_pinvoke_define
struct NativeArray_1_t350F3793D2FE9D9CD5A50725BE978ED846FE3098_marshaled_pinvoke
{
void* ___m_Buffer_0;
int32_t ___m_Length_1;
int32_t ___m_AllocatorLabel_2;
};
#endif
// Native definition for COM marshalling of Unity.Collections.NativeArray`1
#ifndef NativeArray_1_t350F3793D2FE9D9CD5A50725BE978ED846FE3098_marshaled_com_define
#define NativeArray_1_t350F3793D2FE9D9CD5A50725BE978ED846FE3098_marshaled_com_define
struct NativeArray_1_t350F3793D2FE9D9CD5A50725BE978ED846FE3098_marshaled_com
{
void* ___m_Buffer_0;
int32_t ___m_Length_1;
int32_t ___m_AllocatorLabel_2;
};
#endif
// UnityEngine.Experimental.GlobalIllumination.LightDataGI
struct LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2
{
public:
// System.Int32 UnityEngine.Experimental.GlobalIllumination.LightDataGI::instanceID
int32_t ___instanceID_0;
// UnityEngine.Experimental.GlobalIllumination.LinearColor UnityEngine.Experimental.GlobalIllumination.LightDataGI::color
LinearColor_tB8D05FA20CBA5254EA4D27D2B47D7B067FE506CD ___color_1;
// UnityEngine.Experimental.GlobalIllumination.LinearColor UnityEngine.Experimental.GlobalIllumination.LightDataGI::indirectColor
LinearColor_tB8D05FA20CBA5254EA4D27D2B47D7B067FE506CD ___indirectColor_2;
// UnityEngine.Quaternion UnityEngine.Experimental.GlobalIllumination.LightDataGI::orientation
Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357 ___orientation_3;
// UnityEngine.Vector3 UnityEngine.Experimental.GlobalIllumination.LightDataGI::position
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 ___position_4;
// System.Single UnityEngine.Experimental.GlobalIllumination.LightDataGI::range
float ___range_5;
// System.Single UnityEngine.Experimental.GlobalIllumination.LightDataGI::coneAngle
float ___coneAngle_6;
// System.Single UnityEngine.Experimental.GlobalIllumination.LightDataGI::innerConeAngle
float ___innerConeAngle_7;
// System.Single UnityEngine.Experimental.GlobalIllumination.LightDataGI::shape0
float ___shape0_8;
// System.Single UnityEngine.Experimental.GlobalIllumination.LightDataGI::shape1
float ___shape1_9;
// UnityEngine.Experimental.GlobalIllumination.LightType UnityEngine.Experimental.GlobalIllumination.LightDataGI::type
uint8_t ___type_10;
// UnityEngine.Experimental.GlobalIllumination.LightMode UnityEngine.Experimental.GlobalIllumination.LightDataGI::mode
uint8_t ___mode_11;
// System.Byte UnityEngine.Experimental.GlobalIllumination.LightDataGI::shadow
uint8_t ___shadow_12;
// UnityEngine.Experimental.GlobalIllumination.FalloffType UnityEngine.Experimental.GlobalIllumination.LightDataGI::falloff
uint8_t ___falloff_13;
public:
inline static int32_t get_offset_of_instanceID_0() { return static_cast<int32_t>(offsetof(LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2, ___instanceID_0)); }
inline int32_t get_instanceID_0() const { return ___instanceID_0; }
inline int32_t* get_address_of_instanceID_0() { return &___instanceID_0; }
inline void set_instanceID_0(int32_t value)
{
___instanceID_0 = value;
}
inline static int32_t get_offset_of_color_1() { return static_cast<int32_t>(offsetof(LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2, ___color_1)); }
inline LinearColor_tB8D05FA20CBA5254EA4D27D2B47D7B067FE506CD get_color_1() const { return ___color_1; }
inline LinearColor_tB8D05FA20CBA5254EA4D27D2B47D7B067FE506CD * get_address_of_color_1() { return &___color_1; }
inline void set_color_1(LinearColor_tB8D05FA20CBA5254EA4D27D2B47D7B067FE506CD value)
{
___color_1 = value;
}
inline static int32_t get_offset_of_indirectColor_2() { return static_cast<int32_t>(offsetof(LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2, ___indirectColor_2)); }
inline LinearColor_tB8D05FA20CBA5254EA4D27D2B47D7B067FE506CD get_indirectColor_2() const { return ___indirectColor_2; }
inline LinearColor_tB8D05FA20CBA5254EA4D27D2B47D7B067FE506CD * get_address_of_indirectColor_2() { return &___indirectColor_2; }
inline void set_indirectColor_2(LinearColor_tB8D05FA20CBA5254EA4D27D2B47D7B067FE506CD value)
{
___indirectColor_2 = value;
}
inline static int32_t get_offset_of_orientation_3() { return static_cast<int32_t>(offsetof(LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2, ___orientation_3)); }
inline Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357 get_orientation_3() const { return ___orientation_3; }
inline Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357 * get_address_of_orientation_3() { return &___orientation_3; }
inline void set_orientation_3(Quaternion_t319F3319A7D43FFA5D819AD6C0A98851F0095357 value)
{
___orientation_3 = value;
}
inline static int32_t get_offset_of_position_4() { return static_cast<int32_t>(offsetof(LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2, ___position_4)); }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 get_position_4() const { return ___position_4; }
inline Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 * get_address_of_position_4() { return &___position_4; }
inline void set_position_4(Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 value)
{
___position_4 = value;
}
inline static int32_t get_offset_of_range_5() { return static_cast<int32_t>(offsetof(LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2, ___range_5)); }
inline float get_range_5() const { return ___range_5; }
inline float* get_address_of_range_5() { return &___range_5; }
inline void set_range_5(float value)
{
___range_5 = value;
}
inline static int32_t get_offset_of_coneAngle_6() { return static_cast<int32_t>(offsetof(LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2, ___coneAngle_6)); }
inline float get_coneAngle_6() const { return ___coneAngle_6; }
inline float* get_address_of_coneAngle_6() { return &___coneAngle_6; }
inline void set_coneAngle_6(float value)
{
___coneAngle_6 = value;
}
inline static int32_t get_offset_of_innerConeAngle_7() { return static_cast<int32_t>(offsetof(LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2, ___innerConeAngle_7)); }
inline float get_innerConeAngle_7() const { return ___innerConeAngle_7; }
inline float* get_address_of_innerConeAngle_7() { return &___innerConeAngle_7; }
inline void set_innerConeAngle_7(float value)
{
___innerConeAngle_7 = value;
}
inline static int32_t get_offset_of_shape0_8() { return static_cast<int32_t>(offsetof(LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2, ___shape0_8)); }
inline float get_shape0_8() const { return ___shape0_8; }
inline float* get_address_of_shape0_8() { return &___shape0_8; }
inline void set_shape0_8(float value)
{
___shape0_8 = value;
}
inline static int32_t get_offset_of_shape1_9() { return static_cast<int32_t>(offsetof(LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2, ___shape1_9)); }
inline float get_shape1_9() const { return ___shape1_9; }
inline float* get_address_of_shape1_9() { return &___shape1_9; }
inline void set_shape1_9(float value)
{
___shape1_9 = value;
}
inline static int32_t get_offset_of_type_10() { return static_cast<int32_t>(offsetof(LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2, ___type_10)); }
inline uint8_t get_type_10() const { return ___type_10; }
inline uint8_t* get_address_of_type_10() { return &___type_10; }
inline void set_type_10(uint8_t value)
{
___type_10 = value;
}
inline static int32_t get_offset_of_mode_11() { return static_cast<int32_t>(offsetof(LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2, ___mode_11)); }
inline uint8_t get_mode_11() const { return ___mode_11; }
inline uint8_t* get_address_of_mode_11() { return &___mode_11; }
inline void set_mode_11(uint8_t value)
{
___mode_11 = value;
}
inline static int32_t get_offset_of_shadow_12() { return static_cast<int32_t>(offsetof(LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2, ___shadow_12)); }
inline uint8_t get_shadow_12() const { return ___shadow_12; }
inline uint8_t* get_address_of_shadow_12() { return &___shadow_12; }
inline void set_shadow_12(uint8_t value)
{
___shadow_12 = value;
}
inline static int32_t get_offset_of_falloff_13() { return static_cast<int32_t>(offsetof(LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2, ___falloff_13)); }
inline uint8_t get_falloff_13() const { return ___falloff_13; }
inline uint8_t* get_address_of_falloff_13() { return &___falloff_13; }
inline void set_falloff_13(uint8_t value)
{
___falloff_13 = value;
}
};
// UnityEngine.Playables.PlayableBinding
struct PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8
{
public:
// System.String UnityEngine.Playables.PlayableBinding::m_StreamName
String_t* ___m_StreamName_0;
// UnityEngine.Object UnityEngine.Playables.PlayableBinding::m_SourceObject
Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0 * ___m_SourceObject_1;
// System.Type UnityEngine.Playables.PlayableBinding::m_SourceBindingType
Type_t * ___m_SourceBindingType_2;
// UnityEngine.Playables.PlayableBinding_CreateOutputMethod UnityEngine.Playables.PlayableBinding::m_CreateOutputMethod
CreateOutputMethod_tA7B649F49822FC5DD0B0D9F17247C73CAECB1CA3 * ___m_CreateOutputMethod_3;
public:
inline static int32_t get_offset_of_m_StreamName_0() { return static_cast<int32_t>(offsetof(PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8, ___m_StreamName_0)); }
inline String_t* get_m_StreamName_0() const { return ___m_StreamName_0; }
inline String_t** get_address_of_m_StreamName_0() { return &___m_StreamName_0; }
inline void set_m_StreamName_0(String_t* value)
{
___m_StreamName_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_StreamName_0), (void*)value);
}
inline static int32_t get_offset_of_m_SourceObject_1() { return static_cast<int32_t>(offsetof(PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8, ___m_SourceObject_1)); }
inline Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0 * get_m_SourceObject_1() const { return ___m_SourceObject_1; }
inline Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0 ** get_address_of_m_SourceObject_1() { return &___m_SourceObject_1; }
inline void set_m_SourceObject_1(Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0 * value)
{
___m_SourceObject_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_SourceObject_1), (void*)value);
}
inline static int32_t get_offset_of_m_SourceBindingType_2() { return static_cast<int32_t>(offsetof(PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8, ___m_SourceBindingType_2)); }
inline Type_t * get_m_SourceBindingType_2() const { return ___m_SourceBindingType_2; }
inline Type_t ** get_address_of_m_SourceBindingType_2() { return &___m_SourceBindingType_2; }
inline void set_m_SourceBindingType_2(Type_t * value)
{
___m_SourceBindingType_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_SourceBindingType_2), (void*)value);
}
inline static int32_t get_offset_of_m_CreateOutputMethod_3() { return static_cast<int32_t>(offsetof(PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8, ___m_CreateOutputMethod_3)); }
inline CreateOutputMethod_tA7B649F49822FC5DD0B0D9F17247C73CAECB1CA3 * get_m_CreateOutputMethod_3() const { return ___m_CreateOutputMethod_3; }
inline CreateOutputMethod_tA7B649F49822FC5DD0B0D9F17247C73CAECB1CA3 ** get_address_of_m_CreateOutputMethod_3() { return &___m_CreateOutputMethod_3; }
inline void set_m_CreateOutputMethod_3(CreateOutputMethod_tA7B649F49822FC5DD0B0D9F17247C73CAECB1CA3 * value)
{
___m_CreateOutputMethod_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_CreateOutputMethod_3), (void*)value);
}
};
struct PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8_StaticFields
{
public:
// UnityEngine.Playables.PlayableBinding[] UnityEngine.Playables.PlayableBinding::None
PlayableBindingU5BU5D_t7EB322901D51EAB67BA4F711C87F3AC1CF5D89AB* ___None_4;
// System.Double UnityEngine.Playables.PlayableBinding::DefaultDuration
double ___DefaultDuration_5;
public:
inline static int32_t get_offset_of_None_4() { return static_cast<int32_t>(offsetof(PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8_StaticFields, ___None_4)); }
inline PlayableBindingU5BU5D_t7EB322901D51EAB67BA4F711C87F3AC1CF5D89AB* get_None_4() const { return ___None_4; }
inline PlayableBindingU5BU5D_t7EB322901D51EAB67BA4F711C87F3AC1CF5D89AB** get_address_of_None_4() { return &___None_4; }
inline void set_None_4(PlayableBindingU5BU5D_t7EB322901D51EAB67BA4F711C87F3AC1CF5D89AB* value)
{
___None_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___None_4), (void*)value);
}
inline static int32_t get_offset_of_DefaultDuration_5() { return static_cast<int32_t>(offsetof(PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8_StaticFields, ___DefaultDuration_5)); }
inline double get_DefaultDuration_5() const { return ___DefaultDuration_5; }
inline double* get_address_of_DefaultDuration_5() { return &___DefaultDuration_5; }
inline void set_DefaultDuration_5(double value)
{
___DefaultDuration_5 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Playables.PlayableBinding
struct PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8_marshaled_pinvoke
{
char* ___m_StreamName_0;
Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_marshaled_pinvoke ___m_SourceObject_1;
Type_t * ___m_SourceBindingType_2;
Il2CppMethodPointer ___m_CreateOutputMethod_3;
};
// Native definition for COM marshalling of UnityEngine.Playables.PlayableBinding
struct PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8_marshaled_com
{
Il2CppChar* ___m_StreamName_0;
Object_tAE11E5E46CD5C37C9F3E8950C00CD8B45666A2D0_marshaled_com* ___m_SourceObject_1;
Type_t * ___m_SourceBindingType_2;
Il2CppMethodPointer ___m_CreateOutputMethod_3;
};
// UnityEngine.UI.Navigation
struct Navigation_t761250C05C09773B75F5E0D52DDCBBFE60288A07
{
public:
// UnityEngine.UI.Navigation_Mode UnityEngine.UI.Navigation::m_Mode
int32_t ___m_Mode_0;
// UnityEngine.UI.Selectable UnityEngine.UI.Navigation::m_SelectOnUp
Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * ___m_SelectOnUp_1;
// UnityEngine.UI.Selectable UnityEngine.UI.Navigation::m_SelectOnDown
Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * ___m_SelectOnDown_2;
// UnityEngine.UI.Selectable UnityEngine.UI.Navigation::m_SelectOnLeft
Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * ___m_SelectOnLeft_3;
// UnityEngine.UI.Selectable UnityEngine.UI.Navigation::m_SelectOnRight
Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * ___m_SelectOnRight_4;
public:
inline static int32_t get_offset_of_m_Mode_0() { return static_cast<int32_t>(offsetof(Navigation_t761250C05C09773B75F5E0D52DDCBBFE60288A07, ___m_Mode_0)); }
inline int32_t get_m_Mode_0() const { return ___m_Mode_0; }
inline int32_t* get_address_of_m_Mode_0() { return &___m_Mode_0; }
inline void set_m_Mode_0(int32_t value)
{
___m_Mode_0 = value;
}
inline static int32_t get_offset_of_m_SelectOnUp_1() { return static_cast<int32_t>(offsetof(Navigation_t761250C05C09773B75F5E0D52DDCBBFE60288A07, ___m_SelectOnUp_1)); }
inline Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * get_m_SelectOnUp_1() const { return ___m_SelectOnUp_1; }
inline Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A ** get_address_of_m_SelectOnUp_1() { return &___m_SelectOnUp_1; }
inline void set_m_SelectOnUp_1(Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * value)
{
___m_SelectOnUp_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_SelectOnUp_1), (void*)value);
}
inline static int32_t get_offset_of_m_SelectOnDown_2() { return static_cast<int32_t>(offsetof(Navigation_t761250C05C09773B75F5E0D52DDCBBFE60288A07, ___m_SelectOnDown_2)); }
inline Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * get_m_SelectOnDown_2() const { return ___m_SelectOnDown_2; }
inline Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A ** get_address_of_m_SelectOnDown_2() { return &___m_SelectOnDown_2; }
inline void set_m_SelectOnDown_2(Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * value)
{
___m_SelectOnDown_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_SelectOnDown_2), (void*)value);
}
inline static int32_t get_offset_of_m_SelectOnLeft_3() { return static_cast<int32_t>(offsetof(Navigation_t761250C05C09773B75F5E0D52DDCBBFE60288A07, ___m_SelectOnLeft_3)); }
inline Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * get_m_SelectOnLeft_3() const { return ___m_SelectOnLeft_3; }
inline Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A ** get_address_of_m_SelectOnLeft_3() { return &___m_SelectOnLeft_3; }
inline void set_m_SelectOnLeft_3(Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * value)
{
___m_SelectOnLeft_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_SelectOnLeft_3), (void*)value);
}
inline static int32_t get_offset_of_m_SelectOnRight_4() { return static_cast<int32_t>(offsetof(Navigation_t761250C05C09773B75F5E0D52DDCBBFE60288A07, ___m_SelectOnRight_4)); }
inline Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * get_m_SelectOnRight_4() const { return ___m_SelectOnRight_4; }
inline Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A ** get_address_of_m_SelectOnRight_4() { return &___m_SelectOnRight_4; }
inline void set_m_SelectOnRight_4(Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * value)
{
___m_SelectOnRight_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_SelectOnRight_4), (void*)value);
}
};
// Native definition for P/Invoke marshalling of UnityEngine.UI.Navigation
struct Navigation_t761250C05C09773B75F5E0D52DDCBBFE60288A07_marshaled_pinvoke
{
int32_t ___m_Mode_0;
Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * ___m_SelectOnUp_1;
Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * ___m_SelectOnDown_2;
Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * ___m_SelectOnLeft_3;
Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * ___m_SelectOnRight_4;
};
// Native definition for COM marshalling of UnityEngine.UI.Navigation
struct Navigation_t761250C05C09773B75F5E0D52DDCBBFE60288A07_marshaled_com
{
int32_t ___m_Mode_0;
Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * ___m_SelectOnUp_1;
Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * ___m_SelectOnDown_2;
Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * ___m_SelectOnLeft_3;
Selectable_tAA9065030FE0468018DEC880302F95FEA9C0133A * ___m_SelectOnRight_4;
};
// System.Action`1<System.Boolean>
struct Action_1_t6036B3C6D9E897E6266019A987CFC19CFC59CB64 : public MulticastDelegate_t
{
public:
public:
};
// System.Action`1<System.Guid>
struct Action_1_t914484DED737548EE8FABFA959036371C8235942 : public MulticastDelegate_t
{
public:
public:
};
// System.Action`1<System.Object>
struct Action_1_t551A279CEADCF6EEAE8FA2B1E1E757D0D15290D0 : public MulticastDelegate_t
{
public:
public:
};
// System.Action`1<System.Threading.AsyncLocalValueChangedArgs`1<System.Object>>
struct Action_1_tC9C78235CE090A8C814E2C458627F15C33AF0180 : public MulticastDelegate_t
{
public:
public:
};
// System.Action`2<System.Boolean,System.Object>
struct Action_2_t6C33D80670016FFA10F03F59FB542306FA60F1F3 : public MulticastDelegate_t
{
public:
public:
};
// System.Action`2<System.Char,System.Object>
struct Action_2_t2F784F6A8F0E6D7B6C7C73DCA17B1CCA8D724E48 : public MulticastDelegate_t
{
public:
public:
};
// System.Action`2<System.Int32,System.Int32>
struct Action_2_t5B6D9846A42CF1FAF7059138EA4A212815F00916 : public MulticastDelegate_t
{
public:
public:
};
// System.Action`2<System.Int32,System.Int64>
struct Action_2_tC52FA3FD223419FC0456E089309277012CCE38E8 : public MulticastDelegate_t
{
public:
public:
};
// System.Action`2<System.Object,System.Boolean>
struct Action_2_t429E4750D84EBAC7EB494EB565EE0C8E1177C576 : public MulticastDelegate_t
{
public:
public:
};
// System.Action`2<System.Object,System.Int32Enum>
struct Action_2_t4A92D51BAC0CF291CCBECDD41B622EDAE4E77D9F : public MulticastDelegate_t
{
public:
public:
};
// System.Action`2<System.Object,System.Object>
struct Action_2_t0DB6FD6F515527EAB552B690A291778C6F00D48C : public MulticastDelegate_t
{
public:
public:
};
// System.Action`3<System.Object,System.Object,System.Object>
struct Action_3_tCC14115B7178951118504E7198B7C872630643C5 : public MulticastDelegate_t
{
public:
public:
};
// System.AsyncCallback
struct AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 : public MulticastDelegate_t
{
public:
public:
};
// System.InvalidOperationException
struct InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
// UnityEngine.Profiling.Experimental.DebugScreenCapture
struct DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2
{
public:
// Unity.Collections.NativeArray`1<System.Byte> UnityEngine.Profiling.Experimental.DebugScreenCapture::<rawImageDataReference>k__BackingField
NativeArray_1_tB942A78CFAC276F95E8B08EBB94DF670FFAA0405 ___U3CrawImageDataReferenceU3Ek__BackingField_0;
// UnityEngine.TextureFormat UnityEngine.Profiling.Experimental.DebugScreenCapture::<imageFormat>k__BackingField
int32_t ___U3CimageFormatU3Ek__BackingField_1;
// System.Int32 UnityEngine.Profiling.Experimental.DebugScreenCapture::<width>k__BackingField
int32_t ___U3CwidthU3Ek__BackingField_2;
// System.Int32 UnityEngine.Profiling.Experimental.DebugScreenCapture::<height>k__BackingField
int32_t ___U3CheightU3Ek__BackingField_3;
public:
inline static int32_t get_offset_of_U3CrawImageDataReferenceU3Ek__BackingField_0() { return static_cast<int32_t>(offsetof(DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2, ___U3CrawImageDataReferenceU3Ek__BackingField_0)); }
inline NativeArray_1_tB942A78CFAC276F95E8B08EBB94DF670FFAA0405 get_U3CrawImageDataReferenceU3Ek__BackingField_0() const { return ___U3CrawImageDataReferenceU3Ek__BackingField_0; }
inline NativeArray_1_tB942A78CFAC276F95E8B08EBB94DF670FFAA0405 * get_address_of_U3CrawImageDataReferenceU3Ek__BackingField_0() { return &___U3CrawImageDataReferenceU3Ek__BackingField_0; }
inline void set_U3CrawImageDataReferenceU3Ek__BackingField_0(NativeArray_1_tB942A78CFAC276F95E8B08EBB94DF670FFAA0405 value)
{
___U3CrawImageDataReferenceU3Ek__BackingField_0 = value;
}
inline static int32_t get_offset_of_U3CimageFormatU3Ek__BackingField_1() { return static_cast<int32_t>(offsetof(DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2, ___U3CimageFormatU3Ek__BackingField_1)); }
inline int32_t get_U3CimageFormatU3Ek__BackingField_1() const { return ___U3CimageFormatU3Ek__BackingField_1; }
inline int32_t* get_address_of_U3CimageFormatU3Ek__BackingField_1() { return &___U3CimageFormatU3Ek__BackingField_1; }
inline void set_U3CimageFormatU3Ek__BackingField_1(int32_t value)
{
___U3CimageFormatU3Ek__BackingField_1 = value;
}
inline static int32_t get_offset_of_U3CwidthU3Ek__BackingField_2() { return static_cast<int32_t>(offsetof(DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2, ___U3CwidthU3Ek__BackingField_2)); }
inline int32_t get_U3CwidthU3Ek__BackingField_2() const { return ___U3CwidthU3Ek__BackingField_2; }
inline int32_t* get_address_of_U3CwidthU3Ek__BackingField_2() { return &___U3CwidthU3Ek__BackingField_2; }
inline void set_U3CwidthU3Ek__BackingField_2(int32_t value)
{
___U3CwidthU3Ek__BackingField_2 = value;
}
inline static int32_t get_offset_of_U3CheightU3Ek__BackingField_3() { return static_cast<int32_t>(offsetof(DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2, ___U3CheightU3Ek__BackingField_3)); }
inline int32_t get_U3CheightU3Ek__BackingField_3() const { return ___U3CheightU3Ek__BackingField_3; }
inline int32_t* get_address_of_U3CheightU3Ek__BackingField_3() { return &___U3CheightU3Ek__BackingField_3; }
inline void set_U3CheightU3Ek__BackingField_3(int32_t value)
{
___U3CheightU3Ek__BackingField_3 = value;
}
};
// Native definition for P/Invoke marshalling of UnityEngine.Profiling.Experimental.DebugScreenCapture
struct DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2_marshaled_pinvoke
{
NativeArray_1_tB942A78CFAC276F95E8B08EBB94DF670FFAA0405 ___U3CrawImageDataReferenceU3Ek__BackingField_0;
int32_t ___U3CimageFormatU3Ek__BackingField_1;
int32_t ___U3CwidthU3Ek__BackingField_2;
int32_t ___U3CheightU3Ek__BackingField_3;
};
// Native definition for COM marshalling of UnityEngine.Profiling.Experimental.DebugScreenCapture
struct DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2_marshaled_com
{
NativeArray_1_tB942A78CFAC276F95E8B08EBB94DF670FFAA0405 ___U3CrawImageDataReferenceU3Ek__BackingField_0;
int32_t ___U3CimageFormatU3Ek__BackingField_1;
int32_t ___U3CwidthU3Ek__BackingField_2;
int32_t ___U3CheightU3Ek__BackingField_3;
};
// System.Action`3<System.Object,System.Boolean,UnityEngine.Profiling.Experimental.DebugScreenCapture>
struct Action_3_t5EE4F8B9C50F576C16A8CE302D8F2790394C22EA : public MulticastDelegate_t
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// System.Object[]
struct ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A : public RuntimeArray
{
public:
ALIGN_FIELD (8) RuntimeObject * m_Items[1];
public:
inline RuntimeObject * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline RuntimeObject ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, RuntimeObject * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline RuntimeObject * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline RuntimeObject ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, RuntimeObject * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// System.Delegate[]
struct DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86 : public RuntimeArray
{
public:
ALIGN_FIELD (8) Delegate_t * m_Items[1];
public:
inline Delegate_t * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Delegate_t ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, Delegate_t * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline Delegate_t * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Delegate_t ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Delegate_t * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// System.Void System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mB435979A4FC207D777BBBEDCBE6DBD47F06FC2D3_gshared (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m9FFA4290ED807AF40BD2E60F26023529593AA5A0_gshared (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m19B8C2E6A68876BE54C2C35DD948B7C496D98546_gshared (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TableRange_t485CF0807771CC05023466CFCB0AE25C46648100 InternalEnumerator_1_get_Current_m5BF1362D0455A86D563CA0FE18879952C871ABC3_gshared (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC74FE1FCF522A51276B59B78AF8420D1E2F6AEA7_gshared (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD6A7480B222C2ED4423DFA000737E0286A78A130_gshared (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Boolean>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mC6576DE9DFD26D645933F33DDFFF5C193BD2C64F_gshared (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Boolean>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mAA797BBD83F736868FA6A8E186371BEADFC9A7CA_gshared (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Boolean>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m5D14BBDC6E172C9CFF85357EDA146D2F493191EC_gshared (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Boolean>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_get_Current_m0E37DD99400FD8E67350E2959B777C353662D4AE_gshared (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Boolean>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mBF9C54BE8A4A3C352F42280C1B76AD173905241D_gshared (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Boolean>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m406897CA7EC01C35D90402E4AA916647716FB767_gshared (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Byte>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mCE5D4D9E3057660C094936737BA70F2ADE3646F9_gshared (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Byte>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mC32656E5117A66CF11FF1BEA4C941AA4034677AC_gshared (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Byte>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mBA8D7A7C9CD1D0771BB9638FB7A0A4D17F5F7F72_gshared (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Byte>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t InternalEnumerator_1_get_Current_m8322D35634EA8F36F950C7FC88EA889817413E87_gshared (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Byte>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m52D68F77094EDDD9016386AF3F5A5B5781C974D9_gshared (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Byte>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m92570BB2C86AD0B6EB8845B78FF96396A458D6BE_gshared (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Char>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mA816E1C13D866A2558DA3C530799B1D3858F80EF_gshared (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Char>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mDCC22EFC517EA05A44E470F2DA1919EE5A58F9FA_gshared (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Char>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m3FAA847DFF670AFBF34878A1F45C9B29F5DD973C_gshared (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Char>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar InternalEnumerator_1_get_Current_mF9D5C23927E856F0D50CD0211DD96DED7A737466_gshared (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Char>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m51B86411AC68CD7F9618FF2523FB1199AA56372E_gshared (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Char>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mDEDC109FF80129362D85F9A7749B1540AFBD07B7_gshared (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mC0890A26F45EB3D0CE722AA211191F47A7D89CAE_gshared (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mC2FAA1D4D203A9339BBC1340D21F3ED010DDDBAC_gshared (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mCB1B8EAAF7F7CBAFAA5F7514553B6DC1038D4AC4_gshared (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4 InternalEnumerator_1_get_Current_mF60DB3DFAED76189D44BCCA186D595043C014D3E_gshared (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6CB9F8EC8CBE7FD4FADFAB7F64A37B7A7508D691_gshared (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD1EDD7B929F2A9A91509082AEC0A70709B12CEF8_gshared (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Int32,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m826AE3C40B8AFBE65F21024B99461A8E3435394E_gshared (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Int32,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m1CBAB604EC0F2F4558305325B30BC790A0684D54_gshared (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Int32,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m007FB57DED6F561D3EEC01BD59C68BFBD9FEA626_gshared (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Int32,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D InternalEnumerator_1_get_Current_m4ABCF333B87FC095F8DB1908EE7CB57702BBB20F_gshared (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Int32,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC24466541138E727EBE50B0E0A22F6651161EB71_gshared (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Int32,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9369158204F4280AA8C76BD2E47E8A91C9FDC053_gshared (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Int32>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m56019387E27A8E3481BDF2669CDE33C7899A4ECB_gshared (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Int32>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m1F2BED538F9A714FDD0663B4E12CEF6D82CD9459_gshared (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Int32>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m47F7361F7276ED03BEF7B9E04EC7431ACAAE6906_gshared (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Int32>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE InternalEnumerator_1_get_Current_m92BB9CC66A8467F196EA707E00E7186FA64AE48B_gshared (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Int32>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5D43D1F4D741863D821F9E78A4A608F58B2485DF_gshared (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Int32>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1E60E687D9B216101D35FA36C1D0EF48FF5C5F27_gshared (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m1593CE384E20D884D915D8C63DB0063790B3A618_gshared (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m4836500B7FEA20ACA83183ECBE1D467826FCE670_gshared (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m48BA3A9AC0BA051915D58DFCA32B1AA5C09DE957_gshared (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA InternalEnumerator_1_get_Current_mC2EC065F63466F7E6AD6C9AE9BC86A3B0CF0E07A_gshared (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m9C6C41648ADC7B60E8AF51190EEA7BAA8FA93241_gshared (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1536DF98255D34522AB9DC5D47835095718FF3DA_gshared (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Resources.ResourceLocator>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m41F1B4440445674E22696F369E1BE49F6B8B7325_gshared (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Resources.ResourceLocator>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mEEFF36A65ACDF8534CC4A049CF142B6757C1BC98_gshared (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Resources.ResourceLocator>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m1CCFAA43E5AEFCE61B8B581971072C0CE3D847C7_gshared (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Resources.ResourceLocator>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D InternalEnumerator_1_get_Current_m3B5BD0D9A3A2B90B762F783677926F8ED30B67C1_gshared (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m07F10BD620954A735C3091217347BBD9B523B1CB_gshared (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2A449599FC893C43B822B70233F3E79FD26F6959_gshared (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.UInt64,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m0BD0412D0302697F86E43B6F22BB445661F64C8F_gshared (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.UInt64,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m63B89FFEB305B542ABA20AD4FA3B515603DF2F56_gshared (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.UInt64,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m4462B2E5033D638D7F461862D3245ADC40CB5FFB_gshared (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.UInt64,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29 InternalEnumerator_1_get_Current_m902312010187A018147C6FDDC77113E4B125EC6C_gshared (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.UInt64,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mAB47E5373DD3C694D393ECB5B841B38C1A908386_gshared (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.UInt64,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCC02E335DAEB2C190189E5DA6C80C283CFF68D13_gshared (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.HashSet`1/Slot<System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m2047B6F070C9C5C4D9EF6147976F1ED4E28AF602_gshared (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.HashSet`1/Slot<System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m08900DA592D66440E18F7945EAD98B17C6C62404_gshared (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.HashSet`1/Slot<System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mB8FCAF454999038E9D103E26E7DE8D471D680DE9_gshared (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Generic.HashSet`1/Slot<System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279 InternalEnumerator_1_get_Current_m219A6F6D4C2AEE8F86D69E8CED72AB8566CECBFA_gshared (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.HashSet`1/Slot<System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m118A29F1EAB9A121242D65B79DCF0199A9640C5B_gshared (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.HashSet`1/Slot<System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2370D94B162CCB9AE9DE2667E298F002FBBDDEB7_gshared (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mEE2C570D5E7E5426D066B223014819C8AF52C81C_gshared (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mF13B6674061D28A1BEC4861C9DEC3C64227EC93D_gshared (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m4F549A52CFE9F1740D8C1B6F9560C3F199F4A748_gshared (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B InternalEnumerator_1_get_Current_m5C45B04B93E24CF93F54B15DA1E0A4E5FB0D4F77_gshared (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDCDCABB85F4DCAFD112EBF0FAE0C6961DBFE301D_gshared (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m99CA89EB79E57A9759F9A03DF4D0B26DC43E553A_gshared (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m52BE8429C80228377F2B44CF929F869A7B3EB7FB_gshared (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mBE1CDE7FA444201BDA464FFC7DE46B39E8099762_gshared (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mF88FE72FCC8D35935014046A828E263C0B07857E_gshared (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937 InternalEnumerator_1_get_Current_mD3C6FDF318DBC20B66E7B62496085159512C8FB5_gshared (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mF5166C405A731BC27FEB654DAACAB8BFF8111CBF_gshared (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mA4A313B9A3753AFFF14915F1CC2C85E78C25BAD7_gshared (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m242214F003D15A119A0C04FFE652998D8FE41522_gshared (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m5E91FF0A6E2EF0B84CB4158ECB1F8B4A6455CF23_gshared (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mE4B207058D201EB5E54D576C57360ED5A09C2BE8_gshared (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78 InternalEnumerator_1_get_Current_m0577F355E2082ACD4D2A5281A5D618D2BAEB018C_gshared (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mF9EE0D0E138FD359A2F13C49636ACD60C723415C_gshared (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m43DAB8F8C87A0B6E511C39045473A42294BE62CA_gshared (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m61F868D64FD5C0E79726859694754B78C3A12F13_gshared (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m1BF7479D1C81DB164169EA2E67489072EFAEDB8D_gshared (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m70A36FB83C5C0D46465928D98C613AC06DC4555F_gshared (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE InternalEnumerator_1_get_Current_mB446FB579A0D2052E3021D345FBA2E7BD1E2D8E7_gshared (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m19A49279822B4D3317DE80D741A23A1FFBC4AA8D_gshared (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mF99F2E94E6B96C25D18AD365535F6596F6A8976D_gshared (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m68CFC035FC3DC1BD21D1ACB9580D1852CC49FF51_gshared (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mDCA828D764CBB14FB3CF31AF0BDC68709FA4DAE7_gshared (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m9B1CF619F7F4E40343409851A9C45D5E2CB9347D_gshared (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E InternalEnumerator_1_get_Current_mF0C51E221CD4A4E7C605483AF49C78902866C3C5_gshared (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mB8AA11D403DCF5974D63F330E5390A13F2521A2B_gshared (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9646270AE8A4EB0758936B3CB5A0530524ADFB4C_gshared (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m5207FBDBFFFA3362A79214E0F6563073D0739B36_gshared (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m5D695D1842FAD0CF7E2626EE58BE25188594A063_gshared (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mFA644183525E4E7C1DA9E0AB2520DEC0664DB22E_gshared (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE InternalEnumerator_1_get_Current_m8BCE8ACA1FB9184338A431ADF16C9ADEF01FE5A5_gshared (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDEA574E3825E771EA4138A2FDBA795680D2D6DDF_gshared (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8F15A6CF9D2375039F3A2922EC07A6F66A911D2E_gshared (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m9F3DE26BFE9BF17F177A5DC956AADC3AEC5A7729_gshared (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mEA3762DB58F8733CC8196C00787BFB4B1D1BBBFC_gshared (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m4BECF4142A35A113A6B4932DB906E425F6209742_gshared (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6 InternalEnumerator_1_get_Current_m52F1F50D102498BDAA3DC236872E47AB913F5B5D_gshared (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mB8257FAF3E914823A81665B44108DBB6FF6E676B_gshared (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCB16D07C75263BD2D00943720593924E2548EC08_gshared (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m1A7199B93AA095B50B5B5434C225D227E5F5BB93_gshared (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m9741A20915B57ACCEE417A751E7DD64FFFC93BE6_gshared (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mD78BC91300561B9802E9F3D57821D903E75298B3_gshared (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4 InternalEnumerator_1_get_Current_m588A1C9004B72DEF16E5D6EEEE07D34F994B5E5B_gshared (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m63EE71FC9ACD0C91B910C5FDC9CDD975807B70B9_gshared (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB59C149FC8EAA87F79922094A6EF1354971B0A20_gshared (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Hashtable/bucket>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m5E660A4E0C016C0CA6AE7EA86BC146FAA02B10BF_gshared (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Hashtable/bucket>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mE1E9392D5C112D0793D3217A5DA839CDA30E42AE_gshared (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Hashtable/bucket>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m1BDC4F1B539642F68851541B59BE304AC3EACE73_gshared (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Collections.Hashtable/bucket>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bucket_t1C848488DF65838689F7773D46F9E7E8C881B083 InternalEnumerator_1_get_Current_mDBE1EC33C2BD728CBA191BA48B16AFD2BCE81F6D_gshared (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Collections.Hashtable/bucket>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6BEEA4996FE2FAD1230E143C6C160BD2811C445B_gshared (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Collections.Hashtable/bucket>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m898C99F1A17C87AE5BB8AE238571C8D449A9C8A1_gshared (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.DateTime>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m38FF15007E4EC72548A334D194D158343AA99CC7_gshared (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.DateTime>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m706D65100CBE250B47E0D87A75E13164F9CAB601_gshared (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.DateTime>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mAD2E5315BA13D08E0B7FEBC36D5C029DCD48A00B_gshared (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.DateTime>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 InternalEnumerator_1_get_Current_mC41E15442C38B131C7AD1E88876963F01A4868CB_gshared (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.DateTime>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m99164482C6858CCA3B028445F1A836FED67A353B_gshared (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.DateTime>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1668301F0BFBFB089DAFB2BCF55CFD464CC218C2_gshared (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Decimal>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m9FA8DEA90071FEC73528075A9F1100D76CDE99D5_gshared (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Decimal>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m2CDB317CD290A3CF69F8CFFB4740A174FBCB4957_gshared (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Decimal>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m8BFF576A59DF1CA270FBA8F1ED3FC4F57A491229_gshared (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Decimal>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 InternalEnumerator_1_get_Current_mB1B90708ED55CB1E651BF9E5FA629B28E8E5977A_gshared (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Decimal>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mE109263B389473C6F2F6821A32E6273D52722A5D_gshared (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Decimal>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mBF9B03E2327F706D52248C6F35FCAD49FB6C2F98_gshared (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider/SessionInfo>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mDDF607BB20488A6FA7CA084A5224268E0338C52C_gshared (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider/SessionInfo>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mADC6EE407FA72D81123E076FBBFF257865478FF1_gshared (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider/SessionInfo>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m3652AD403099B49406A1E024990598169861FC38_gshared (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider/SessionInfo>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A InternalEnumerator_1_get_Current_m868993F9E581D2FDE89D311B0D0E7F043B5526EE_gshared (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider/SessionInfo>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m0A1DEAFFFA545BF34F3B2B8B5C4ABBD0D762860F_gshared (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider/SessionInfo>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB3B98E6648B86023BBCBA7071A37A9DF18C899BF_gshared (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventSource/EventMetadata>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m70FD5955510D3C8C60F9432DC1576FEA4BF298D6_gshared (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventSource/EventMetadata>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m068CDEACC21774C02CAE19D8DA4DD58BA70A77FA_gshared (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventSource/EventMetadata>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mF47AB1403AEA819AC6C6F83E75A8E6B630274601_gshared (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventSource/EventMetadata>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B InternalEnumerator_1_get_Current_m209A56D6C53AC134B236FD1E3808E42C2DA0F378_gshared (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventSource/EventMetadata>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mEDDD49DFA18C451495C8E8128854D370181D0C12_gshared (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventSource/EventMetadata>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mA1E541F561DF486D84527601ABB2404DD6501DA3_gshared (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Double>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m2EB3647F564935D58525C6BF0F365C22D0F86EEF_gshared (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Double>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m897B005D5C7B05B9946D2CA717A24D642DC3B692_gshared (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Double>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mC78350B2B7286550FF3DCEA2105FAF745425F5F6_gshared (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Double>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR double InternalEnumerator_1_get_Current_m4CF2B380D638F22E5C70B4E41F35AD95FB71FE26_gshared (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Double>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m2E70BDAD683DCC0CBD56FF1B3F1C1DC7B86565A3_gshared (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Double>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2E95A3A4607ED179D9FE2D702C7E6109ACF36269_gshared (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m99BBAA2F747C901A1EAED9DD8F28837B642E16D9_gshared (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m190F2C8765ECDC1A19A67DEE686CDAE334DD238F_gshared (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m5874180E5D0BF8559989E93AD753745463CCE784_gshared (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4 InternalEnumerator_1_get_Current_m5E3D89E57206E983F95400F30010E1922D7E1A1C_gshared (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mAC88F8333D9BC850EB955235E4FF7B49A2EB9ADA_gshared (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mADD52706A60B65EF430A9A8361D76CE2FB08FBF4_gshared (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mC0268A706CA7F19506CC886359704ED873A74811_gshared (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m829CDAF898E571D63C974F1031E986662BE6A7B4_gshared (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mA4049184F49FCF2BB8D8164C53BC2F9A98DE1528_gshared (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211 InternalEnumerator_1_get_Current_m7CE9128839CB0EC4AF3B0BAF875A178ED4EA9E42_gshared (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m9B5A4FBEB36F25AB04EC9A082999D3C5C960F2B2_gshared (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0864F6C06C70CAE51CC7A38AA55CCF704BB674A8_gshared (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Guid>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m9903677C8275AC12400E4CF7DD8F9CA715E93EF7_gshared (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Guid>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mD354E2C453E6A047D967B2B456259FF544320E3B_gshared (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Guid>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mE7E1CD869291B4E596B1A67E0863CC7D6F4D7186_gshared (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Guid>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Guid_t InternalEnumerator_1_get_Current_m654F712F9682ADAE03DA5A38B8EA05099AB77864_gshared (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Guid>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mCC1FF18F89CE70BE3D2AD5ED3FEE3E244F2885C5_gshared (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Guid>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m99DD87F3BFD258C3366BA0846CA059840BA2D0CE_gshared (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Int16>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m8EE54AB2215933CFD3514ACDD75A87A8BE8B60AE_gshared (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Int16>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m3C2D5CADD976B0AD79CDC5BBE3EACFA5E1EAEC14_gshared (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Int16>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m454457EA339027D7DAE0DD53FF1EA7C34A6CD7EE_gshared (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Int16>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int16_t InternalEnumerator_1_get_Current_mFFD60C69E1F8CF93C20492F2A58FBC09CEB6188F_gshared (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Int16>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA81C0DBCEBF6CFD70EC6FD73CD4F84CE65DDB260_gshared (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Int16>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m51CF0FAA9202E3C70397E473B6F312B1977D0861_gshared (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Int32>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mFD68B921CD29713A2BEB038318C202A9E4E9B5CE_gshared (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Int32>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mBFEAB58E625616898F0E0ED1A11935920DD0A34E_gshared (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Int32>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mEABDC1E82F7AAE1B3B6DE2F40F0B7FDE199312C3_gshared (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Int32>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t InternalEnumerator_1_get_Current_m70AA9F95B052891AAD4AB638CA09537554ABE683_gshared (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Int32>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5215F161D6643BFA30010228E401FFA587630F25_gshared (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Int32>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m95E1A22E55B29BD2BE8001BDB1E13CC3DE23A2D7_gshared (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Int32Enum>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mBF8E58BAA9971C4074B8EEC028434A1BAEB0748F_gshared (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Int32Enum>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m4A6D2508A0C1EFE6CB0DDCCA0057F8EC22168204_gshared (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Int32Enum>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mDD38EA99C85E3EE7271D7786026B1523054CC257_gshared (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Int32Enum>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t InternalEnumerator_1_get_Current_m079C9B7D950F47EBDDE3290AF721C64568541238_gshared (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Int32Enum>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mEA4ADBA1D47E80688B0470DF0C297444612C7311_gshared (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Int32Enum>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC2955E66B742022B3C37F449E2DAFDA6CED420C0_gshared (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Int64>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m68F9020151CD964322723D3C02977C30EA0F189E_gshared (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Int64>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mD7021BD3B9CF1E4B5A10D78E753CDB276A8631AD_gshared (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Int64>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m3921385986D9A6472FAAAD1EEFBB0AFBEE0A98AE_gshared (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Int64>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t InternalEnumerator_1_get_Current_m9A73AB58D1A8BE0B72C490559F3DB7A1A8194174_gshared (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Int64>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC3C01ADBFB01FCDD97526280A73422955CA7898F_gshared (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Int64>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m7CDD9680E17A3B80D1D3332A68A89353FFAA0D87_gshared (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.IntPtr>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mCC5889C0F1785F416EB4E3EB0EE4BE48D0A055C8_gshared (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.IntPtr>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m2404F9B209B37D0B37621E1D7FB27D3E7C105719_gshared (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.IntPtr>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mF114574B4163E7D82DCB1FD35E3AF796F8F1A868_gshared (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.IntPtr>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR intptr_t InternalEnumerator_1_get_Current_m94C0D13214FB1EC791B1CC5DFE5A82E2AAE63406_gshared (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.IntPtr>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m491E05099AFA8FC0AED0F826973AF0A2565B1E9B_gshared (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.IntPtr>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m87769ABA238DC3B1539ABAEFB4A723EDB7F0DF9C_gshared (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Object>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mD75F701A17A7159EEF2877D9FE74845402AC4201_gshared (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Object>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m8EAB86BD597ACADB2C2CACC4EE1C95C2AF4B7FE0_gshared (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Object>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m940227577EE2352E678C755A533CD684708D464C_gshared (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Object>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_get_Current_m4CE05D9509A3134EAC31E8340F36EC2B4B54703F_gshared (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Object>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m7BC7629BA183FA12CC79E5271FB346EC4F200C4D_gshared (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Object>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0A567B403B179EFB6D4D15CF7700244CB66E5AEA_gshared (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.ParameterizedStrings/FormatParam>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mAEB0249C2146033E833B7EBDA3EB88B9A9F90659_gshared (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.ParameterizedStrings/FormatParam>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m68BF57EDA1103571F0E0FE5001194B0BB8F3A78F_gshared (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.ParameterizedStrings/FormatParam>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mD624D66316245A1A440D7492A5A3C940E1FA3EFC_gshared (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.ParameterizedStrings/FormatParam>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800 InternalEnumerator_1_get_Current_m80B0AC143205EB914B0C033876B87B4C3B344F57_gshared (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.ParameterizedStrings/FormatParam>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m3485D18CB013850FA9EB78958297150717F3C5EF_gshared (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.ParameterizedStrings/FormatParam>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2979F5923AFE9DF4D43A441505AFDC088D016C8E_gshared (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m226870CF6B7D12848BF991EACF40C735345AB28B_gshared (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m6C8EBC317B2CFAA7DA0D992C194FD95A92926413_gshared (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m0CACB620368208A8F7576489AE8CE43D3CF50ACB_gshared (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E InternalEnumerator_1_get_Current_m1AB3F2C70645660A20831F4A4FDBB1AB61DB8420_gshared (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC0F15D2E68613F49046B87ACA9F38FA69335EAE4_gshared (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m5842A354F96DCDF6DB6E8B1A2A7FE11B12912965_gshared (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m5FF7EDC8E7C9A9250B548F9C9EB5CF3360E889FB_gshared (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m4EF1DF22F31CAA58E4F6DD4B579E722157C60B68_gshared (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mB92131A3838FF515C4E84AFEE0EFBBB0D9CEE12D_gshared (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 InternalEnumerator_1_get_Current_m3D123B39BCDA4F165484915F8DD3940962AECBF0_gshared (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m55E5E22BB6ECFA78AD2DA166F453D831C80A0454_gshared (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m24102447F4216E92F9D6C5449EFA7C4D0303B3A0_gshared (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Reflection.ParameterModifier>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mDEBB2C6716C9789C8928EC4E44AF6AAB5C270D3C_gshared (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Reflection.ParameterModifier>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m0E64CEABEE646480E8568420A7019690D7649941_gshared (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Reflection.ParameterModifier>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m730B50E3F1654202F07EA4CF4B79E444DA499268_gshared (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Reflection.ParameterModifier>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E InternalEnumerator_1_get_Current_m81C0B3258A94D63BA8AF4BE1C02FC30E77BCA1C4_gshared (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Reflection.ParameterModifier>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m77F8981C0DA5CA0ED4BBF6CA038792DC61AA2B07_gshared (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Reflection.ParameterModifier>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCD8241095A16E48C02661D5E39C42E18D7F8AD5B_gshared (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Resources.ResourceLocator>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m3E014CF0DDF2BDBCED19F196342255153BDBA51E_gshared (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Resources.ResourceLocator>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m52FBDFDBF43E58009C49B5F1C21DE59215820C75_gshared (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Resources.ResourceLocator>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mD4C121CEDFFEFB31C6EC9302CBC1192E51F2093A_gshared (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Resources.ResourceLocator>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C InternalEnumerator_1_get_Current_m5474D37CD91A506826F57EEEA5BA8900CC2A212D_gshared (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Resources.ResourceLocator>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA76FFEF1093C75431297838B18FFBF048A4CB917_gshared (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Resources.ResourceLocator>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6D49286C74B3A35243C731877CCE06A79725DCF9_gshared (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m9E14CFB1C79CC7C9D79DD72B62C9B0F353F8BAB4_gshared (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m969B47D66A78D205B0B3A1CA537C3A9FBCB6EC5D_gshared (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m1CD5357A6497F1DB261EA284D09EC306D38ADF48_gshared (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA InternalEnumerator_1_get_Current_mCFB8564C9D825B393AABF73A69BAE8E986796895_gshared (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m29C2E6DA559A8EBC643267E932846423DBDA5858_gshared (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0CBEFE2675B461D8C9459F86D1554C6C4E1F80D0_gshared (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mA819F7E05D294E7B7E037030EB0FD992FB346FC6_gshared (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mD4D3F12484F4B6379333FAC08508D39808224D91_gshared (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mA2DBBC0E980B2978432B2B220B1189909B91F03F_gshared (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 InternalEnumerator_1_get_Current_m95BBA6E2E51E7EFE7672D9D8A78D29B9FFDFEAEE_gshared (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC0579D55B4A9F531AF1351053125A484DB0095F7_gshared (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8AD84D9CB10EB751A7052B86C5316EBB2BF7717A_gshared (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.SByte>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mE9379D2FF2800845F39295ECC82CC75C1BFAD2A2_gshared (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.SByte>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m05749D31B7EEEF1517775595FCB5BDD0873722C1_gshared (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.SByte>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m7A514CDCE03B1914EA0CC2EC436A9BDB88026FA7_gshared (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.SByte>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int8_t InternalEnumerator_1_get_Current_mCEBACD4CF4D2DF7FDB7FF8031CCE8725B75DA540_gshared (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.SByte>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6B6DFDBA279C13F9F632240CF4F9CEEF91DB0530_gshared (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.SByte>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m003EC0581DCE444D5CFBFF92BEF7664C66963B76_gshared (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Single>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mAA128A1D51031DF02D178B5C5A7316CC7D6C22BE_gshared (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Single>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m88C5741AF3B1D2EA397DB46512535BC34C871D3C_gshared (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Single>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m61CFF397E0E8740BC9F65E736C1507C05D8FCF32_gshared (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Single>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float InternalEnumerator_1_get_Current_m8C4CCAC66EBAE129B0DCCA46A73041A2B0F3B999_gshared (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Single>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5F8FEAC529452CDE3CAF154E65C3F0E8B7EDD6C6_gshared (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Single>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m607EFC7537C7AF61B9224D93F36EDF50577EFE62_gshared (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m7F748D6834D2CDDE775D0EEE50FBF11138CFF61F_gshared (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m44FBA1A533BB2AD3EDF8E6570E5E0032549BCCE1_gshared (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m6E63B51D31ABC06C44F6EC10392F44AF29319A72_gshared (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B InternalEnumerator_1_get_Current_m4BFF9065A44EB1D4FB065F5709238C6489E5A0C5_gshared (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m61DB74B19C84DF5D0586793E8AE60599FD8D9E3E_gshared (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mAA35E609F68D4AA4808C8518DBEA1A5DC84FD2F8_gshared (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m3F65E1A1CF891ED1F8E134CE2EE25E149C327F19_gshared (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m39C85AF12F54B32A18A618ED54AEB5BABC90F776_gshared (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m0DBCE94BE0EA9EFB33DA7667DF03CCF8F83E7585_gshared (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2 InternalEnumerator_1_get_Current_m2EF8D8561F60AAA02F2B3BD2EC7176E50BCD5E52_gshared (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mBEA53E27186A3117450CEAFB374CEB5B73313997_gshared (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m343A40850C40793147C70F0A503FD2CB6E4CE4AE_gshared (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.TimeSpan>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mC1AEF444A58A2261E281DD76B188FF7538F424EA_gshared (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.TimeSpan>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mCD40BF3A7626144872F2642F3B34F182DA518793_gshared (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.TimeSpan>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m5ECDBB64DF2420FD59C457CFD882942454EFEC65_gshared (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.TimeSpan>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 InternalEnumerator_1_get_Current_m08ED2C8C47D5621377FB042EFFFF6038160D427C_gshared (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.TimeSpan>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m061C2085607EF3A620F7914BBDFABB38E2F988E5_gshared (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.TimeSpan>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9D8A5C3B19CDB3A2FA242A18C34301E6D95865C8_gshared (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.UInt16>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mFE4EF7DC9B7656A8F9541C6DB174623D677CA6CD_gshared (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.UInt16>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mF86968B10A7E2847776ADFBF834C522CDB599961_gshared (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.UInt16>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mB8CE82E4885258C6A341B97A978720422A1E9738_gshared (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.UInt16>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t InternalEnumerator_1_get_Current_mB4EDDDE7A9FD306176CCDDC4E9693B40EF7B984B_gshared (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.UInt16>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m116599B0F101CFB030D78D7AFD984D465A4C6F83_gshared (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.UInt16>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1F016830E08D4370DEE1C0F0136A9F75CB608CE0_gshared (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.UInt32>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m577E98213388A2A32E776481E79087B4BEC45B01_gshared (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.UInt32>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m8FF972AE2AF8D8C8EBF974D4B9CC114114E76C8B_gshared (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.UInt32>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m8D45F4F482D6E2899C7E9A9E11CE3A9E7390D10C_gshared (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.UInt32>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t InternalEnumerator_1_get_Current_m7A52D8C9B31569083E11811B585B6D3BABA3A948_gshared (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.UInt32>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mE3C9251CD4163687394B2503AEEF0E2E7EB2ECC5_gshared (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.UInt32>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m886F80208845CAF7BEB08CD40275D4453CA3427A_gshared (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.UInt64>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m7292D20FBAECFA8BCEA4475F6BBE6AC30075B45E_gshared (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.UInt64>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mD466713709A8E59C335DBE0FFF5EFA8855CE93C9_gshared (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.UInt64>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m4F5A6CEDFCDD55DFACBF1BF4FE66A19BDAA14CBF_gshared (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.UInt64>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t InternalEnumerator_1_get_Current_mEACBD5ABDAC498CC39F2D794C276AFCB4B23D5A6_gshared (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.UInt64>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mED2DD8750E377B5B9B3D6C18B841712DCC6B79A7_gshared (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.UInt64>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD46DCC366FA87AE6E061E4789BB1C74A5DA10B3B_gshared (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.UIntPtr>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mFA2C0D7C19279B4FE83F179D8BB3FE277CD6BB40_gshared (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.UIntPtr>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m8EB8FF6C30EC949B10E0008F0FCF5E0AEA78F6D6_gshared (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<System.UIntPtr>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m872C83B5D2E2C798AB5482B0919DCC9EF3E0D613_gshared (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<System.UIntPtr>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uintptr_t InternalEnumerator_1_get_Current_m898EF6FD732B94B5BA3C6CFC17B8C3897D0C5B6B_gshared (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<System.UIntPtr>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDF094F535B0402FBE582B4CBF3B943D5919FB798_gshared (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<System.UIntPtr>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m868092AD29D3DEA8DFA21574DCA9D751BCD65B6C_gshared (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.BeforeRenderHelper/OrderBlock>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m0CE98768FA95BB57698E7D51B48485337983B3A6_gshared (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.BeforeRenderHelper/OrderBlock>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m720EC1E93AD8CBDB05BB4E9DE7B14892F51DE771_gshared (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.BeforeRenderHelper/OrderBlock>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mE291D66A15F236A0AF25EC165D0AB1C3322A1685_gshared (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<UnityEngine.BeforeRenderHelper/OrderBlock>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727 InternalEnumerator_1_get_Current_mF3A24C3ABE3B152A3C3A30863E92D79103A50BA1_gshared (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.BeforeRenderHelper/OrderBlock>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m067658D2CA96B529EB660B05302D2CE3B39C7E1A_gshared (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<UnityEngine.BeforeRenderHelper/OrderBlock>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m78F6CCA9BF95D5E77745394EFA9DA416D89098C0_gshared (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Color32>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mA76CB6C92F93D4D154DEF97B62B04875E9DD0C0C_gshared (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Color32>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mE55774E2396C5AE20E56EC04F520945363A489B9_gshared (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.Color32>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m677EA6BD7E9DF5EE4A08D0A7A229D4F099D15B70_gshared (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<UnityEngine.Color32>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 InternalEnumerator_1_get_Current_m80E4BACA28C64E50461E74B92DEE28DD5C49A580_gshared (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Color32>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5E4EBF6B2AAA4014717EA1653979D34CEECE24CA_gshared (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<UnityEngine.Color32>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mE73D1EC7DC5AEA554051C0D37A9E295058779760_gshared (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m2009C5E8886D700C065C716EF1D08BACA6B8087F_gshared (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m77AAB4FA0C543E276DDD0B102DFBE7FCDA30EF84_gshared (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m39F2F8FCB3BA39695FB2A1DEC28855172B6E5D4A_gshared (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91 InternalEnumerator_1_get_Current_mB7A85C3324689374F5BBE1813C0439798CDFF9CB_gshared (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m853CB9E446725D1B5FCA19FD9A4D48B5B5FECB63_gshared (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8E1C99A6B2906E3087932AFEF36212027CC4061D_gshared (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m090BB39068F5FAEBC457FE64EBE4DA412ED1EFDC_gshared (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m17AD15A48F9CDF8D46E8580E3CEFC6F5D2836901_gshared (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m26900C6C96A7B745F63A23F111699B6C143AAE16_gshared (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2 InternalEnumerator_1_get_Current_mA90DEF143C9B52AABD722C59391860F4421B8D6C_gshared (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6910B345DBCBBF0C51B12306365DDC4490D26FDE_gshared (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC8201A170A6AE7E43400EEE1DC7DD3A78CAE3A86_gshared (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Keyframe>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m53F1CFC38C88469A9029DF819DCDDCE98487450A_gshared (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Keyframe>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mA73E7B7883E5D7E92D433DF0A315C5D93999F3BC_gshared (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.Keyframe>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m5AF8DEADCAFA428FB19D5A6BD9AB03ACBC4E2529_gshared (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<UnityEngine.Keyframe>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74 InternalEnumerator_1_get_Current_m423DED00D8E4A4F471ACF4A96345C45C4378F556_gshared (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Keyframe>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m883E5884C422A9F29875971082BB78699FB05CC2_gshared (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<UnityEngine.Keyframe>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m43B13AEAA9229073FEC9D245DD86BA6C7271C778_gshared (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m02C8360860C5438D895C11BB0AD8FC4F1A84B31A_gshared (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m7089BC2386B69BD1D6A077BAB7EF4FC870FBF3A4_gshared (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m3DE3F342FDB99BAF186349D0A92573B0457B5E8D_gshared (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93 InternalEnumerator_1_get_Current_mCF3BFAF3BCAACDF803583C88DD293C5B812A145C_gshared (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m8ED9FEB6CB357866559DA8F1EB2357D2A2AF4C12_gshared (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mFE74BD11BA547725F31D73E2B0D9D52E766974A0_gshared (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Plane>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mEB73FE451C65A512459AF88DD8D0FE7380EDF3D0_gshared (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Plane>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m180D8619B6A23257FC75B397E08E49A799C4FE21_gshared (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.Plane>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m3C69C6DCCF2CD3D57E04836C025D1F6A6C4C6968_gshared (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<UnityEngine.Plane>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED InternalEnumerator_1_get_Current_mE52FE5CD07FFC9C64D612B428D4C9CE7BD68C140_gshared (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Plane>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m8CEF9D7220336ED895EDC381CFB017FD626D28BD_gshared (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<UnityEngine.Plane>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB6DF41AE2CF0E39492CBF01D41C79A2AD588D93F_gshared (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mF99DDB9595945AEC3CB62FAAF94AE0B1DC69ADDB_gshared (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m51B757A0306D3F268AD6471871FBEEBB522A61D6_gshared (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m06838EFE676483F59B23F9AED5EDC25307714819_gshared (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8 InternalEnumerator_1_get_Current_m409E760F9CBF152E005D1ABB74D0D4208D56227F_gshared (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m544181F0799962E6A3C803D778B166694730EB37_gshared (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0D484DEF2526C455371ED5D16CB02AD3FAD8C523_gshared (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.RaycastHit2D>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m830814E57A2D1219D886501A9029DEED40DD6635_gshared (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.RaycastHit2D>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m210975609AF4E5F2A41A9E2D0CFFF0CAA90B5585_gshared (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.RaycastHit2D>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mCDA22D571C4E009906699C4AB8BA2DE7A3D94302_gshared (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<UnityEngine.RaycastHit2D>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE InternalEnumerator_1_get_Current_m8DD1DD354BD2CCD8BF53308EE859FD91BAC319F4_gshared (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.RaycastHit2D>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA7B96D62B276CF6419B4931598F51F617FBAD8C4_gshared (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<UnityEngine.RaycastHit2D>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mFABE9B6A837F021896FCC9A5575D1AD8A90B0C40_gshared (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.RaycastHit>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m116E15DD07CF4905FCA6B327A46E6DC056560A77_gshared (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, RuntimeArray * ___array0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.RaycastHit>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m213BB289521A11B41BDA96FDCBC473571C0F7134_gshared (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.RaycastHit>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m102F72F47F424F98374FB84922BF92F939ACE282_gshared (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method);
// T System.Array/InternalEnumerator`1<UnityEngine.RaycastHit>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3 InternalEnumerator_1_get_Current_m7DAF45BE6246754B95E518F44152AB86F6F01503_gshared (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<UnityEngine.RaycastHit>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m42B612DDDCBC1C31AC83DDDAA4382E7C8FED7384_gshared (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method);
// System.Object System.Array/InternalEnumerator`1<UnityEngine.RaycastHit>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6AB1B76B5D46EFE4ACDA056F38B79D9449AE806E_gshared (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method);
// System.Void System.Object::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0 (RuntimeObject * __this, const RuntimeMethod* method);
// System.String System.String::Format(System.IFormatProvider,System.String,System.Object[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Format_mF68EE0DEC1AA5ADE9DFEF9AE0508E428FBB10EFD (RuntimeObject* ___provider0, String_t* ___format1, ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* ___args2, const RuntimeMethod* method);
// System.Void System.InvalidOperationException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706 (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * __this, String_t* ___message0, const RuntimeMethod* method);
// System.Void System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mB435979A4FC207D777BBBEDCBE6DBD47F06FC2D3 (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mB435979A4FC207D777BBBEDCBE6DBD47F06FC2D3_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::Dispose()
inline void InternalEnumerator_1_Dispose_m9FFA4290ED807AF40BD2E60F26023529593AA5A0 (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m9FFA4290ED807AF40BD2E60F26023529593AA5A0_gshared)(__this, method);
}
// System.Int32 System.Array::get_Length()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D (RuntimeArray * __this, const RuntimeMethod* method);
// System.Boolean System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m19B8C2E6A68876BE54C2C35DD948B7C496D98546 (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m19B8C2E6A68876BE54C2C35DD948B7C496D98546_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::get_Current()
inline TableRange_t485CF0807771CC05023466CFCB0AE25C46648100 InternalEnumerator_1_get_Current_m5BF1362D0455A86D563CA0FE18879952C871ABC3 (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method)
{
return (( TableRange_t485CF0807771CC05023466CFCB0AE25C46648100 (*) (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m5BF1362D0455A86D563CA0FE18879952C871ABC3_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC74FE1FCF522A51276B59B78AF8420D1E2F6AEA7 (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC74FE1FCF522A51276B59B78AF8420D1E2F6AEA7_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD6A7480B222C2ED4423DFA000737E0286A78A130 (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD6A7480B222C2ED4423DFA000737E0286A78A130_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Boolean>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mC6576DE9DFD26D645933F33DDFFF5C193BD2C64F (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mC6576DE9DFD26D645933F33DDFFF5C193BD2C64F_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Boolean>::Dispose()
inline void InternalEnumerator_1_Dispose_mAA797BBD83F736868FA6A8E186371BEADFC9A7CA (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mAA797BBD83F736868FA6A8E186371BEADFC9A7CA_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Boolean>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m5D14BBDC6E172C9CFF85357EDA146D2F493191EC (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m5D14BBDC6E172C9CFF85357EDA146D2F493191EC_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Boolean>::get_Current()
inline bool InternalEnumerator_1_get_Current_m0E37DD99400FD8E67350E2959B777C353662D4AE (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m0E37DD99400FD8E67350E2959B777C353662D4AE_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Boolean>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mBF9C54BE8A4A3C352F42280C1B76AD173905241D (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mBF9C54BE8A4A3C352F42280C1B76AD173905241D_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Boolean>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m406897CA7EC01C35D90402E4AA916647716FB767 (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m406897CA7EC01C35D90402E4AA916647716FB767_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Byte>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mCE5D4D9E3057660C094936737BA70F2ADE3646F9 (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mCE5D4D9E3057660C094936737BA70F2ADE3646F9_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Byte>::Dispose()
inline void InternalEnumerator_1_Dispose_mC32656E5117A66CF11FF1BEA4C941AA4034677AC (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mC32656E5117A66CF11FF1BEA4C941AA4034677AC_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Byte>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mBA8D7A7C9CD1D0771BB9638FB7A0A4D17F5F7F72 (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mBA8D7A7C9CD1D0771BB9638FB7A0A4D17F5F7F72_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Byte>::get_Current()
inline uint8_t InternalEnumerator_1_get_Current_m8322D35634EA8F36F950C7FC88EA889817413E87 (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method)
{
return (( uint8_t (*) (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m8322D35634EA8F36F950C7FC88EA889817413E87_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Byte>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m52D68F77094EDDD9016386AF3F5A5B5781C974D9 (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m52D68F77094EDDD9016386AF3F5A5B5781C974D9_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Byte>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m92570BB2C86AD0B6EB8845B78FF96396A458D6BE (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m92570BB2C86AD0B6EB8845B78FF96396A458D6BE_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Char>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mA816E1C13D866A2558DA3C530799B1D3858F80EF (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mA816E1C13D866A2558DA3C530799B1D3858F80EF_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Char>::Dispose()
inline void InternalEnumerator_1_Dispose_mDCC22EFC517EA05A44E470F2DA1919EE5A58F9FA (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mDCC22EFC517EA05A44E470F2DA1919EE5A58F9FA_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Char>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m3FAA847DFF670AFBF34878A1F45C9B29F5DD973C (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m3FAA847DFF670AFBF34878A1F45C9B29F5DD973C_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Char>::get_Current()
inline Il2CppChar InternalEnumerator_1_get_Current_mF9D5C23927E856F0D50CD0211DD96DED7A737466 (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method)
{
return (( Il2CppChar (*) (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mF9D5C23927E856F0D50CD0211DD96DED7A737466_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Char>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m51B86411AC68CD7F9618FF2523FB1199AA56372E (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m51B86411AC68CD7F9618FF2523FB1199AA56372E_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Char>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mDEDC109FF80129362D85F9A7749B1540AFBD07B7 (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mDEDC109FF80129362D85F9A7749B1540AFBD07B7_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mC0890A26F45EB3D0CE722AA211191F47A7D89CAE (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mC0890A26F45EB3D0CE722AA211191F47A7D89CAE_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::Dispose()
inline void InternalEnumerator_1_Dispose_mC2FAA1D4D203A9339BBC1340D21F3ED010DDDBAC (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mC2FAA1D4D203A9339BBC1340D21F3ED010DDDBAC_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mCB1B8EAAF7F7CBAFAA5F7514553B6DC1038D4AC4 (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mCB1B8EAAF7F7CBAFAA5F7514553B6DC1038D4AC4_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::get_Current()
inline DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4 InternalEnumerator_1_get_Current_mF60DB3DFAED76189D44BCCA186D595043C014D3E (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method)
{
return (( DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4 (*) (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mF60DB3DFAED76189D44BCCA186D595043C014D3E_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6CB9F8EC8CBE7FD4FADFAB7F64A37B7A7508D691 (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6CB9F8EC8CBE7FD4FADFAB7F64A37B7A7508D691_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD1EDD7B929F2A9A91509082AEC0A70709B12CEF8 (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD1EDD7B929F2A9A91509082AEC0A70709B12CEF8_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Int32,System.Object>>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m826AE3C40B8AFBE65F21024B99461A8E3435394E (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m826AE3C40B8AFBE65F21024B99461A8E3435394E_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Int32,System.Object>>::Dispose()
inline void InternalEnumerator_1_Dispose_m1CBAB604EC0F2F4558305325B30BC790A0684D54 (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m1CBAB604EC0F2F4558305325B30BC790A0684D54_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Int32,System.Object>>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m007FB57DED6F561D3EEC01BD59C68BFBD9FEA626 (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m007FB57DED6F561D3EEC01BD59C68BFBD9FEA626_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Int32,System.Object>>::get_Current()
inline Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D InternalEnumerator_1_get_Current_m4ABCF333B87FC095F8DB1908EE7CB57702BBB20F (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method)
{
return (( Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D (*) (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m4ABCF333B87FC095F8DB1908EE7CB57702BBB20F_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Int32,System.Object>>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC24466541138E727EBE50B0E0A22F6651161EB71 (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC24466541138E727EBE50B0E0A22F6651161EB71_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Int32,System.Object>>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9369158204F4280AA8C76BD2E47E8A91C9FDC053 (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9369158204F4280AA8C76BD2E47E8A91C9FDC053_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Int32>>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m56019387E27A8E3481BDF2669CDE33C7899A4ECB (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m56019387E27A8E3481BDF2669CDE33C7899A4ECB_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Int32>>::Dispose()
inline void InternalEnumerator_1_Dispose_m1F2BED538F9A714FDD0663B4E12CEF6D82CD9459 (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m1F2BED538F9A714FDD0663B4E12CEF6D82CD9459_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Int32>>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m47F7361F7276ED03BEF7B9E04EC7431ACAAE6906 (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m47F7361F7276ED03BEF7B9E04EC7431ACAAE6906_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Int32>>::get_Current()
inline Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE InternalEnumerator_1_get_Current_m92BB9CC66A8467F196EA707E00E7186FA64AE48B (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method)
{
return (( Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE (*) (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m92BB9CC66A8467F196EA707E00E7186FA64AE48B_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Int32>>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5D43D1F4D741863D821F9E78A4A608F58B2485DF (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5D43D1F4D741863D821F9E78A4A608F58B2485DF_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Int32>>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1E60E687D9B216101D35FA36C1D0EF48FF5C5F27 (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1E60E687D9B216101D35FA36C1D0EF48FF5C5F27_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Object>>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m1593CE384E20D884D915D8C63DB0063790B3A618 (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m1593CE384E20D884D915D8C63DB0063790B3A618_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Object>>::Dispose()
inline void InternalEnumerator_1_Dispose_m4836500B7FEA20ACA83183ECBE1D467826FCE670 (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m4836500B7FEA20ACA83183ECBE1D467826FCE670_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Object>>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m48BA3A9AC0BA051915D58DFCA32B1AA5C09DE957 (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m48BA3A9AC0BA051915D58DFCA32B1AA5C09DE957_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Object>>::get_Current()
inline Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA InternalEnumerator_1_get_Current_mC2EC065F63466F7E6AD6C9AE9BC86A3B0CF0E07A (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method)
{
return (( Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA (*) (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mC2EC065F63466F7E6AD6C9AE9BC86A3B0CF0E07A_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Object>>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m9C6C41648ADC7B60E8AF51190EEA7BAA8FA93241 (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m9C6C41648ADC7B60E8AF51190EEA7BAA8FA93241_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Object>>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1536DF98255D34522AB9DC5D47835095718FF3DA (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1536DF98255D34522AB9DC5D47835095718FF3DA_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Resources.ResourceLocator>>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m41F1B4440445674E22696F369E1BE49F6B8B7325 (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m41F1B4440445674E22696F369E1BE49F6B8B7325_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Resources.ResourceLocator>>::Dispose()
inline void InternalEnumerator_1_Dispose_mEEFF36A65ACDF8534CC4A049CF142B6757C1BC98 (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mEEFF36A65ACDF8534CC4A049CF142B6757C1BC98_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Resources.ResourceLocator>>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m1CCFAA43E5AEFCE61B8B581971072C0CE3D847C7 (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m1CCFAA43E5AEFCE61B8B581971072C0CE3D847C7_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Resources.ResourceLocator>>::get_Current()
inline Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D InternalEnumerator_1_get_Current_m3B5BD0D9A3A2B90B762F783677926F8ED30B67C1 (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method)
{
return (( Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D (*) (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m3B5BD0D9A3A2B90B762F783677926F8ED30B67C1_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m07F10BD620954A735C3091217347BBD9B523B1CB (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m07F10BD620954A735C3091217347BBD9B523B1CB_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2A449599FC893C43B822B70233F3E79FD26F6959 (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2A449599FC893C43B822B70233F3E79FD26F6959_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.UInt64,System.Object>>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m0BD0412D0302697F86E43B6F22BB445661F64C8F (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m0BD0412D0302697F86E43B6F22BB445661F64C8F_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.UInt64,System.Object>>::Dispose()
inline void InternalEnumerator_1_Dispose_m63B89FFEB305B542ABA20AD4FA3B515603DF2F56 (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m63B89FFEB305B542ABA20AD4FA3B515603DF2F56_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.UInt64,System.Object>>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m4462B2E5033D638D7F461862D3245ADC40CB5FFB (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m4462B2E5033D638D7F461862D3245ADC40CB5FFB_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.UInt64,System.Object>>::get_Current()
inline Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29 InternalEnumerator_1_get_Current_m902312010187A018147C6FDDC77113E4B125EC6C (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method)
{
return (( Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29 (*) (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m902312010187A018147C6FDDC77113E4B125EC6C_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.UInt64,System.Object>>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mAB47E5373DD3C694D393ECB5B841B38C1A908386 (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mAB47E5373DD3C694D393ECB5B841B38C1A908386_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.Dictionary`2/Entry<System.UInt64,System.Object>>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCC02E335DAEB2C190189E5DA6C80C283CFF68D13 (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCC02E335DAEB2C190189E5DA6C80C283CFF68D13_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.HashSet`1/Slot<System.Object>>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m2047B6F070C9C5C4D9EF6147976F1ED4E28AF602 (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m2047B6F070C9C5C4D9EF6147976F1ED4E28AF602_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.HashSet`1/Slot<System.Object>>::Dispose()
inline void InternalEnumerator_1_Dispose_m08900DA592D66440E18F7945EAD98B17C6C62404 (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m08900DA592D66440E18F7945EAD98B17C6C62404_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.HashSet`1/Slot<System.Object>>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mB8FCAF454999038E9D103E26E7DE8D471D680DE9 (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mB8FCAF454999038E9D103E26E7DE8D471D680DE9_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.HashSet`1/Slot<System.Object>>::get_Current()
inline Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279 InternalEnumerator_1_get_Current_m219A6F6D4C2AEE8F86D69E8CED72AB8566CECBFA (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method)
{
return (( Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279 (*) (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m219A6F6D4C2AEE8F86D69E8CED72AB8566CECBFA_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.HashSet`1/Slot<System.Object>>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m118A29F1EAB9A121242D65B79DCF0199A9640C5B (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m118A29F1EAB9A121242D65B79DCF0199A9640C5B_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.HashSet`1/Slot<System.Object>>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2370D94B162CCB9AE9DE2667E298F002FBBDDEB7 (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2370D94B162CCB9AE9DE2667E298F002FBBDDEB7_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mEE2C570D5E7E5426D066B223014819C8AF52C81C (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mEE2C570D5E7E5426D066B223014819C8AF52C81C_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::Dispose()
inline void InternalEnumerator_1_Dispose_mF13B6674061D28A1BEC4861C9DEC3C64227EC93D (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mF13B6674061D28A1BEC4861C9DEC3C64227EC93D_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m4F549A52CFE9F1740D8C1B6F9560C3F199F4A748 (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m4F549A52CFE9F1740D8C1B6F9560C3F199F4A748_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::get_Current()
inline KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B InternalEnumerator_1_get_Current_m5C45B04B93E24CF93F54B15DA1E0A4E5FB0D4F77 (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method)
{
return (( KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B (*) (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m5C45B04B93E24CF93F54B15DA1E0A4E5FB0D4F77_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDCDCABB85F4DCAFD112EBF0FAE0C6961DBFE301D (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDCDCABB85F4DCAFD112EBF0FAE0C6961DBFE301D_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m99CA89EB79E57A9759F9A03DF4D0B26DC43E553A (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m99CA89EB79E57A9759F9A03DF4D0B26DC43E553A_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m52BE8429C80228377F2B44CF929F869A7B3EB7FB (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m52BE8429C80228377F2B44CF929F869A7B3EB7FB_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::Dispose()
inline void InternalEnumerator_1_Dispose_mBE1CDE7FA444201BDA464FFC7DE46B39E8099762 (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mBE1CDE7FA444201BDA464FFC7DE46B39E8099762_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mF88FE72FCC8D35935014046A828E263C0B07857E (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mF88FE72FCC8D35935014046A828E263C0B07857E_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::get_Current()
inline KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937 InternalEnumerator_1_get_Current_mD3C6FDF318DBC20B66E7B62496085159512C8FB5 (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method)
{
return (( KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937 (*) (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mD3C6FDF318DBC20B66E7B62496085159512C8FB5_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mF5166C405A731BC27FEB654DAACAB8BFF8111CBF (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mF5166C405A731BC27FEB654DAACAB8BFF8111CBF_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mA4A313B9A3753AFFF14915F1CC2C85E78C25BAD7 (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mA4A313B9A3753AFFF14915F1CC2C85E78C25BAD7_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m242214F003D15A119A0C04FFE652998D8FE41522 (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m242214F003D15A119A0C04FFE652998D8FE41522_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::Dispose()
inline void InternalEnumerator_1_Dispose_m5E91FF0A6E2EF0B84CB4158ECB1F8B4A6455CF23 (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m5E91FF0A6E2EF0B84CB4158ECB1F8B4A6455CF23_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mE4B207058D201EB5E54D576C57360ED5A09C2BE8 (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mE4B207058D201EB5E54D576C57360ED5A09C2BE8_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::get_Current()
inline KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78 InternalEnumerator_1_get_Current_m0577F355E2082ACD4D2A5281A5D618D2BAEB018C (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method)
{
return (( KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78 (*) (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m0577F355E2082ACD4D2A5281A5D618D2BAEB018C_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mF9EE0D0E138FD359A2F13C49636ACD60C723415C (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mF9EE0D0E138FD359A2F13C49636ACD60C723415C_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m43DAB8F8C87A0B6E511C39045473A42294BE62CA (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m43DAB8F8C87A0B6E511C39045473A42294BE62CA_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m61F868D64FD5C0E79726859694754B78C3A12F13 (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m61F868D64FD5C0E79726859694754B78C3A12F13_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::Dispose()
inline void InternalEnumerator_1_Dispose_m1BF7479D1C81DB164169EA2E67489072EFAEDB8D (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m1BF7479D1C81DB164169EA2E67489072EFAEDB8D_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m70A36FB83C5C0D46465928D98C613AC06DC4555F (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m70A36FB83C5C0D46465928D98C613AC06DC4555F_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::get_Current()
inline KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE InternalEnumerator_1_get_Current_mB446FB579A0D2052E3021D345FBA2E7BD1E2D8E7 (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method)
{
return (( KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE (*) (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mB446FB579A0D2052E3021D345FBA2E7BD1E2D8E7_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m19A49279822B4D3317DE80D741A23A1FFBC4AA8D (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m19A49279822B4D3317DE80D741A23A1FFBC4AA8D_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mF99F2E94E6B96C25D18AD365535F6596F6A8976D (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mF99F2E94E6B96C25D18AD365535F6596F6A8976D_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m68CFC035FC3DC1BD21D1ACB9580D1852CC49FF51 (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m68CFC035FC3DC1BD21D1ACB9580D1852CC49FF51_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::Dispose()
inline void InternalEnumerator_1_Dispose_mDCA828D764CBB14FB3CF31AF0BDC68709FA4DAE7 (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mDCA828D764CBB14FB3CF31AF0BDC68709FA4DAE7_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m9B1CF619F7F4E40343409851A9C45D5E2CB9347D (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m9B1CF619F7F4E40343409851A9C45D5E2CB9347D_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::get_Current()
inline KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E InternalEnumerator_1_get_Current_mF0C51E221CD4A4E7C605483AF49C78902866C3C5 (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method)
{
return (( KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E (*) (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mF0C51E221CD4A4E7C605483AF49C78902866C3C5_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mB8AA11D403DCF5974D63F330E5390A13F2521A2B (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mB8AA11D403DCF5974D63F330E5390A13F2521A2B_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9646270AE8A4EB0758936B3CB5A0530524ADFB4C (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9646270AE8A4EB0758936B3CB5A0530524ADFB4C_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m5207FBDBFFFA3362A79214E0F6563073D0739B36 (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m5207FBDBFFFA3362A79214E0F6563073D0739B36_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::Dispose()
inline void InternalEnumerator_1_Dispose_m5D695D1842FAD0CF7E2626EE58BE25188594A063 (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m5D695D1842FAD0CF7E2626EE58BE25188594A063_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mFA644183525E4E7C1DA9E0AB2520DEC0664DB22E (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mFA644183525E4E7C1DA9E0AB2520DEC0664DB22E_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::get_Current()
inline KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE InternalEnumerator_1_get_Current_m8BCE8ACA1FB9184338A431ADF16C9ADEF01FE5A5 (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method)
{
return (( KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE (*) (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m8BCE8ACA1FB9184338A431ADF16C9ADEF01FE5A5_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDEA574E3825E771EA4138A2FDBA795680D2D6DDF (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDEA574E3825E771EA4138A2FDBA795680D2D6DDF_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8F15A6CF9D2375039F3A2922EC07A6F66A911D2E (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8F15A6CF9D2375039F3A2922EC07A6F66A911D2E_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m9F3DE26BFE9BF17F177A5DC956AADC3AEC5A7729 (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m9F3DE26BFE9BF17F177A5DC956AADC3AEC5A7729_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::Dispose()
inline void InternalEnumerator_1_Dispose_mEA3762DB58F8733CC8196C00787BFB4B1D1BBBFC (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mEA3762DB58F8733CC8196C00787BFB4B1D1BBBFC_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m4BECF4142A35A113A6B4932DB906E425F6209742 (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m4BECF4142A35A113A6B4932DB906E425F6209742_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::get_Current()
inline KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6 InternalEnumerator_1_get_Current_m52F1F50D102498BDAA3DC236872E47AB913F5B5D (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method)
{
return (( KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6 (*) (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m52F1F50D102498BDAA3DC236872E47AB913F5B5D_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mB8257FAF3E914823A81665B44108DBB6FF6E676B (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mB8257FAF3E914823A81665B44108DBB6FF6E676B_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCB16D07C75263BD2D00943720593924E2548EC08 (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCB16D07C75263BD2D00943720593924E2548EC08_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m1A7199B93AA095B50B5B5434C225D227E5F5BB93 (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m1A7199B93AA095B50B5B5434C225D227E5F5BB93_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::Dispose()
inline void InternalEnumerator_1_Dispose_m9741A20915B57ACCEE417A751E7DD64FFFC93BE6 (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m9741A20915B57ACCEE417A751E7DD64FFFC93BE6_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mD78BC91300561B9802E9F3D57821D903E75298B3 (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mD78BC91300561B9802E9F3D57821D903E75298B3_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::get_Current()
inline KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4 InternalEnumerator_1_get_Current_m588A1C9004B72DEF16E5D6EEEE07D34F994B5E5B (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method)
{
return (( KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4 (*) (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m588A1C9004B72DEF16E5D6EEEE07D34F994B5E5B_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m63EE71FC9ACD0C91B910C5FDC9CDD975807B70B9 (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m63EE71FC9ACD0C91B910C5FDC9CDD975807B70B9_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB59C149FC8EAA87F79922094A6EF1354971B0A20 (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB59C149FC8EAA87F79922094A6EF1354971B0A20_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Hashtable/bucket>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m5E660A4E0C016C0CA6AE7EA86BC146FAA02B10BF (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m5E660A4E0C016C0CA6AE7EA86BC146FAA02B10BF_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Hashtable/bucket>::Dispose()
inline void InternalEnumerator_1_Dispose_mE1E9392D5C112D0793D3217A5DA839CDA30E42AE (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mE1E9392D5C112D0793D3217A5DA839CDA30E42AE_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Hashtable/bucket>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m1BDC4F1B539642F68851541B59BE304AC3EACE73 (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m1BDC4F1B539642F68851541B59BE304AC3EACE73_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Collections.Hashtable/bucket>::get_Current()
inline bucket_t1C848488DF65838689F7773D46F9E7E8C881B083 InternalEnumerator_1_get_Current_mDBE1EC33C2BD728CBA191BA48B16AFD2BCE81F6D (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method)
{
return (( bucket_t1C848488DF65838689F7773D46F9E7E8C881B083 (*) (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mDBE1EC33C2BD728CBA191BA48B16AFD2BCE81F6D_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Hashtable/bucket>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6BEEA4996FE2FAD1230E143C6C160BD2811C445B (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6BEEA4996FE2FAD1230E143C6C160BD2811C445B_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Hashtable/bucket>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m898C99F1A17C87AE5BB8AE238571C8D449A9C8A1 (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m898C99F1A17C87AE5BB8AE238571C8D449A9C8A1_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.DateTime>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m38FF15007E4EC72548A334D194D158343AA99CC7 (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m38FF15007E4EC72548A334D194D158343AA99CC7_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.DateTime>::Dispose()
inline void InternalEnumerator_1_Dispose_m706D65100CBE250B47E0D87A75E13164F9CAB601 (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m706D65100CBE250B47E0D87A75E13164F9CAB601_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.DateTime>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mAD2E5315BA13D08E0B7FEBC36D5C029DCD48A00B (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mAD2E5315BA13D08E0B7FEBC36D5C029DCD48A00B_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.DateTime>::get_Current()
inline DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 InternalEnumerator_1_get_Current_mC41E15442C38B131C7AD1E88876963F01A4868CB (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method)
{
return (( DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 (*) (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mC41E15442C38B131C7AD1E88876963F01A4868CB_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.DateTime>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m99164482C6858CCA3B028445F1A836FED67A353B (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m99164482C6858CCA3B028445F1A836FED67A353B_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.DateTime>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1668301F0BFBFB089DAFB2BCF55CFD464CC218C2 (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1668301F0BFBFB089DAFB2BCF55CFD464CC218C2_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Decimal>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m9FA8DEA90071FEC73528075A9F1100D76CDE99D5 (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m9FA8DEA90071FEC73528075A9F1100D76CDE99D5_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Decimal>::Dispose()
inline void InternalEnumerator_1_Dispose_m2CDB317CD290A3CF69F8CFFB4740A174FBCB4957 (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m2CDB317CD290A3CF69F8CFFB4740A174FBCB4957_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Decimal>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m8BFF576A59DF1CA270FBA8F1ED3FC4F57A491229 (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m8BFF576A59DF1CA270FBA8F1ED3FC4F57A491229_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Decimal>::get_Current()
inline Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 InternalEnumerator_1_get_Current_mB1B90708ED55CB1E651BF9E5FA629B28E8E5977A (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method)
{
return (( Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 (*) (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mB1B90708ED55CB1E651BF9E5FA629B28E8E5977A_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Decimal>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mE109263B389473C6F2F6821A32E6273D52722A5D (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mE109263B389473C6F2F6821A32E6273D52722A5D_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Decimal>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mBF9B03E2327F706D52248C6F35FCAD49FB6C2F98 (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mBF9B03E2327F706D52248C6F35FCAD49FB6C2F98_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider/SessionInfo>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mDDF607BB20488A6FA7CA084A5224268E0338C52C (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mDDF607BB20488A6FA7CA084A5224268E0338C52C_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider/SessionInfo>::Dispose()
inline void InternalEnumerator_1_Dispose_mADC6EE407FA72D81123E076FBBFF257865478FF1 (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mADC6EE407FA72D81123E076FBBFF257865478FF1_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider/SessionInfo>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m3652AD403099B49406A1E024990598169861FC38 (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m3652AD403099B49406A1E024990598169861FC38_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider/SessionInfo>::get_Current()
inline SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A InternalEnumerator_1_get_Current_m868993F9E581D2FDE89D311B0D0E7F043B5526EE (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method)
{
return (( SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A (*) (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m868993F9E581D2FDE89D311B0D0E7F043B5526EE_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider/SessionInfo>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m0A1DEAFFFA545BF34F3B2B8B5C4ABBD0D762860F (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m0A1DEAFFFA545BF34F3B2B8B5C4ABBD0D762860F_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider/SessionInfo>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB3B98E6648B86023BBCBA7071A37A9DF18C899BF (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB3B98E6648B86023BBCBA7071A37A9DF18C899BF_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventSource/EventMetadata>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m70FD5955510D3C8C60F9432DC1576FEA4BF298D6 (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m70FD5955510D3C8C60F9432DC1576FEA4BF298D6_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventSource/EventMetadata>::Dispose()
inline void InternalEnumerator_1_Dispose_m068CDEACC21774C02CAE19D8DA4DD58BA70A77FA (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m068CDEACC21774C02CAE19D8DA4DD58BA70A77FA_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventSource/EventMetadata>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mF47AB1403AEA819AC6C6F83E75A8E6B630274601 (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mF47AB1403AEA819AC6C6F83E75A8E6B630274601_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventSource/EventMetadata>::get_Current()
inline EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B InternalEnumerator_1_get_Current_m209A56D6C53AC134B236FD1E3808E42C2DA0F378 (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method)
{
return (( EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B (*) (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m209A56D6C53AC134B236FD1E3808E42C2DA0F378_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventSource/EventMetadata>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mEDDD49DFA18C451495C8E8128854D370181D0C12 (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mEDDD49DFA18C451495C8E8128854D370181D0C12_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Diagnostics.Tracing.EventSource/EventMetadata>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mA1E541F561DF486D84527601ABB2404DD6501DA3 (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mA1E541F561DF486D84527601ABB2404DD6501DA3_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Double>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m2EB3647F564935D58525C6BF0F365C22D0F86EEF (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m2EB3647F564935D58525C6BF0F365C22D0F86EEF_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Double>::Dispose()
inline void InternalEnumerator_1_Dispose_m897B005D5C7B05B9946D2CA717A24D642DC3B692 (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m897B005D5C7B05B9946D2CA717A24D642DC3B692_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Double>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mC78350B2B7286550FF3DCEA2105FAF745425F5F6 (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mC78350B2B7286550FF3DCEA2105FAF745425F5F6_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Double>::get_Current()
inline double InternalEnumerator_1_get_Current_m4CF2B380D638F22E5C70B4E41F35AD95FB71FE26 (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method)
{
return (( double (*) (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m4CF2B380D638F22E5C70B4E41F35AD95FB71FE26_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Double>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m2E70BDAD683DCC0CBD56FF1B3F1C1DC7B86565A3 (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m2E70BDAD683DCC0CBD56FF1B3F1C1DC7B86565A3_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Double>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2E95A3A4607ED179D9FE2D702C7E6109ACF36269 (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2E95A3A4607ED179D9FE2D702C7E6109ACF36269_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m99BBAA2F747C901A1EAED9DD8F28837B642E16D9 (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m99BBAA2F747C901A1EAED9DD8F28837B642E16D9_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::Dispose()
inline void InternalEnumerator_1_Dispose_m190F2C8765ECDC1A19A67DEE686CDAE334DD238F (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m190F2C8765ECDC1A19A67DEE686CDAE334DD238F_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m5874180E5D0BF8559989E93AD753745463CCE784 (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m5874180E5D0BF8559989E93AD753745463CCE784_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::get_Current()
inline InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4 InternalEnumerator_1_get_Current_m5E3D89E57206E983F95400F30010E1922D7E1A1C (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method)
{
return (( InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4 (*) (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m5E3D89E57206E983F95400F30010E1922D7E1A1C_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mAC88F8333D9BC850EB955235E4FF7B49A2EB9ADA (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mAC88F8333D9BC850EB955235E4FF7B49A2EB9ADA_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mADD52706A60B65EF430A9A8361D76CE2FB08FBF4 (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mADD52706A60B65EF430A9A8361D76CE2FB08FBF4_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mC0268A706CA7F19506CC886359704ED873A74811 (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mC0268A706CA7F19506CC886359704ED873A74811_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::Dispose()
inline void InternalEnumerator_1_Dispose_m829CDAF898E571D63C974F1031E986662BE6A7B4 (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m829CDAF898E571D63C974F1031E986662BE6A7B4_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mA4049184F49FCF2BB8D8164C53BC2F9A98DE1528 (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mA4049184F49FCF2BB8D8164C53BC2F9A98DE1528_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::get_Current()
inline InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211 InternalEnumerator_1_get_Current_m7CE9128839CB0EC4AF3B0BAF875A178ED4EA9E42 (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method)
{
return (( InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211 (*) (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m7CE9128839CB0EC4AF3B0BAF875A178ED4EA9E42_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m9B5A4FBEB36F25AB04EC9A082999D3C5C960F2B2 (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m9B5A4FBEB36F25AB04EC9A082999D3C5C960F2B2_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0864F6C06C70CAE51CC7A38AA55CCF704BB674A8 (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0864F6C06C70CAE51CC7A38AA55CCF704BB674A8_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Guid>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m9903677C8275AC12400E4CF7DD8F9CA715E93EF7 (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m9903677C8275AC12400E4CF7DD8F9CA715E93EF7_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Guid>::Dispose()
inline void InternalEnumerator_1_Dispose_mD354E2C453E6A047D967B2B456259FF544320E3B (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mD354E2C453E6A047D967B2B456259FF544320E3B_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Guid>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mE7E1CD869291B4E596B1A67E0863CC7D6F4D7186 (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mE7E1CD869291B4E596B1A67E0863CC7D6F4D7186_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Guid>::get_Current()
inline Guid_t InternalEnumerator_1_get_Current_m654F712F9682ADAE03DA5A38B8EA05099AB77864 (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method)
{
return (( Guid_t (*) (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m654F712F9682ADAE03DA5A38B8EA05099AB77864_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Guid>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mCC1FF18F89CE70BE3D2AD5ED3FEE3E244F2885C5 (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mCC1FF18F89CE70BE3D2AD5ED3FEE3E244F2885C5_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Guid>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m99DD87F3BFD258C3366BA0846CA059840BA2D0CE (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m99DD87F3BFD258C3366BA0846CA059840BA2D0CE_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Int16>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m8EE54AB2215933CFD3514ACDD75A87A8BE8B60AE (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m8EE54AB2215933CFD3514ACDD75A87A8BE8B60AE_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Int16>::Dispose()
inline void InternalEnumerator_1_Dispose_m3C2D5CADD976B0AD79CDC5BBE3EACFA5E1EAEC14 (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m3C2D5CADD976B0AD79CDC5BBE3EACFA5E1EAEC14_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Int16>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m454457EA339027D7DAE0DD53FF1EA7C34A6CD7EE (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m454457EA339027D7DAE0DD53FF1EA7C34A6CD7EE_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Int16>::get_Current()
inline int16_t InternalEnumerator_1_get_Current_mFFD60C69E1F8CF93C20492F2A58FBC09CEB6188F (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method)
{
return (( int16_t (*) (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mFFD60C69E1F8CF93C20492F2A58FBC09CEB6188F_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Int16>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA81C0DBCEBF6CFD70EC6FD73CD4F84CE65DDB260 (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA81C0DBCEBF6CFD70EC6FD73CD4F84CE65DDB260_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Int16>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m51CF0FAA9202E3C70397E473B6F312B1977D0861 (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m51CF0FAA9202E3C70397E473B6F312B1977D0861_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Int32>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mFD68B921CD29713A2BEB038318C202A9E4E9B5CE (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mFD68B921CD29713A2BEB038318C202A9E4E9B5CE_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Int32>::Dispose()
inline void InternalEnumerator_1_Dispose_mBFEAB58E625616898F0E0ED1A11935920DD0A34E (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mBFEAB58E625616898F0E0ED1A11935920DD0A34E_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Int32>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mEABDC1E82F7AAE1B3B6DE2F40F0B7FDE199312C3 (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mEABDC1E82F7AAE1B3B6DE2F40F0B7FDE199312C3_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Int32>::get_Current()
inline int32_t InternalEnumerator_1_get_Current_m70AA9F95B052891AAD4AB638CA09537554ABE683 (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method)
{
return (( int32_t (*) (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m70AA9F95B052891AAD4AB638CA09537554ABE683_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Int32>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5215F161D6643BFA30010228E401FFA587630F25 (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5215F161D6643BFA30010228E401FFA587630F25_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Int32>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m95E1A22E55B29BD2BE8001BDB1E13CC3DE23A2D7 (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m95E1A22E55B29BD2BE8001BDB1E13CC3DE23A2D7_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Int32Enum>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mBF8E58BAA9971C4074B8EEC028434A1BAEB0748F (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mBF8E58BAA9971C4074B8EEC028434A1BAEB0748F_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Int32Enum>::Dispose()
inline void InternalEnumerator_1_Dispose_m4A6D2508A0C1EFE6CB0DDCCA0057F8EC22168204 (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m4A6D2508A0C1EFE6CB0DDCCA0057F8EC22168204_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Int32Enum>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mDD38EA99C85E3EE7271D7786026B1523054CC257 (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mDD38EA99C85E3EE7271D7786026B1523054CC257_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Int32Enum>::get_Current()
inline int32_t InternalEnumerator_1_get_Current_m079C9B7D950F47EBDDE3290AF721C64568541238 (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method)
{
return (( int32_t (*) (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m079C9B7D950F47EBDDE3290AF721C64568541238_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Int32Enum>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mEA4ADBA1D47E80688B0470DF0C297444612C7311 (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mEA4ADBA1D47E80688B0470DF0C297444612C7311_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Int32Enum>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC2955E66B742022B3C37F449E2DAFDA6CED420C0 (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC2955E66B742022B3C37F449E2DAFDA6CED420C0_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Int64>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m68F9020151CD964322723D3C02977C30EA0F189E (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m68F9020151CD964322723D3C02977C30EA0F189E_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Int64>::Dispose()
inline void InternalEnumerator_1_Dispose_mD7021BD3B9CF1E4B5A10D78E753CDB276A8631AD (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mD7021BD3B9CF1E4B5A10D78E753CDB276A8631AD_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Int64>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m3921385986D9A6472FAAAD1EEFBB0AFBEE0A98AE (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m3921385986D9A6472FAAAD1EEFBB0AFBEE0A98AE_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Int64>::get_Current()
inline int64_t InternalEnumerator_1_get_Current_m9A73AB58D1A8BE0B72C490559F3DB7A1A8194174 (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method)
{
return (( int64_t (*) (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m9A73AB58D1A8BE0B72C490559F3DB7A1A8194174_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Int64>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC3C01ADBFB01FCDD97526280A73422955CA7898F (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC3C01ADBFB01FCDD97526280A73422955CA7898F_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Int64>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m7CDD9680E17A3B80D1D3332A68A89353FFAA0D87 (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m7CDD9680E17A3B80D1D3332A68A89353FFAA0D87_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.IntPtr>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mCC5889C0F1785F416EB4E3EB0EE4BE48D0A055C8 (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mCC5889C0F1785F416EB4E3EB0EE4BE48D0A055C8_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.IntPtr>::Dispose()
inline void InternalEnumerator_1_Dispose_m2404F9B209B37D0B37621E1D7FB27D3E7C105719 (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m2404F9B209B37D0B37621E1D7FB27D3E7C105719_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.IntPtr>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mF114574B4163E7D82DCB1FD35E3AF796F8F1A868 (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mF114574B4163E7D82DCB1FD35E3AF796F8F1A868_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.IntPtr>::get_Current()
inline intptr_t InternalEnumerator_1_get_Current_m94C0D13214FB1EC791B1CC5DFE5A82E2AAE63406 (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method)
{
return (( intptr_t (*) (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m94C0D13214FB1EC791B1CC5DFE5A82E2AAE63406_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.IntPtr>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m491E05099AFA8FC0AED0F826973AF0A2565B1E9B (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m491E05099AFA8FC0AED0F826973AF0A2565B1E9B_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.IntPtr>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m87769ABA238DC3B1539ABAEFB4A723EDB7F0DF9C (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m87769ABA238DC3B1539ABAEFB4A723EDB7F0DF9C_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Object>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mD75F701A17A7159EEF2877D9FE74845402AC4201 (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mD75F701A17A7159EEF2877D9FE74845402AC4201_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Object>::Dispose()
inline void InternalEnumerator_1_Dispose_m8EAB86BD597ACADB2C2CACC4EE1C95C2AF4B7FE0 (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m8EAB86BD597ACADB2C2CACC4EE1C95C2AF4B7FE0_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Object>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m940227577EE2352E678C755A533CD684708D464C (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m940227577EE2352E678C755A533CD684708D464C_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Object>::get_Current()
inline RuntimeObject * InternalEnumerator_1_get_Current_m4CE05D9509A3134EAC31E8340F36EC2B4B54703F (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m4CE05D9509A3134EAC31E8340F36EC2B4B54703F_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Object>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m7BC7629BA183FA12CC79E5271FB346EC4F200C4D (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m7BC7629BA183FA12CC79E5271FB346EC4F200C4D_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Object>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0A567B403B179EFB6D4D15CF7700244CB66E5AEA (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0A567B403B179EFB6D4D15CF7700244CB66E5AEA_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.ParameterizedStrings/FormatParam>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mAEB0249C2146033E833B7EBDA3EB88B9A9F90659 (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mAEB0249C2146033E833B7EBDA3EB88B9A9F90659_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.ParameterizedStrings/FormatParam>::Dispose()
inline void InternalEnumerator_1_Dispose_m68BF57EDA1103571F0E0FE5001194B0BB8F3A78F (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m68BF57EDA1103571F0E0FE5001194B0BB8F3A78F_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.ParameterizedStrings/FormatParam>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mD624D66316245A1A440D7492A5A3C940E1FA3EFC (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mD624D66316245A1A440D7492A5A3C940E1FA3EFC_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.ParameterizedStrings/FormatParam>::get_Current()
inline FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800 InternalEnumerator_1_get_Current_m80B0AC143205EB914B0C033876B87B4C3B344F57 (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method)
{
return (( FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800 (*) (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m80B0AC143205EB914B0C033876B87B4C3B344F57_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.ParameterizedStrings/FormatParam>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m3485D18CB013850FA9EB78958297150717F3C5EF (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m3485D18CB013850FA9EB78958297150717F3C5EF_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.ParameterizedStrings/FormatParam>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2979F5923AFE9DF4D43A441505AFDC088D016C8E (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2979F5923AFE9DF4D43A441505AFDC088D016C8E_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m226870CF6B7D12848BF991EACF40C735345AB28B (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m226870CF6B7D12848BF991EACF40C735345AB28B_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::Dispose()
inline void InternalEnumerator_1_Dispose_m6C8EBC317B2CFAA7DA0D992C194FD95A92926413 (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m6C8EBC317B2CFAA7DA0D992C194FD95A92926413_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m0CACB620368208A8F7576489AE8CE43D3CF50ACB (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m0CACB620368208A8F7576489AE8CE43D3CF50ACB_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::get_Current()
inline CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E InternalEnumerator_1_get_Current_m1AB3F2C70645660A20831F4A4FDBB1AB61DB8420 (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method)
{
return (( CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E (*) (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m1AB3F2C70645660A20831F4A4FDBB1AB61DB8420_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC0F15D2E68613F49046B87ACA9F38FA69335EAE4 (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC0F15D2E68613F49046B87ACA9F38FA69335EAE4_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m5842A354F96DCDF6DB6E8B1A2A7FE11B12912965 (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m5842A354F96DCDF6DB6E8B1A2A7FE11B12912965_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m5FF7EDC8E7C9A9250B548F9C9EB5CF3360E889FB (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m5FF7EDC8E7C9A9250B548F9C9EB5CF3360E889FB_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::Dispose()
inline void InternalEnumerator_1_Dispose_m4EF1DF22F31CAA58E4F6DD4B579E722157C60B68 (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m4EF1DF22F31CAA58E4F6DD4B579E722157C60B68_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mB92131A3838FF515C4E84AFEE0EFBBB0D9CEE12D (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mB92131A3838FF515C4E84AFEE0EFBBB0D9CEE12D_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::get_Current()
inline CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 InternalEnumerator_1_get_Current_m3D123B39BCDA4F165484915F8DD3940962AECBF0 (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method)
{
return (( CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 (*) (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m3D123B39BCDA4F165484915F8DD3940962AECBF0_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m55E5E22BB6ECFA78AD2DA166F453D831C80A0454 (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m55E5E22BB6ECFA78AD2DA166F453D831C80A0454_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m24102447F4216E92F9D6C5449EFA7C4D0303B3A0 (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m24102447F4216E92F9D6C5449EFA7C4D0303B3A0_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.ParameterModifier>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mDEBB2C6716C9789C8928EC4E44AF6AAB5C270D3C (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mDEBB2C6716C9789C8928EC4E44AF6AAB5C270D3C_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.ParameterModifier>::Dispose()
inline void InternalEnumerator_1_Dispose_m0E64CEABEE646480E8568420A7019690D7649941 (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m0E64CEABEE646480E8568420A7019690D7649941_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Reflection.ParameterModifier>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m730B50E3F1654202F07EA4CF4B79E444DA499268 (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m730B50E3F1654202F07EA4CF4B79E444DA499268_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Reflection.ParameterModifier>::get_Current()
inline ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E InternalEnumerator_1_get_Current_m81C0B3258A94D63BA8AF4BE1C02FC30E77BCA1C4 (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method)
{
return (( ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E (*) (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m81C0B3258A94D63BA8AF4BE1C02FC30E77BCA1C4_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.ParameterModifier>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m77F8981C0DA5CA0ED4BBF6CA038792DC61AA2B07 (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m77F8981C0DA5CA0ED4BBF6CA038792DC61AA2B07_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Reflection.ParameterModifier>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCD8241095A16E48C02661D5E39C42E18D7F8AD5B (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCD8241095A16E48C02661D5E39C42E18D7F8AD5B_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Resources.ResourceLocator>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m3E014CF0DDF2BDBCED19F196342255153BDBA51E (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m3E014CF0DDF2BDBCED19F196342255153BDBA51E_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Resources.ResourceLocator>::Dispose()
inline void InternalEnumerator_1_Dispose_m52FBDFDBF43E58009C49B5F1C21DE59215820C75 (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m52FBDFDBF43E58009C49B5F1C21DE59215820C75_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Resources.ResourceLocator>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mD4C121CEDFFEFB31C6EC9302CBC1192E51F2093A (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mD4C121CEDFFEFB31C6EC9302CBC1192E51F2093A_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Resources.ResourceLocator>::get_Current()
inline ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C InternalEnumerator_1_get_Current_m5474D37CD91A506826F57EEEA5BA8900CC2A212D (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method)
{
return (( ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C (*) (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m5474D37CD91A506826F57EEEA5BA8900CC2A212D_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Resources.ResourceLocator>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA76FFEF1093C75431297838B18FFBF048A4CB917 (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA76FFEF1093C75431297838B18FFBF048A4CB917_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Resources.ResourceLocator>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6D49286C74B3A35243C731877CCE06A79725DCF9 (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6D49286C74B3A35243C731877CCE06A79725DCF9_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m9E14CFB1C79CC7C9D79DD72B62C9B0F353F8BAB4 (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m9E14CFB1C79CC7C9D79DD72B62C9B0F353F8BAB4_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::Dispose()
inline void InternalEnumerator_1_Dispose_m969B47D66A78D205B0B3A1CA537C3A9FBCB6EC5D (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m969B47D66A78D205B0B3A1CA537C3A9FBCB6EC5D_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m1CD5357A6497F1DB261EA284D09EC306D38ADF48 (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m1CD5357A6497F1DB261EA284D09EC306D38ADF48_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::get_Current()
inline Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA InternalEnumerator_1_get_Current_mCFB8564C9D825B393AABF73A69BAE8E986796895 (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method)
{
return (( Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA (*) (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mCFB8564C9D825B393AABF73A69BAE8E986796895_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m29C2E6DA559A8EBC643267E932846423DBDA5858 (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m29C2E6DA559A8EBC643267E932846423DBDA5858_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0CBEFE2675B461D8C9459F86D1554C6C4E1F80D0 (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0CBEFE2675B461D8C9459F86D1554C6C4E1F80D0_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mA819F7E05D294E7B7E037030EB0FD992FB346FC6 (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mA819F7E05D294E7B7E037030EB0FD992FB346FC6_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::Dispose()
inline void InternalEnumerator_1_Dispose_mD4D3F12484F4B6379333FAC08508D39808224D91 (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mD4D3F12484F4B6379333FAC08508D39808224D91_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mA2DBBC0E980B2978432B2B220B1189909B91F03F (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mA2DBBC0E980B2978432B2B220B1189909B91F03F_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::get_Current()
inline GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 InternalEnumerator_1_get_Current_m95BBA6E2E51E7EFE7672D9D8A78D29B9FFDFEAEE (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method)
{
return (( GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 (*) (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m95BBA6E2E51E7EFE7672D9D8A78D29B9FFDFEAEE_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC0579D55B4A9F531AF1351053125A484DB0095F7 (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC0579D55B4A9F531AF1351053125A484DB0095F7_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8AD84D9CB10EB751A7052B86C5316EBB2BF7717A (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8AD84D9CB10EB751A7052B86C5316EBB2BF7717A_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.SByte>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mE9379D2FF2800845F39295ECC82CC75C1BFAD2A2 (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mE9379D2FF2800845F39295ECC82CC75C1BFAD2A2_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.SByte>::Dispose()
inline void InternalEnumerator_1_Dispose_m05749D31B7EEEF1517775595FCB5BDD0873722C1 (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m05749D31B7EEEF1517775595FCB5BDD0873722C1_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.SByte>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m7A514CDCE03B1914EA0CC2EC436A9BDB88026FA7 (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m7A514CDCE03B1914EA0CC2EC436A9BDB88026FA7_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.SByte>::get_Current()
inline int8_t InternalEnumerator_1_get_Current_mCEBACD4CF4D2DF7FDB7FF8031CCE8725B75DA540 (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method)
{
return (( int8_t (*) (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mCEBACD4CF4D2DF7FDB7FF8031CCE8725B75DA540_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.SByte>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6B6DFDBA279C13F9F632240CF4F9CEEF91DB0530 (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6B6DFDBA279C13F9F632240CF4F9CEEF91DB0530_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.SByte>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m003EC0581DCE444D5CFBFF92BEF7664C66963B76 (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m003EC0581DCE444D5CFBFF92BEF7664C66963B76_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Single>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mAA128A1D51031DF02D178B5C5A7316CC7D6C22BE (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mAA128A1D51031DF02D178B5C5A7316CC7D6C22BE_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Single>::Dispose()
inline void InternalEnumerator_1_Dispose_m88C5741AF3B1D2EA397DB46512535BC34C871D3C (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m88C5741AF3B1D2EA397DB46512535BC34C871D3C_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Single>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m61CFF397E0E8740BC9F65E736C1507C05D8FCF32 (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m61CFF397E0E8740BC9F65E736C1507C05D8FCF32_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Single>::get_Current()
inline float InternalEnumerator_1_get_Current_m8C4CCAC66EBAE129B0DCCA46A73041A2B0F3B999 (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method)
{
return (( float (*) (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m8C4CCAC66EBAE129B0DCCA46A73041A2B0F3B999_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Single>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5F8FEAC529452CDE3CAF154E65C3F0E8B7EDD6C6 (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5F8FEAC529452CDE3CAF154E65C3F0E8B7EDD6C6_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Single>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m607EFC7537C7AF61B9224D93F36EDF50577EFE62 (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m607EFC7537C7AF61B9224D93F36EDF50577EFE62_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m7F748D6834D2CDDE775D0EEE50FBF11138CFF61F (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m7F748D6834D2CDDE775D0EEE50FBF11138CFF61F_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping>::Dispose()
inline void InternalEnumerator_1_Dispose_m44FBA1A533BB2AD3EDF8E6570E5E0032549BCCE1 (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m44FBA1A533BB2AD3EDF8E6570E5E0032549BCCE1_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m6E63B51D31ABC06C44F6EC10392F44AF29319A72 (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m6E63B51D31ABC06C44F6EC10392F44AF29319A72_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping>::get_Current()
inline LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B InternalEnumerator_1_get_Current_m4BFF9065A44EB1D4FB065F5709238C6489E5A0C5 (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method)
{
return (( LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B (*) (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m4BFF9065A44EB1D4FB065F5709238C6489E5A0C5_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m61DB74B19C84DF5D0586793E8AE60599FD8D9E3E (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m61DB74B19C84DF5D0586793E8AE60599FD8D9E3E_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass/LowerCaseMapping>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mAA35E609F68D4AA4808C8518DBEA1A5DC84FD2F8 (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mAA35E609F68D4AA4808C8518DBEA1A5DC84FD2F8_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m3F65E1A1CF891ED1F8E134CE2EE25E149C327F19 (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m3F65E1A1CF891ED1F8E134CE2EE25E149C327F19_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::Dispose()
inline void InternalEnumerator_1_Dispose_m39C85AF12F54B32A18A618ED54AEB5BABC90F776 (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m39C85AF12F54B32A18A618ED54AEB5BABC90F776_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m0DBCE94BE0EA9EFB33DA7667DF03CCF8F83E7585 (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m0DBCE94BE0EA9EFB33DA7667DF03CCF8F83E7585_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::get_Current()
inline CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2 InternalEnumerator_1_get_Current_m2EF8D8561F60AAA02F2B3BD2EC7176E50BCD5E52 (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method)
{
return (( CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2 (*) (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m2EF8D8561F60AAA02F2B3BD2EC7176E50BCD5E52_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mBEA53E27186A3117450CEAFB374CEB5B73313997 (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mBEA53E27186A3117450CEAFB374CEB5B73313997_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m343A40850C40793147C70F0A503FD2CB6E4CE4AE (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m343A40850C40793147C70F0A503FD2CB6E4CE4AE_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.TimeSpan>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mC1AEF444A58A2261E281DD76B188FF7538F424EA (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mC1AEF444A58A2261E281DD76B188FF7538F424EA_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.TimeSpan>::Dispose()
inline void InternalEnumerator_1_Dispose_mCD40BF3A7626144872F2642F3B34F182DA518793 (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mCD40BF3A7626144872F2642F3B34F182DA518793_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.TimeSpan>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m5ECDBB64DF2420FD59C457CFD882942454EFEC65 (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m5ECDBB64DF2420FD59C457CFD882942454EFEC65_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.TimeSpan>::get_Current()
inline TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 InternalEnumerator_1_get_Current_m08ED2C8C47D5621377FB042EFFFF6038160D427C (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method)
{
return (( TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 (*) (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m08ED2C8C47D5621377FB042EFFFF6038160D427C_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.TimeSpan>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m061C2085607EF3A620F7914BBDFABB38E2F988E5 (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m061C2085607EF3A620F7914BBDFABB38E2F988E5_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.TimeSpan>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9D8A5C3B19CDB3A2FA242A18C34301E6D95865C8 (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9D8A5C3B19CDB3A2FA242A18C34301E6D95865C8_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.UInt16>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mFE4EF7DC9B7656A8F9541C6DB174623D677CA6CD (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mFE4EF7DC9B7656A8F9541C6DB174623D677CA6CD_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.UInt16>::Dispose()
inline void InternalEnumerator_1_Dispose_mF86968B10A7E2847776ADFBF834C522CDB599961 (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mF86968B10A7E2847776ADFBF834C522CDB599961_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.UInt16>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mB8CE82E4885258C6A341B97A978720422A1E9738 (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mB8CE82E4885258C6A341B97A978720422A1E9738_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.UInt16>::get_Current()
inline uint16_t InternalEnumerator_1_get_Current_mB4EDDDE7A9FD306176CCDDC4E9693B40EF7B984B (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method)
{
return (( uint16_t (*) (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mB4EDDDE7A9FD306176CCDDC4E9693B40EF7B984B_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.UInt16>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m116599B0F101CFB030D78D7AFD984D465A4C6F83 (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m116599B0F101CFB030D78D7AFD984D465A4C6F83_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.UInt16>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1F016830E08D4370DEE1C0F0136A9F75CB608CE0 (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1F016830E08D4370DEE1C0F0136A9F75CB608CE0_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.UInt32>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m577E98213388A2A32E776481E79087B4BEC45B01 (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m577E98213388A2A32E776481E79087B4BEC45B01_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.UInt32>::Dispose()
inline void InternalEnumerator_1_Dispose_m8FF972AE2AF8D8C8EBF974D4B9CC114114E76C8B (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m8FF972AE2AF8D8C8EBF974D4B9CC114114E76C8B_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.UInt32>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m8D45F4F482D6E2899C7E9A9E11CE3A9E7390D10C (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m8D45F4F482D6E2899C7E9A9E11CE3A9E7390D10C_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.UInt32>::get_Current()
inline uint32_t InternalEnumerator_1_get_Current_m7A52D8C9B31569083E11811B585B6D3BABA3A948 (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method)
{
return (( uint32_t (*) (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m7A52D8C9B31569083E11811B585B6D3BABA3A948_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.UInt32>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mE3C9251CD4163687394B2503AEEF0E2E7EB2ECC5 (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mE3C9251CD4163687394B2503AEEF0E2E7EB2ECC5_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.UInt32>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m886F80208845CAF7BEB08CD40275D4453CA3427A (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m886F80208845CAF7BEB08CD40275D4453CA3427A_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.UInt64>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m7292D20FBAECFA8BCEA4475F6BBE6AC30075B45E (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m7292D20FBAECFA8BCEA4475F6BBE6AC30075B45E_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.UInt64>::Dispose()
inline void InternalEnumerator_1_Dispose_mD466713709A8E59C335DBE0FFF5EFA8855CE93C9 (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mD466713709A8E59C335DBE0FFF5EFA8855CE93C9_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.UInt64>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m4F5A6CEDFCDD55DFACBF1BF4FE66A19BDAA14CBF (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m4F5A6CEDFCDD55DFACBF1BF4FE66A19BDAA14CBF_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.UInt64>::get_Current()
inline uint64_t InternalEnumerator_1_get_Current_mEACBD5ABDAC498CC39F2D794C276AFCB4B23D5A6 (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method)
{
return (( uint64_t (*) (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mEACBD5ABDAC498CC39F2D794C276AFCB4B23D5A6_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.UInt64>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mED2DD8750E377B5B9B3D6C18B841712DCC6B79A7 (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mED2DD8750E377B5B9B3D6C18B841712DCC6B79A7_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.UInt64>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD46DCC366FA87AE6E061E4789BB1C74A5DA10B3B (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD46DCC366FA87AE6E061E4789BB1C74A5DA10B3B_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.UIntPtr>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mFA2C0D7C19279B4FE83F179D8BB3FE277CD6BB40 (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mFA2C0D7C19279B4FE83F179D8BB3FE277CD6BB40_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<System.UIntPtr>::Dispose()
inline void InternalEnumerator_1_Dispose_m8EB8FF6C30EC949B10E0008F0FCF5E0AEA78F6D6 (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m8EB8FF6C30EC949B10E0008F0FCF5E0AEA78F6D6_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<System.UIntPtr>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m872C83B5D2E2C798AB5482B0919DCC9EF3E0D613 (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m872C83B5D2E2C798AB5482B0919DCC9EF3E0D613_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<System.UIntPtr>::get_Current()
inline uintptr_t InternalEnumerator_1_get_Current_m898EF6FD732B94B5BA3C6CFC17B8C3897D0C5B6B (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method)
{
return (( uintptr_t (*) (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m898EF6FD732B94B5BA3C6CFC17B8C3897D0C5B6B_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<System.UIntPtr>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDF094F535B0402FBE582B4CBF3B943D5919FB798 (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDF094F535B0402FBE582B4CBF3B943D5919FB798_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<System.UIntPtr>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m868092AD29D3DEA8DFA21574DCA9D751BCD65B6C (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m868092AD29D3DEA8DFA21574DCA9D751BCD65B6C_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.BeforeRenderHelper/OrderBlock>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m0CE98768FA95BB57698E7D51B48485337983B3A6 (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m0CE98768FA95BB57698E7D51B48485337983B3A6_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.BeforeRenderHelper/OrderBlock>::Dispose()
inline void InternalEnumerator_1_Dispose_m720EC1E93AD8CBDB05BB4E9DE7B14892F51DE771 (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m720EC1E93AD8CBDB05BB4E9DE7B14892F51DE771_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.BeforeRenderHelper/OrderBlock>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mE291D66A15F236A0AF25EC165D0AB1C3322A1685 (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mE291D66A15F236A0AF25EC165D0AB1C3322A1685_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<UnityEngine.BeforeRenderHelper/OrderBlock>::get_Current()
inline OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727 InternalEnumerator_1_get_Current_mF3A24C3ABE3B152A3C3A30863E92D79103A50BA1 (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method)
{
return (( OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727 (*) (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mF3A24C3ABE3B152A3C3A30863E92D79103A50BA1_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.BeforeRenderHelper/OrderBlock>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m067658D2CA96B529EB660B05302D2CE3B39C7E1A (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m067658D2CA96B529EB660B05302D2CE3B39C7E1A_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<UnityEngine.BeforeRenderHelper/OrderBlock>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m78F6CCA9BF95D5E77745394EFA9DA416D89098C0 (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m78F6CCA9BF95D5E77745394EFA9DA416D89098C0_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Color32>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mA76CB6C92F93D4D154DEF97B62B04875E9DD0C0C (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mA76CB6C92F93D4D154DEF97B62B04875E9DD0C0C_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Color32>::Dispose()
inline void InternalEnumerator_1_Dispose_mE55774E2396C5AE20E56EC04F520945363A489B9 (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mE55774E2396C5AE20E56EC04F520945363A489B9_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.Color32>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m677EA6BD7E9DF5EE4A08D0A7A229D4F099D15B70 (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m677EA6BD7E9DF5EE4A08D0A7A229D4F099D15B70_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<UnityEngine.Color32>::get_Current()
inline Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 InternalEnumerator_1_get_Current_m80E4BACA28C64E50461E74B92DEE28DD5C49A580 (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method)
{
return (( Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 (*) (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m80E4BACA28C64E50461E74B92DEE28DD5C49A580_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Color32>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5E4EBF6B2AAA4014717EA1653979D34CEECE24CA (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5E4EBF6B2AAA4014717EA1653979D34CEECE24CA_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<UnityEngine.Color32>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mE73D1EC7DC5AEA554051C0D37A9E295058779760 (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mE73D1EC7DC5AEA554051C0D37A9E295058779760_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m2009C5E8886D700C065C716EF1D08BACA6B8087F (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m2009C5E8886D700C065C716EF1D08BACA6B8087F_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::Dispose()
inline void InternalEnumerator_1_Dispose_m77AAB4FA0C543E276DDD0B102DFBE7FCDA30EF84 (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m77AAB4FA0C543E276DDD0B102DFBE7FCDA30EF84_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m39F2F8FCB3BA39695FB2A1DEC28855172B6E5D4A (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m39F2F8FCB3BA39695FB2A1DEC28855172B6E5D4A_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::get_Current()
inline RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91 InternalEnumerator_1_get_Current_mB7A85C3324689374F5BBE1813C0439798CDFF9CB (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method)
{
return (( RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91 (*) (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mB7A85C3324689374F5BBE1813C0439798CDFF9CB_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m853CB9E446725D1B5FCA19FD9A4D48B5B5FECB63 (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m853CB9E446725D1B5FCA19FD9A4D48B5B5FECB63_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8E1C99A6B2906E3087932AFEF36212027CC4061D (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8E1C99A6B2906E3087932AFEF36212027CC4061D_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m090BB39068F5FAEBC457FE64EBE4DA412ED1EFDC (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m090BB39068F5FAEBC457FE64EBE4DA412ED1EFDC_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::Dispose()
inline void InternalEnumerator_1_Dispose_m17AD15A48F9CDF8D46E8580E3CEFC6F5D2836901 (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m17AD15A48F9CDF8D46E8580E3CEFC6F5D2836901_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m26900C6C96A7B745F63A23F111699B6C143AAE16 (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m26900C6C96A7B745F63A23F111699B6C143AAE16_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::get_Current()
inline LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2 InternalEnumerator_1_get_Current_mA90DEF143C9B52AABD722C59391860F4421B8D6C (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method)
{
return (( LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2 (*) (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mA90DEF143C9B52AABD722C59391860F4421B8D6C_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6910B345DBCBBF0C51B12306365DDC4490D26FDE (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6910B345DBCBBF0C51B12306365DDC4490D26FDE_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC8201A170A6AE7E43400EEE1DC7DD3A78CAE3A86 (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC8201A170A6AE7E43400EEE1DC7DD3A78CAE3A86_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Keyframe>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m53F1CFC38C88469A9029DF819DCDDCE98487450A (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m53F1CFC38C88469A9029DF819DCDDCE98487450A_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Keyframe>::Dispose()
inline void InternalEnumerator_1_Dispose_mA73E7B7883E5D7E92D433DF0A315C5D93999F3BC (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_mA73E7B7883E5D7E92D433DF0A315C5D93999F3BC_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.Keyframe>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m5AF8DEADCAFA428FB19D5A6BD9AB03ACBC4E2529 (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m5AF8DEADCAFA428FB19D5A6BD9AB03ACBC4E2529_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<UnityEngine.Keyframe>::get_Current()
inline Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74 InternalEnumerator_1_get_Current_m423DED00D8E4A4F471ACF4A96345C45C4378F556 (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method)
{
return (( Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74 (*) (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m423DED00D8E4A4F471ACF4A96345C45C4378F556_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Keyframe>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m883E5884C422A9F29875971082BB78699FB05CC2 (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m883E5884C422A9F29875971082BB78699FB05CC2_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<UnityEngine.Keyframe>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m43B13AEAA9229073FEC9D245DD86BA6C7271C778 (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m43B13AEAA9229073FEC9D245DD86BA6C7271C778_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m02C8360860C5438D895C11BB0AD8FC4F1A84B31A (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m02C8360860C5438D895C11BB0AD8FC4F1A84B31A_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::Dispose()
inline void InternalEnumerator_1_Dispose_m7089BC2386B69BD1D6A077BAB7EF4FC870FBF3A4 (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m7089BC2386B69BD1D6A077BAB7EF4FC870FBF3A4_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m3DE3F342FDB99BAF186349D0A92573B0457B5E8D (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m3DE3F342FDB99BAF186349D0A92573B0457B5E8D_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::get_Current()
inline PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93 InternalEnumerator_1_get_Current_mCF3BFAF3BCAACDF803583C88DD293C5B812A145C (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method)
{
return (( PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93 (*) (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mCF3BFAF3BCAACDF803583C88DD293C5B812A145C_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m8ED9FEB6CB357866559DA8F1EB2357D2A2AF4C12 (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m8ED9FEB6CB357866559DA8F1EB2357D2A2AF4C12_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mFE74BD11BA547725F31D73E2B0D9D52E766974A0 (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mFE74BD11BA547725F31D73E2B0D9D52E766974A0_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Plane>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mEB73FE451C65A512459AF88DD8D0FE7380EDF3D0 (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mEB73FE451C65A512459AF88DD8D0FE7380EDF3D0_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Plane>::Dispose()
inline void InternalEnumerator_1_Dispose_m180D8619B6A23257FC75B397E08E49A799C4FE21 (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m180D8619B6A23257FC75B397E08E49A799C4FE21_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.Plane>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m3C69C6DCCF2CD3D57E04836C025D1F6A6C4C6968 (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m3C69C6DCCF2CD3D57E04836C025D1F6A6C4C6968_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<UnityEngine.Plane>::get_Current()
inline Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED InternalEnumerator_1_get_Current_mE52FE5CD07FFC9C64D612B428D4C9CE7BD68C140 (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method)
{
return (( Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED (*) (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_mE52FE5CD07FFC9C64D612B428D4C9CE7BD68C140_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Plane>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m8CEF9D7220336ED895EDC381CFB017FD626D28BD (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m8CEF9D7220336ED895EDC381CFB017FD626D28BD_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<UnityEngine.Plane>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB6DF41AE2CF0E39492CBF01D41C79A2AD588D93F (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB6DF41AE2CF0E39492CBF01D41C79A2AD588D93F_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_mF99DDB9595945AEC3CB62FAAF94AE0B1DC69ADDB (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_mF99DDB9595945AEC3CB62FAAF94AE0B1DC69ADDB_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::Dispose()
inline void InternalEnumerator_1_Dispose_m51B757A0306D3F268AD6471871FBEEBB522A61D6 (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m51B757A0306D3F268AD6471871FBEEBB522A61D6_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m06838EFE676483F59B23F9AED5EDC25307714819 (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m06838EFE676483F59B23F9AED5EDC25307714819_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::get_Current()
inline PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8 InternalEnumerator_1_get_Current_m409E760F9CBF152E005D1ABB74D0D4208D56227F (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method)
{
return (( PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8 (*) (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m409E760F9CBF152E005D1ABB74D0D4208D56227F_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m544181F0799962E6A3C803D778B166694730EB37 (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m544181F0799962E6A3C803D778B166694730EB37_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0D484DEF2526C455371ED5D16CB02AD3FAD8C523 (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0D484DEF2526C455371ED5D16CB02AD3FAD8C523_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.RaycastHit2D>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m830814E57A2D1219D886501A9029DEED40DD6635 (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m830814E57A2D1219D886501A9029DEED40DD6635_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.RaycastHit2D>::Dispose()
inline void InternalEnumerator_1_Dispose_m210975609AF4E5F2A41A9E2D0CFFF0CAA90B5585 (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m210975609AF4E5F2A41A9E2D0CFFF0CAA90B5585_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.RaycastHit2D>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_mCDA22D571C4E009906699C4AB8BA2DE7A3D94302 (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_mCDA22D571C4E009906699C4AB8BA2DE7A3D94302_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<UnityEngine.RaycastHit2D>::get_Current()
inline RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE InternalEnumerator_1_get_Current_m8DD1DD354BD2CCD8BF53308EE859FD91BAC319F4 (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method)
{
return (( RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE (*) (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m8DD1DD354BD2CCD8BF53308EE859FD91BAC319F4_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.RaycastHit2D>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA7B96D62B276CF6419B4931598F51F617FBAD8C4 (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA7B96D62B276CF6419B4931598F51F617FBAD8C4_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<UnityEngine.RaycastHit2D>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mFABE9B6A837F021896FCC9A5575D1AD8A90B0C40 (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mFABE9B6A837F021896FCC9A5575D1AD8A90B0C40_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.RaycastHit>::.ctor(System.Array)
inline void InternalEnumerator_1__ctor_m116E15DD07CF4905FCA6B327A46E6DC056560A77 (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 *, RuntimeArray *, const RuntimeMethod*))InternalEnumerator_1__ctor_m116E15DD07CF4905FCA6B327A46E6DC056560A77_gshared)(__this, ___array0, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.RaycastHit>::Dispose()
inline void InternalEnumerator_1_Dispose_m213BB289521A11B41BDA96FDCBC473571C0F7134 (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 *, const RuntimeMethod*))InternalEnumerator_1_Dispose_m213BB289521A11B41BDA96FDCBC473571C0F7134_gshared)(__this, method);
}
// System.Boolean System.Array/InternalEnumerator`1<UnityEngine.RaycastHit>::MoveNext()
inline bool InternalEnumerator_1_MoveNext_m102F72F47F424F98374FB84922BF92F939ACE282 (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method)
{
return (( bool (*) (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 *, const RuntimeMethod*))InternalEnumerator_1_MoveNext_m102F72F47F424F98374FB84922BF92F939ACE282_gshared)(__this, method);
}
// T System.Array/InternalEnumerator`1<UnityEngine.RaycastHit>::get_Current()
inline RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3 InternalEnumerator_1_get_Current_m7DAF45BE6246754B95E518F44152AB86F6F01503 (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method)
{
return (( RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3 (*) (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 *, const RuntimeMethod*))InternalEnumerator_1_get_Current_m7DAF45BE6246754B95E518F44152AB86F6F01503_gshared)(__this, method);
}
// System.Void System.Array/InternalEnumerator`1<UnityEngine.RaycastHit>::System.Collections.IEnumerator.Reset()
inline void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m42B612DDDCBC1C31AC83DDDAA4382E7C8FED7384 (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method)
{
(( void (*) (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_Reset_m42B612DDDCBC1C31AC83DDDAA4382E7C8FED7384_gshared)(__this, method);
}
// System.Object System.Array/InternalEnumerator`1<UnityEngine.RaycastHit>::System.Collections.IEnumerator.get_Current()
inline RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6AB1B76B5D46EFE4ACDA056F38B79D9449AE806E (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method)
{
return (( RuntimeObject * (*) (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 *, const RuntimeMethod*))InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6AB1B76B5D46EFE4ACDA056F38B79D9449AE806E_gshared)(__this, method);
}
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void <>f__AnonymousType0`1<System.Object>::.ctor(<message>j__TPar)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void U3CU3Ef__AnonymousType0_1__ctor_m57B3BC60E57AF443B4602955F02471392D756778_gshared (U3CU3Ef__AnonymousType0_1_t103DB909F3478F55EAABC0751EA7624561E5B35F * __this, RuntimeObject * ___message0, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
RuntimeObject * L_0 = ___message0;
__this->set_U3CmessageU3Ei__Field_0(L_0);
return;
}
}
// System.Boolean <>f__AnonymousType0`1<System.Object>::Equals(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool U3CU3Ef__AnonymousType0_1_Equals_m6ABC333479B91B05E8D5256B3BB24DB217487AAC_gshared (U3CU3Ef__AnonymousType0_1_t103DB909F3478F55EAABC0751EA7624561E5B35F * __this, RuntimeObject * ___value0, const RuntimeMethod* method)
{
U3CU3Ef__AnonymousType0_1_t103DB909F3478F55EAABC0751EA7624561E5B35F * V_0 = NULL;
{
RuntimeObject * L_0 = ___value0;
V_0 = (U3CU3Ef__AnonymousType0_1_t103DB909F3478F55EAABC0751EA7624561E5B35F *)((U3CU3Ef__AnonymousType0_1_t103DB909F3478F55EAABC0751EA7624561E5B35F *)IsInst((RuntimeObject*)L_0, IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 0)));
U3CU3Ef__AnonymousType0_1_t103DB909F3478F55EAABC0751EA7624561E5B35F * L_1 = V_0;
if (!L_1)
{
goto IL_0021;
}
}
{
EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA * L_2 = (( EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA * (*) (const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 1)->methodPointer)(/*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 1));
RuntimeObject * L_3 = (RuntimeObject *)__this->get_U3CmessageU3Ei__Field_0();
U3CU3Ef__AnonymousType0_1_t103DB909F3478F55EAABC0751EA7624561E5B35F * L_4 = V_0;
NullCheck(L_4);
RuntimeObject * L_5 = (RuntimeObject *)L_4->get_U3CmessageU3Ei__Field_0();
NullCheck((EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA *)L_2);
bool L_6 = VirtFuncInvoker2< bool, RuntimeObject *, RuntimeObject * >::Invoke(8 /* System.Boolean System.Collections.Generic.EqualityComparer`1<System.Object>::Equals(T,T) */, (EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA *)L_2, (RuntimeObject *)L_3, (RuntimeObject *)L_5);
return L_6;
}
IL_0021:
{
return (bool)0;
}
}
// System.Int32 <>f__AnonymousType0`1<System.Object>::GetHashCode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t U3CU3Ef__AnonymousType0_1_GetHashCode_m79B85D1E42566EF3324E0B6239DB2BD523B4B79D_gshared (U3CU3Ef__AnonymousType0_1_t103DB909F3478F55EAABC0751EA7624561E5B35F * __this, const RuntimeMethod* method)
{
{
EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA * L_0 = (( EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA * (*) (const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 1)->methodPointer)(/*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 1));
RuntimeObject * L_1 = (RuntimeObject *)__this->get_U3CmessageU3Ei__Field_0();
NullCheck((EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA *)L_0);
int32_t L_2 = VirtFuncInvoker1< int32_t, RuntimeObject * >::Invoke(9 /* System.Int32 System.Collections.Generic.EqualityComparer`1<System.Object>::GetHashCode(T) */, (EqualityComparer_1_t54972BA287ED38B066E4BE7A3B21F49803B62EBA *)L_0, (RuntimeObject *)L_1);
return ((int32_t)il2cpp_codegen_add((int32_t)((int32_t)il2cpp_codegen_multiply((int32_t)((int32_t)-1089263382), (int32_t)((int32_t)-1521134295))), (int32_t)L_2));
}
}
// System.String <>f__AnonymousType0`1<System.Object>::ToString()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* U3CU3Ef__AnonymousType0_1_ToString_m1B1F29A3B1690D6AA429AF0A8405278664F94771_gshared (U3CU3Ef__AnonymousType0_1_t103DB909F3478F55EAABC0751EA7624561E5B35F * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (U3CU3Ef__AnonymousType0_1_ToString_m1B1F29A3B1690D6AA429AF0A8405278664F94771_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
RuntimeObject * V_0 = NULL;
RuntimeObject * V_1 = NULL;
RuntimeObject ** G_B3_0 = NULL;
int32_t G_B3_1 = 0;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* G_B3_2 = NULL;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* G_B3_3 = NULL;
String_t* G_B3_4 = NULL;
RuntimeObject * G_B3_5 = NULL;
RuntimeObject ** G_B1_0 = NULL;
int32_t G_B1_1 = 0;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* G_B1_2 = NULL;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* G_B1_3 = NULL;
String_t* G_B1_4 = NULL;
RuntimeObject * G_B1_5 = NULL;
RuntimeObject ** G_B2_0 = NULL;
int32_t G_B2_1 = 0;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* G_B2_2 = NULL;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* G_B2_3 = NULL;
String_t* G_B2_4 = NULL;
RuntimeObject * G_B2_5 = NULL;
String_t* G_B4_0 = NULL;
int32_t G_B4_1 = 0;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* G_B4_2 = NULL;
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* G_B4_3 = NULL;
String_t* G_B4_4 = NULL;
RuntimeObject * G_B4_5 = NULL;
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_0 = (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)SZArrayNew(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var, (uint32_t)1);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_1 = (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)L_0;
RuntimeObject * L_2 = (RuntimeObject *)__this->get_U3CmessageU3Ei__Field_0();
V_0 = (RuntimeObject *)L_2;
il2cpp_codegen_initobj((&V_1), sizeof(RuntimeObject *));
RuntimeObject * L_3 = V_1;
G_B1_0 = (&V_0);
G_B1_1 = 0;
G_B1_2 = L_1;
G_B1_3 = L_1;
G_B1_4 = _stringLiteral5858A25A11472FD4CFA2597DDB1EFF89706B5707;
G_B1_5 = NULL;
if (L_3)
{
G_B3_0 = (&V_0);
G_B3_1 = 0;
G_B3_2 = L_1;
G_B3_3 = L_1;
G_B3_4 = _stringLiteral5858A25A11472FD4CFA2597DDB1EFF89706B5707;
G_B3_5 = NULL;
goto IL_003b;
}
}
{
RuntimeObject * L_4 = (*(RuntimeObject **)G_B1_0);
V_1 = (RuntimeObject *)L_4;
RuntimeObject * L_5 = V_1;
G_B2_0 = (&V_1);
G_B2_1 = G_B1_1;
G_B2_2 = G_B1_2;
G_B2_3 = G_B1_3;
G_B2_4 = G_B1_4;
G_B2_5 = G_B1_5;
if (L_5)
{
G_B3_0 = (&V_1);
G_B3_1 = G_B1_1;
G_B3_2 = G_B1_2;
G_B3_3 = G_B1_3;
G_B3_4 = G_B1_4;
G_B3_5 = G_B1_5;
goto IL_003b;
}
}
{
G_B4_0 = ((String_t*)(NULL));
G_B4_1 = G_B2_1;
G_B4_2 = G_B2_2;
G_B4_3 = G_B2_3;
G_B4_4 = G_B2_4;
G_B4_5 = G_B2_5;
goto IL_0046;
}
IL_003b:
{
NullCheck((RuntimeObject *)(*G_B3_0));
String_t* L_6 = VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, (RuntimeObject *)(*G_B3_0));
G_B4_0 = L_6;
G_B4_1 = G_B3_1;
G_B4_2 = G_B3_2;
G_B4_3 = G_B3_3;
G_B4_4 = G_B3_4;
G_B4_5 = G_B3_5;
}
IL_0046:
{
NullCheck(G_B4_2);
ArrayElementTypeCheck (G_B4_2, G_B4_0);
(G_B4_2)->SetAt(static_cast<il2cpp_array_size_t>(G_B4_1), (RuntimeObject *)G_B4_0);
String_t* L_7 = String_Format_mF68EE0DEC1AA5ADE9DFEF9AE0508E428FBB10EFD((RuntimeObject*)G_B4_5, (String_t*)G_B4_4, (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)G_B4_3, /*hidden argument*/NULL);
return L_7;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Action`1<System.Boolean>::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_1__ctor_mAC998B8AD6A8D39434263D21FA7397949F39F244_gshared (Action_1_t6036B3C6D9E897E6266019A987CFC19CFC59CB64 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.Action`1<System.Boolean>::Invoke(T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_1_Invoke_mE256EA3D2B800C6C8251AAAFDFDDA3C3CFF0EE47_gshared (Action_1_t6036B3C6D9E897E6266019A987CFC19CFC59CB64 * __this, bool ___obj0, const RuntimeMethod* method)
{
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (bool, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___obj0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, bool, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___obj0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (bool, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___obj0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< bool >::Invoke(targetMethod, targetThis, ___obj0);
else
GenericVirtActionInvoker1< bool >::Invoke(targetMethod, targetThis, ___obj0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< bool >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___obj0);
else
VirtActionInvoker1< bool >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___obj0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___obj0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, bool, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___obj0, targetMethod);
}
}
}
}
}
// System.IAsyncResult System.Action`1<System.Boolean>::BeginInvoke(T,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Action_1_BeginInvoke_m10C6A956131CC7E0B40A82EF4973DB68378C7F11_gshared (Action_1_t6036B3C6D9E897E6266019A987CFC19CFC59CB64 * __this, bool ___obj0, AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Action_1_BeginInvoke_m10C6A956131CC7E0B40A82EF4973DB68378C7F11_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[2] = {0};
__d_args[0] = Box(Boolean_tB53F6830F670160873277339AA58F15CAED4399C_il2cpp_TypeInfo_var, &___obj0);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void System.Action`1<System.Boolean>::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_1_EndInvoke_m015FBFB09F7184CC5F17647CA950DBC77D10A54A_gshared (Action_1_t6036B3C6D9E897E6266019A987CFC19CFC59CB64 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Action`1<System.Guid>::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_1__ctor_m1B1AAFACBBC63972A7B94AFDF7122B330CBE9EE8_gshared (Action_1_t914484DED737548EE8FABFA959036371C8235942 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.Action`1<System.Guid>::Invoke(T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_1_Invoke_m0A36AC4F2CACB1975B2716676ED3576FD82E20DA_gshared (Action_1_t914484DED737548EE8FABFA959036371C8235942 * __this, Guid_t ___obj0, const RuntimeMethod* method)
{
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (Guid_t , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___obj0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, Guid_t , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___obj0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (Guid_t , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___obj0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< Guid_t >::Invoke(targetMethod, targetThis, ___obj0);
else
GenericVirtActionInvoker1< Guid_t >::Invoke(targetMethod, targetThis, ___obj0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< Guid_t >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___obj0);
else
VirtActionInvoker1< Guid_t >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___obj0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___obj0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, Guid_t , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___obj0, targetMethod);
}
}
}
}
}
// System.IAsyncResult System.Action`1<System.Guid>::BeginInvoke(T,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Action_1_BeginInvoke_m147EA0AF0B438620EBDA154160680EDFB8FDE786_gshared (Action_1_t914484DED737548EE8FABFA959036371C8235942 * __this, Guid_t ___obj0, AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Action_1_BeginInvoke_m147EA0AF0B438620EBDA154160680EDFB8FDE786_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[2] = {0};
__d_args[0] = Box(Guid_t_il2cpp_TypeInfo_var, &___obj0);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void System.Action`1<System.Guid>::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_1_EndInvoke_m01A63BAFFC2B2B3DA4D9F1E316F90534ADE07962_gshared (Action_1_t914484DED737548EE8FABFA959036371C8235942 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Action`1<System.Object>::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_1__ctor_mAFC7442D9D3CEC6701C3C5599F8CF12476095510_gshared (Action_1_t551A279CEADCF6EEAE8FA2B1E1E757D0D15290D0 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.Action`1<System.Object>::Invoke(T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_1_Invoke_mB86FC1B303E77C41ED0E94FC3592A9CF8DA571D5_gshared (Action_1_t551A279CEADCF6EEAE8FA2B1E1E757D0D15290D0 * __this, RuntimeObject * ___obj0, const RuntimeMethod* method)
{
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___obj0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___obj0, targetMethod);
}
}
else if (___parameterCount != 1)
{
// open
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker0::Invoke(targetMethod, ___obj0);
else
GenericVirtActionInvoker0::Invoke(targetMethod, ___obj0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker0::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), ___obj0);
else
VirtActionInvoker0::Invoke(il2cpp_codegen_method_get_slot(targetMethod), ___obj0);
}
}
else
{
typedef void (*FunctionPointerType) (RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___obj0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___obj0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< RuntimeObject * >::Invoke(targetMethod, targetThis, ___obj0);
else
GenericVirtActionInvoker1< RuntimeObject * >::Invoke(targetMethod, targetThis, ___obj0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< RuntimeObject * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___obj0);
else
VirtActionInvoker1< RuntimeObject * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___obj0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(___obj0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___obj0, targetMethod);
}
}
}
}
}
// System.IAsyncResult System.Action`1<System.Object>::BeginInvoke(T,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Action_1_BeginInvoke_m1D9F0AFC5864321DE96BED72F9B47CFB288907E9_gshared (Action_1_t551A279CEADCF6EEAE8FA2B1E1E757D0D15290D0 * __this, RuntimeObject * ___obj0, AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
void *__d_args[2] = {0};
__d_args[0] = ___obj0;
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void System.Action`1<System.Object>::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_1_EndInvoke_mACF259F14B1B9C8DA5E54D0D3349F682C71952DE_gshared (Action_1_t551A279CEADCF6EEAE8FA2B1E1E757D0D15290D0 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Action`1<System.Threading.AsyncLocalValueChangedArgs`1<System.Object>>::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_1__ctor_m09B6544493F7B95A7FA3A568D25489C5E3EEAFB6_gshared (Action_1_tC9C78235CE090A8C814E2C458627F15C33AF0180 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.Action`1<System.Threading.AsyncLocalValueChangedArgs`1<System.Object>>::Invoke(T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_1_Invoke_m9353AD83FE03CCDD354D18BF22CFB6F19C4CF4D0_gshared (Action_1_tC9C78235CE090A8C814E2C458627F15C33AF0180 * __this, AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D ___obj0, const RuntimeMethod* method)
{
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 1)
{
// open
typedef void (*FunctionPointerType) (AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___obj0, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___obj0, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___obj0, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D >::Invoke(targetMethod, targetThis, ___obj0);
else
GenericVirtActionInvoker1< AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D >::Invoke(targetMethod, targetThis, ___obj0);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___obj0);
else
VirtActionInvoker1< AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___obj0);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___obj0) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___obj0, targetMethod);
}
}
}
}
}
// System.IAsyncResult System.Action`1<System.Threading.AsyncLocalValueChangedArgs`1<System.Object>>::BeginInvoke(T,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Action_1_BeginInvoke_m38D4DB74F04D419EB6A08DC496693915A0A3060D_gshared (Action_1_tC9C78235CE090A8C814E2C458627F15C33AF0180 * __this, AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D ___obj0, AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 * ___callback1, RuntimeObject * ___object2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Action_1_BeginInvoke_m38D4DB74F04D419EB6A08DC496693915A0A3060D_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[2] = {0};
__d_args[0] = Box(AsyncLocalValueChangedArgs_1_t64BF6800935406CA808E9821DF12DBB72A71640D_il2cpp_TypeInfo_var, &___obj0);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback1, (RuntimeObject*)___object2);
}
// System.Void System.Action`1<System.Threading.AsyncLocalValueChangedArgs`1<System.Object>>::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_1_EndInvoke_mB5DE8FAC1ABE1A25A6D3EBC97D75FDD9D44A78B4_gshared (Action_1_tC9C78235CE090A8C814E2C458627F15C33AF0180 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Action`2<System.Boolean,System.Object>::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2__ctor_m554B24ED5873B2CD7DF609F61D2D11CC35DF6AE7_gshared (Action_2_t6C33D80670016FFA10F03F59FB542306FA60F1F3 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.Action`2<System.Boolean,System.Object>::Invoke(T1,T2)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2_Invoke_mF41C7E7E0E5367BC9C76AD3CDE65075DE8CEC623_gshared (Action_2_t6C33D80670016FFA10F03F59FB542306FA60F1F3 * __this, bool ___arg10, RuntimeObject * ___arg21, const RuntimeMethod* method)
{
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 2)
{
// open
typedef void (*FunctionPointerType) (bool, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, bool, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (bool, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker2< bool, RuntimeObject * >::Invoke(targetMethod, targetThis, ___arg10, ___arg21);
else
GenericVirtActionInvoker2< bool, RuntimeObject * >::Invoke(targetMethod, targetThis, ___arg10, ___arg21);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker2< bool, RuntimeObject * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___arg10, ___arg21);
else
VirtActionInvoker2< bool, RuntimeObject * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___arg10, ___arg21);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___arg10) - 1), ___arg21, targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, bool, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, targetMethod);
}
}
}
}
}
// System.IAsyncResult System.Action`2<System.Boolean,System.Object>::BeginInvoke(T1,T2,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Action_2_BeginInvoke_m4F9434B4D9C00487F3304FDB70D3303596AD3081_gshared (Action_2_t6C33D80670016FFA10F03F59FB542306FA60F1F3 * __this, bool ___arg10, RuntimeObject * ___arg21, AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 * ___callback2, RuntimeObject * ___object3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Action_2_BeginInvoke_m4F9434B4D9C00487F3304FDB70D3303596AD3081_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[3] = {0};
__d_args[0] = Box(Boolean_tB53F6830F670160873277339AA58F15CAED4399C_il2cpp_TypeInfo_var, &___arg10);
__d_args[1] = ___arg21;
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback2, (RuntimeObject*)___object3);
}
// System.Void System.Action`2<System.Boolean,System.Object>::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2_EndInvoke_mAFE67979FF5DB345AFA6B5CEEC790EB620C12E99_gshared (Action_2_t6C33D80670016FFA10F03F59FB542306FA60F1F3 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Action`2<System.Char,System.Object>::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2__ctor_mA2639DB159E3B05930C6A2D4ADA031412CCFB1A0_gshared (Action_2_t2F784F6A8F0E6D7B6C7C73DCA17B1CCA8D724E48 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.Action`2<System.Char,System.Object>::Invoke(T1,T2)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2_Invoke_mB35D966442076362FBEEAD952988680900A4B476_gshared (Action_2_t2F784F6A8F0E6D7B6C7C73DCA17B1CCA8D724E48 * __this, Il2CppChar ___arg10, RuntimeObject * ___arg21, const RuntimeMethod* method)
{
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 2)
{
// open
typedef void (*FunctionPointerType) (Il2CppChar, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, Il2CppChar, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (Il2CppChar, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker2< Il2CppChar, RuntimeObject * >::Invoke(targetMethod, targetThis, ___arg10, ___arg21);
else
GenericVirtActionInvoker2< Il2CppChar, RuntimeObject * >::Invoke(targetMethod, targetThis, ___arg10, ___arg21);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker2< Il2CppChar, RuntimeObject * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___arg10, ___arg21);
else
VirtActionInvoker2< Il2CppChar, RuntimeObject * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___arg10, ___arg21);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___arg10) - 1), ___arg21, targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, Il2CppChar, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, targetMethod);
}
}
}
}
}
// System.IAsyncResult System.Action`2<System.Char,System.Object>::BeginInvoke(T1,T2,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Action_2_BeginInvoke_m00BD43B0496F386EBA85D9FD7BF8480F6B2C1E13_gshared (Action_2_t2F784F6A8F0E6D7B6C7C73DCA17B1CCA8D724E48 * __this, Il2CppChar ___arg10, RuntimeObject * ___arg21, AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 * ___callback2, RuntimeObject * ___object3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Action_2_BeginInvoke_m00BD43B0496F386EBA85D9FD7BF8480F6B2C1E13_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[3] = {0};
__d_args[0] = Box(Char_tBF22D9FC341BE970735250BB6FF1A4A92BBA58B9_il2cpp_TypeInfo_var, &___arg10);
__d_args[1] = ___arg21;
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback2, (RuntimeObject*)___object3);
}
// System.Void System.Action`2<System.Char,System.Object>::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2_EndInvoke_m314FF98D07323AB25B265AD9CF765812747A22FC_gshared (Action_2_t2F784F6A8F0E6D7B6C7C73DCA17B1CCA8D724E48 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Action`2<System.Int32,System.Int32>::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2__ctor_m4048F6E9D3C32BED328AD8C327950293062BB0EC_gshared (Action_2_t5B6D9846A42CF1FAF7059138EA4A212815F00916 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.Action`2<System.Int32,System.Int32>::Invoke(T1,T2)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2_Invoke_mE6F0F8331921DED8D2AC7959CAAA28B26371EE97_gshared (Action_2_t5B6D9846A42CF1FAF7059138EA4A212815F00916 * __this, int32_t ___arg10, int32_t ___arg21, const RuntimeMethod* method)
{
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 2)
{
// open
typedef void (*FunctionPointerType) (int32_t, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, int32_t, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (int32_t, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker2< int32_t, int32_t >::Invoke(targetMethod, targetThis, ___arg10, ___arg21);
else
GenericVirtActionInvoker2< int32_t, int32_t >::Invoke(targetMethod, targetThis, ___arg10, ___arg21);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker2< int32_t, int32_t >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___arg10, ___arg21);
else
VirtActionInvoker2< int32_t, int32_t >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___arg10, ___arg21);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___arg10) - 1), ___arg21, targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, int32_t, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, targetMethod);
}
}
}
}
}
// System.IAsyncResult System.Action`2<System.Int32,System.Int32>::BeginInvoke(T1,T2,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Action_2_BeginInvoke_m6896AF87BCD908F449DE142BACD2A924D9C1869C_gshared (Action_2_t5B6D9846A42CF1FAF7059138EA4A212815F00916 * __this, int32_t ___arg10, int32_t ___arg21, AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 * ___callback2, RuntimeObject * ___object3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Action_2_BeginInvoke_m6896AF87BCD908F449DE142BACD2A924D9C1869C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[3] = {0};
__d_args[0] = Box(Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var, &___arg10);
__d_args[1] = Box(Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var, &___arg21);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback2, (RuntimeObject*)___object3);
}
// System.Void System.Action`2<System.Int32,System.Int32>::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2_EndInvoke_mE38ACAF24479F20B0C465A6EFF3DD349A1BE10F9_gshared (Action_2_t5B6D9846A42CF1FAF7059138EA4A212815F00916 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Action`2<System.Int32,System.Int64>::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2__ctor_m9C040F19BDAD892FF07CCF43ECF57026B3D9851C_gshared (Action_2_tC52FA3FD223419FC0456E089309277012CCE38E8 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.Action`2<System.Int32,System.Int64>::Invoke(T1,T2)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2_Invoke_m4CA8B2E800895A188FD0F7981737F367C5916FC7_gshared (Action_2_tC52FA3FD223419FC0456E089309277012CCE38E8 * __this, int32_t ___arg10, int64_t ___arg21, const RuntimeMethod* method)
{
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 2)
{
// open
typedef void (*FunctionPointerType) (int32_t, int64_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, int32_t, int64_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, targetMethod);
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (int32_t, int64_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker2< int32_t, int64_t >::Invoke(targetMethod, targetThis, ___arg10, ___arg21);
else
GenericVirtActionInvoker2< int32_t, int64_t >::Invoke(targetMethod, targetThis, ___arg10, ___arg21);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker2< int32_t, int64_t >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___arg10, ___arg21);
else
VirtActionInvoker2< int32_t, int64_t >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___arg10, ___arg21);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, int64_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___arg10) - 1), ___arg21, targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, int32_t, int64_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, targetMethod);
}
}
}
}
}
// System.IAsyncResult System.Action`2<System.Int32,System.Int64>::BeginInvoke(T1,T2,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Action_2_BeginInvoke_m1A2023AD69CC33FE7360200C4E77F16B840BCCBB_gshared (Action_2_tC52FA3FD223419FC0456E089309277012CCE38E8 * __this, int32_t ___arg10, int64_t ___arg21, AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 * ___callback2, RuntimeObject * ___object3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Action_2_BeginInvoke_m1A2023AD69CC33FE7360200C4E77F16B840BCCBB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[3] = {0};
__d_args[0] = Box(Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var, &___arg10);
__d_args[1] = Box(Int64_t7A386C2FF7B0280A0F516992401DDFCF0FF7B436_il2cpp_TypeInfo_var, &___arg21);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback2, (RuntimeObject*)___object3);
}
// System.Void System.Action`2<System.Int32,System.Int64>::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2_EndInvoke_m57B49839A4E216265C8247977CFB0361F32730D3_gshared (Action_2_tC52FA3FD223419FC0456E089309277012CCE38E8 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Action`2<System.Object,System.Boolean>::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2__ctor_m657B1B0C1E9AC8EB5EBD8CF1E13727FDACB91441_gshared (Action_2_t429E4750D84EBAC7EB494EB565EE0C8E1177C576 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.Action`2<System.Object,System.Boolean>::Invoke(T1,T2)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2_Invoke_m4A302C805FB44D9505C553A9716A8F0373CD984C_gshared (Action_2_t429E4750D84EBAC7EB494EB565EE0C8E1177C576 * __this, RuntimeObject * ___arg10, bool ___arg21, const RuntimeMethod* method)
{
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 2)
{
// open
typedef void (*FunctionPointerType) (RuntimeObject *, bool, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, RuntimeObject *, bool, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, targetMethod);
}
}
else if (___parameterCount != 2)
{
// open
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< bool >::Invoke(targetMethod, ___arg10, ___arg21);
else
GenericVirtActionInvoker1< bool >::Invoke(targetMethod, ___arg10, ___arg21);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< bool >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), ___arg10, ___arg21);
else
VirtActionInvoker1< bool >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), ___arg10, ___arg21);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___arg21) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (RuntimeObject *, bool, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (RuntimeObject *, bool, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker2< RuntimeObject *, bool >::Invoke(targetMethod, targetThis, ___arg10, ___arg21);
else
GenericVirtActionInvoker2< RuntimeObject *, bool >::Invoke(targetMethod, targetThis, ___arg10, ___arg21);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker2< RuntimeObject *, bool >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___arg10, ___arg21);
else
VirtActionInvoker2< RuntimeObject *, bool >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___arg10, ___arg21);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, bool, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(___arg10) - 1), ___arg21, targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, RuntimeObject *, bool, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, targetMethod);
}
}
}
}
}
// System.IAsyncResult System.Action`2<System.Object,System.Boolean>::BeginInvoke(T1,T2,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Action_2_BeginInvoke_m90CE2E30BF265027DA651AF5A3946F6E1C2404E7_gshared (Action_2_t429E4750D84EBAC7EB494EB565EE0C8E1177C576 * __this, RuntimeObject * ___arg10, bool ___arg21, AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 * ___callback2, RuntimeObject * ___object3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Action_2_BeginInvoke_m90CE2E30BF265027DA651AF5A3946F6E1C2404E7_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[3] = {0};
__d_args[0] = ___arg10;
__d_args[1] = Box(Boolean_tB53F6830F670160873277339AA58F15CAED4399C_il2cpp_TypeInfo_var, &___arg21);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback2, (RuntimeObject*)___object3);
}
// System.Void System.Action`2<System.Object,System.Boolean>::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2_EndInvoke_m42B557D898D05509759CA1113E3D28BA935CF1B8_gshared (Action_2_t429E4750D84EBAC7EB494EB565EE0C8E1177C576 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Action`2<System.Object,System.Int32Enum>::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2__ctor_m11C09FEBBF4BEC8CAF47DAF048B54ED68F75D8DB_gshared (Action_2_t4A92D51BAC0CF291CCBECDD41B622EDAE4E77D9F * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.Action`2<System.Object,System.Int32Enum>::Invoke(T1,T2)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2_Invoke_m964ED13DD838E051A371202A42FA76751BDE6EDA_gshared (Action_2_t4A92D51BAC0CF291CCBECDD41B622EDAE4E77D9F * __this, RuntimeObject * ___arg10, int32_t ___arg21, const RuntimeMethod* method)
{
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 2)
{
// open
typedef void (*FunctionPointerType) (RuntimeObject *, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, RuntimeObject *, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, targetMethod);
}
}
else if (___parameterCount != 2)
{
// open
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< int32_t >::Invoke(targetMethod, ___arg10, ___arg21);
else
GenericVirtActionInvoker1< int32_t >::Invoke(targetMethod, ___arg10, ___arg21);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< int32_t >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), ___arg10, ___arg21);
else
VirtActionInvoker1< int32_t >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), ___arg10, ___arg21);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___arg21) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (RuntimeObject *, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (RuntimeObject *, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker2< RuntimeObject *, int32_t >::Invoke(targetMethod, targetThis, ___arg10, ___arg21);
else
GenericVirtActionInvoker2< RuntimeObject *, int32_t >::Invoke(targetMethod, targetThis, ___arg10, ___arg21);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker2< RuntimeObject *, int32_t >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___arg10, ___arg21);
else
VirtActionInvoker2< RuntimeObject *, int32_t >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___arg10, ___arg21);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(___arg10) - 1), ___arg21, targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, RuntimeObject *, int32_t, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, targetMethod);
}
}
}
}
}
// System.IAsyncResult System.Action`2<System.Object,System.Int32Enum>::BeginInvoke(T1,T2,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Action_2_BeginInvoke_m701B18451EA00B7A907C490C88AD8DA88992B8CC_gshared (Action_2_t4A92D51BAC0CF291CCBECDD41B622EDAE4E77D9F * __this, RuntimeObject * ___arg10, int32_t ___arg21, AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 * ___callback2, RuntimeObject * ___object3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Action_2_BeginInvoke_m701B18451EA00B7A907C490C88AD8DA88992B8CC_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[3] = {0};
__d_args[0] = ___arg10;
__d_args[1] = Box(Int32Enum_t6312CE4586C17FE2E2E513D2E7655B574F10FDCD_il2cpp_TypeInfo_var, &___arg21);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback2, (RuntimeObject*)___object3);
}
// System.Void System.Action`2<System.Object,System.Int32Enum>::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2_EndInvoke_mA6DA71CAB733365347DE2FAC719EA046A9EE4DAD_gshared (Action_2_t4A92D51BAC0CF291CCBECDD41B622EDAE4E77D9F * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Action`2<System.Object,System.Object>::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2__ctor_mB83B0C1C61CED5B54803D334FFC7187881D32EFB_gshared (Action_2_t0DB6FD6F515527EAB552B690A291778C6F00D48C * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.Action`2<System.Object,System.Object>::Invoke(T1,T2)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2_Invoke_m1738FFAE74BE5E599FD42520FA2BEF69D1AC4709_gshared (Action_2_t0DB6FD6F515527EAB552B690A291778C6F00D48C * __this, RuntimeObject * ___arg10, RuntimeObject * ___arg21, const RuntimeMethod* method)
{
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 2)
{
// open
typedef void (*FunctionPointerType) (RuntimeObject *, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, RuntimeObject *, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, targetMethod);
}
}
else if (___parameterCount != 2)
{
// open
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker1< RuntimeObject * >::Invoke(targetMethod, ___arg10, ___arg21);
else
GenericVirtActionInvoker1< RuntimeObject * >::Invoke(targetMethod, ___arg10, ___arg21);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker1< RuntimeObject * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), ___arg10, ___arg21);
else
VirtActionInvoker1< RuntimeObject * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), ___arg10, ___arg21);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(___arg21) - 1), targetMethod);
}
else
{
typedef void (*FunctionPointerType) (RuntimeObject *, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (RuntimeObject *, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker2< RuntimeObject *, RuntimeObject * >::Invoke(targetMethod, targetThis, ___arg10, ___arg21);
else
GenericVirtActionInvoker2< RuntimeObject *, RuntimeObject * >::Invoke(targetMethod, targetThis, ___arg10, ___arg21);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker2< RuntimeObject *, RuntimeObject * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___arg10, ___arg21);
else
VirtActionInvoker2< RuntimeObject *, RuntimeObject * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___arg10, ___arg21);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(___arg10) - 1), ___arg21, targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, RuntimeObject *, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, targetMethod);
}
}
}
}
}
// System.IAsyncResult System.Action`2<System.Object,System.Object>::BeginInvoke(T1,T2,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Action_2_BeginInvoke_mD0FF883616A21651A83167C74B2DDA0AC1389A4C_gshared (Action_2_t0DB6FD6F515527EAB552B690A291778C6F00D48C * __this, RuntimeObject * ___arg10, RuntimeObject * ___arg21, AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 * ___callback2, RuntimeObject * ___object3, const RuntimeMethod* method)
{
void *__d_args[3] = {0};
__d_args[0] = ___arg10;
__d_args[1] = ___arg21;
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback2, (RuntimeObject*)___object3);
}
// System.Void System.Action`2<System.Object,System.Object>::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_2_EndInvoke_m571D4054E4D4C22830424759ECF29B004D7C78D0_gshared (Action_2_t0DB6FD6F515527EAB552B690A291778C6F00D48C * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Action`3<System.Object,System.Boolean,UnityEngine.Profiling.Experimental.DebugScreenCapture>::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_3__ctor_m43CF23ACBBB54C9FE89D0131E9878392FED217C8_gshared (Action_3_t5EE4F8B9C50F576C16A8CE302D8F2790394C22EA * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.Action`3<System.Object,System.Boolean,UnityEngine.Profiling.Experimental.DebugScreenCapture>::Invoke(T1,T2,T3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_3_Invoke_m9CC8A5F1F553A50389835F11E7A19F401AA7DE6D_gshared (Action_3_t5EE4F8B9C50F576C16A8CE302D8F2790394C22EA * __this, RuntimeObject * ___arg10, bool ___arg21, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 ___arg32, const RuntimeMethod* method)
{
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 3)
{
// open
typedef void (*FunctionPointerType) (RuntimeObject *, bool, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, ___arg32, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, RuntimeObject *, bool, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, ___arg32, targetMethod);
}
}
else if (___parameterCount != 3)
{
// open
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker2< bool, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 >::Invoke(targetMethod, ___arg10, ___arg21, ___arg32);
else
GenericVirtActionInvoker2< bool, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 >::Invoke(targetMethod, ___arg10, ___arg21, ___arg32);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker2< bool, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), ___arg10, ___arg21, ___arg32);
else
VirtActionInvoker2< bool, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), ___arg10, ___arg21, ___arg32);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(&___arg21) - 1), ___arg32, targetMethod);
}
else
{
typedef void (*FunctionPointerType) (RuntimeObject *, bool, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, ___arg32, targetMethod);
}
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (RuntimeObject *, bool, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, ___arg32, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker3< RuntimeObject *, bool, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 >::Invoke(targetMethod, targetThis, ___arg10, ___arg21, ___arg32);
else
GenericVirtActionInvoker3< RuntimeObject *, bool, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 >::Invoke(targetMethod, targetThis, ___arg10, ___arg21, ___arg32);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker3< RuntimeObject *, bool, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___arg10, ___arg21, ___arg32);
else
VirtActionInvoker3< RuntimeObject *, bool, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___arg10, ___arg21, ___arg32);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, bool, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(___arg10) - 1), ___arg21, ___arg32, targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, RuntimeObject *, bool, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 , const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, ___arg32, targetMethod);
}
}
}
}
}
// System.IAsyncResult System.Action`3<System.Object,System.Boolean,UnityEngine.Profiling.Experimental.DebugScreenCapture>::BeginInvoke(T1,T2,T3,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Action_3_BeginInvoke_mA891E1DC8C7E105C63B16AFFBB1009FC68E1DF91_gshared (Action_3_t5EE4F8B9C50F576C16A8CE302D8F2790394C22EA * __this, RuntimeObject * ___arg10, bool ___arg21, DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2 ___arg32, AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 * ___callback3, RuntimeObject * ___object4, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Action_3_BeginInvoke_mA891E1DC8C7E105C63B16AFFBB1009FC68E1DF91_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
void *__d_args[4] = {0};
__d_args[0] = ___arg10;
__d_args[1] = Box(Boolean_tB53F6830F670160873277339AA58F15CAED4399C_il2cpp_TypeInfo_var, &___arg21);
__d_args[2] = Box(DebugScreenCapture_t0250AAA3AE55F6AE2BDDBC4F85B00E2519A8CEF2_il2cpp_TypeInfo_var, &___arg32);
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback3, (RuntimeObject*)___object4);
}
// System.Void System.Action`3<System.Object,System.Boolean,UnityEngine.Profiling.Experimental.DebugScreenCapture>::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_3_EndInvoke_m9BCBEBB265CBE0A5D515C761BB52F80584D45FA0_gshared (Action_3_t5EE4F8B9C50F576C16A8CE302D8F2790394C22EA * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Action`3<System.Object,System.Object,System.Object>::.ctor(System.Object,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_3__ctor_m25A724612A54C1E14CFA77D23347E46330066B07_gshared (Action_3_tCC14115B7178951118504E7198B7C872630643C5 * __this, RuntimeObject * ___object0, intptr_t ___method1, const RuntimeMethod* method)
{
__this->set_method_ptr_0(il2cpp_codegen_get_method_pointer((RuntimeMethod*)___method1));
__this->set_method_3(___method1);
__this->set_m_target_2(___object0);
}
// System.Void System.Action`3<System.Object,System.Object,System.Object>::Invoke(T1,T2,T3)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_3_Invoke_mD5A124763BAD82556A8D306185AD34536508013B_gshared (Action_3_tCC14115B7178951118504E7198B7C872630643C5 * __this, RuntimeObject * ___arg10, RuntimeObject * ___arg21, RuntimeObject * ___arg32, const RuntimeMethod* method)
{
DelegateU5BU5D_tDFCDEE2A6322F96C0FE49AF47E9ADB8C4B294E86* delegateArrayToInvoke = __this->get_delegates_11();
Delegate_t** delegatesToInvoke;
il2cpp_array_size_t length;
if (delegateArrayToInvoke != NULL)
{
length = delegateArrayToInvoke->max_length;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(delegateArrayToInvoke->GetAddressAtUnchecked(0));
}
else
{
length = 1;
delegatesToInvoke = reinterpret_cast<Delegate_t**>(&__this);
}
for (il2cpp_array_size_t i = 0; i < length; i++)
{
Delegate_t* currentDelegate = delegatesToInvoke[i];
Il2CppMethodPointer targetMethodPointer = currentDelegate->get_method_ptr_0();
RuntimeObject* targetThis = currentDelegate->get_m_target_2();
RuntimeMethod* targetMethod = (RuntimeMethod*)(currentDelegate->get_method_3());
if (!il2cpp_codegen_method_is_virtual(targetMethod))
{
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found(targetMethod);
}
bool ___methodIsStatic = MethodIsStatic(targetMethod);
int ___parameterCount = il2cpp_codegen_method_parameter_count(targetMethod);
if (___methodIsStatic)
{
if (___parameterCount == 3)
{
// open
typedef void (*FunctionPointerType) (RuntimeObject *, RuntimeObject *, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, ___arg32, targetMethod);
}
else
{
// closed
typedef void (*FunctionPointerType) (void*, RuntimeObject *, RuntimeObject *, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, ___arg32, targetMethod);
}
}
else if (___parameterCount != 3)
{
// open
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker2< RuntimeObject *, RuntimeObject * >::Invoke(targetMethod, ___arg10, ___arg21, ___arg32);
else
GenericVirtActionInvoker2< RuntimeObject *, RuntimeObject * >::Invoke(targetMethod, ___arg10, ___arg21, ___arg32);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker2< RuntimeObject *, RuntimeObject * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), ___arg10, ___arg21, ___arg32);
else
VirtActionInvoker2< RuntimeObject *, RuntimeObject * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), ___arg10, ___arg21, ___arg32);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(___arg21) - 1), ___arg32, targetMethod);
}
else
{
typedef void (*FunctionPointerType) (RuntimeObject *, RuntimeObject *, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, ___arg32, targetMethod);
}
}
}
else
{
// closed
if (il2cpp_codegen_method_is_virtual(targetMethod) && !il2cpp_codegen_object_is_of_sealed_type(targetThis) && il2cpp_codegen_delegate_has_invoker((Il2CppDelegate*)__this))
{
if (targetThis == NULL)
{
typedef void (*FunctionPointerType) (RuntimeObject *, RuntimeObject *, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(___arg10, ___arg21, ___arg32, targetMethod);
}
else if (il2cpp_codegen_method_is_generic_instance(targetMethod))
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
GenericInterfaceActionInvoker3< RuntimeObject *, RuntimeObject *, RuntimeObject * >::Invoke(targetMethod, targetThis, ___arg10, ___arg21, ___arg32);
else
GenericVirtActionInvoker3< RuntimeObject *, RuntimeObject *, RuntimeObject * >::Invoke(targetMethod, targetThis, ___arg10, ___arg21, ___arg32);
}
else
{
if (il2cpp_codegen_method_is_interface_method(targetMethod))
InterfaceActionInvoker3< RuntimeObject *, RuntimeObject *, RuntimeObject * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), il2cpp_codegen_method_get_declaring_type(targetMethod), targetThis, ___arg10, ___arg21, ___arg32);
else
VirtActionInvoker3< RuntimeObject *, RuntimeObject *, RuntimeObject * >::Invoke(il2cpp_codegen_method_get_slot(targetMethod), targetThis, ___arg10, ___arg21, ___arg32);
}
}
else
{
if (targetThis == NULL && il2cpp_codegen_class_is_value_type(il2cpp_codegen_method_get_declaring_type(targetMethod)))
{
typedef void (*FunctionPointerType) (RuntimeObject*, RuntimeObject *, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)((reinterpret_cast<RuntimeObject*>(___arg10) - 1), ___arg21, ___arg32, targetMethod);
}
else
{
typedef void (*FunctionPointerType) (void*, RuntimeObject *, RuntimeObject *, RuntimeObject *, const RuntimeMethod*);
((FunctionPointerType)targetMethodPointer)(targetThis, ___arg10, ___arg21, ___arg32, targetMethod);
}
}
}
}
}
// System.IAsyncResult System.Action`3<System.Object,System.Object,System.Object>::BeginInvoke(T1,T2,T3,System.AsyncCallback,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Action_3_BeginInvoke_mB7C2A7A582F5FDE5A43E718EEDCADA5AF24C67A5_gshared (Action_3_tCC14115B7178951118504E7198B7C872630643C5 * __this, RuntimeObject * ___arg10, RuntimeObject * ___arg21, RuntimeObject * ___arg32, AsyncCallback_t3F3DA3BEDAEE81DD1D24125DF8EB30E85EE14DA4 * ___callback3, RuntimeObject * ___object4, const RuntimeMethod* method)
{
void *__d_args[4] = {0};
__d_args[0] = ___arg10;
__d_args[1] = ___arg21;
__d_args[2] = ___arg32;
return (RuntimeObject*)il2cpp_codegen_delegate_begin_invoke((RuntimeDelegate*)__this, __d_args, (RuntimeDelegate*)___callback3, (RuntimeObject*)___object4);
}
// System.Void System.Action`3<System.Object,System.Object,System.Object>::EndInvoke(System.IAsyncResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Action_3_EndInvoke_m1AB06047C37C4249AE68BDE6F900F3AD86821A8D_gshared (Action_3_tCC14115B7178951118504E7198B7C872630643C5 * __this, RuntimeObject* ___result0, const RuntimeMethod* method)
{
il2cpp_codegen_delegate_end_invoke((Il2CppAsyncResult*) ___result0, 0);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m215D1405D67CC92D7E62FEE78CB443E47E344A6E_gshared (EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m897312AE3CCDDC3226A9BBE9258A4977EBEA5B0D_gshared (EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TableRange_t485CF0807771CC05023466CFCB0AE25C46648100 EmptyInternalEnumerator_1_get_Current_m293B9C3C02900945171CC48486B75790594968C4_gshared (EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m293B9C3C02900945171CC48486B75790594968C4_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m293B9C3C02900945171CC48486B75790594968C4_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mF0986CF525A4682BB1723F6EFE6B97264C64B7EC_gshared (EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F *)__this);
TableRange_t485CF0807771CC05023466CFCB0AE25C46648100 L_0 = (( TableRange_t485CF0807771CC05023466CFCB0AE25C46648100 (*) (EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
TableRange_t485CF0807771CC05023466CFCB0AE25C46648100 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m7E92DB01F9D86DF179CD299C623378D585732E7C_gshared (EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mEB80F6F0A53A9C18840EEEC6F33DCAEA3473AA69_gshared (EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m6D42B4A27555171E65D9E6E9963676DDDC949483_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F * L_0 = (EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t0E2DD3C6D716A5F267DF9CFDF5DF37DE08990B1F_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Boolean>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m8885A418B4EEB6672F0BFFF9C6E05F20055417F5_gshared (EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Boolean>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m74B68C92611D878CE644F51C85D39C50F2DC77F9_gshared (EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Boolean>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_get_Current_m43159AC3B73F8C7B43D68F731301DAAF9660A0FF_gshared (EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m43159AC3B73F8C7B43D68F731301DAAF9660A0FF_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m43159AC3B73F8C7B43D68F731301DAAF9660A0FF_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Boolean>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m3FC589A0727ED9F77EB60F0DD110207E323783BC_gshared (EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 *)__this);
bool L_0 = (( bool (*) (EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
bool L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Boolean>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mBA3C9890B11409AB3860F36DF7560FF65D0E1009_gshared (EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Boolean>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mC5F3543A1E024A9563861BC69DCB5D60EC234A0C_gshared (EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Boolean>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m5B6D9DB2A4B771FAD1E24248F0869DE42E66C883_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 * L_0 = (EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tFA86E51CE1C2DDFA8FB9C480D56A2503217488A8_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Byte>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m713A719776A78FB091BCFCD6FB8583C8AD4F3DE0_gshared (EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Byte>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m5ABFA67ED2DE271F9BD57C6C26CDE5DC2AF9CFC3_gshared (EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Byte>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t EmptyInternalEnumerator_1_get_Current_m420EE01A411C337671037356ED272F11275F1CB5_gshared (EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m420EE01A411C337671037356ED272F11275F1CB5_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m420EE01A411C337671037356ED272F11275F1CB5_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Byte>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m4F30997E76A261D5A7048B78E39D6953567A0963_gshared (EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A *)__this);
uint8_t L_0 = (( uint8_t (*) (EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
uint8_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Byte>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m7AEDD5F60C2AE0B62EAF2E3AAE0A889FB9ABBFD9_gshared (EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Byte>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mBDAB36790D0E5860EE1FBC7308700969603B4390_gshared (EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Byte>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mC4DD0B4E33508AB63EAB5D0656FE32A7C50BE06C_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A * L_0 = (EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t8990DCB2ED70C2D8F091563F66E63289500B6D4A_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Char>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m3F6A0B5AB03FAB7CD877B3ED8FD2FD556DAE6864_gshared (EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Char>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mE0C713EE39303B29BF69C5DCE85AD3498D5AD4F3_gshared (EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Char>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar EmptyInternalEnumerator_1_get_Current_m7BC4D764094154DE60F8FB6C4201D3E091D5BFE5_gshared (EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m7BC4D764094154DE60F8FB6C4201D3E091D5BFE5_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m7BC4D764094154DE60F8FB6C4201D3E091D5BFE5_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Char>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m52A65B323390709429FEA901950D6C34BAA97FC0_gshared (EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD *)__this);
Il2CppChar L_0 = (( Il2CppChar (*) (EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Il2CppChar L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Char>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mC6FBFAA069FA70AE8FC086EBD55B0B8EBF3CBB07_gshared (EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Char>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mF3D2B81FAABE5627D18FCA6A9554426ABB540523_gshared (EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Char>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mDD3882014B3DCD4EEA30C94447AB18D08B3E0395_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD * L_0 = (EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tC42BBE2DCC3BF9978E5C3A47D7CB6AFE67FB9DDD_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.DictionaryEntry>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mF26FE9262BC4A24D324C756544CDF58ECF07B364_gshared (EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.DictionaryEntry>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mD078E2D4C0D3C0DC580A042ADE90C552B40062AD_gshared (EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.DictionaryEntry>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4 EmptyInternalEnumerator_1_get_Current_m8D775E44C86196D9A8E7493AE45BB5274764C46A_gshared (EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m8D775E44C86196D9A8E7493AE45BB5274764C46A_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m8D775E44C86196D9A8E7493AE45BB5274764C46A_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.DictionaryEntry>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m88FBF9A650DFC8C09EE8382F6B90F7EC799B204E_gshared (EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE *)__this);
DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4 L_0 = (( DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4 (*) (EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.DictionaryEntry>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m8E52F01C3C20D71E35ECC54B344F5DBD93829FB1_gshared (EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.DictionaryEntry>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mE87CC8EF989DF064366EC5E3B2359CB0C059C96B_gshared (EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.DictionaryEntry>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m953F54256C552508DA94EAD36B6CABFA687CD731_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE * L_0 = (EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t8AAEA1F7532F0059C00E3B37C926F0D465636BAE_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m03E8852482C7F42B15C49AE663784DCA10EF4EF4_gshared (EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m1C015DEE133648D1FC057467CFE0CA7368D71D2F_gshared (EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D EmptyInternalEnumerator_1_get_Current_m68884E7F37A82001ECE18FF1AB9E0807E71EEB14_gshared (EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m68884E7F37A82001ECE18FF1AB9E0807E71EEB14_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m68884E7F37A82001ECE18FF1AB9E0807E71EEB14_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mDBFE5EE2C4B9D552AF016D8F9A7B39B0B5CF6A64_gshared (EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 *)__this);
Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D L_0 = (( Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D (*) (EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m0398EA0E7B145009AE5AA2D593F1A14BAA8A113F_gshared (EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m8EE19BC8D9F59BA6F9791590C62A04C1E69F8FFF_gshared (EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m50F30A6AE7EA622F80BA600CE193EF01BD18BAB5_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 * L_0 = (EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t38E20B961E244B042F99E10B7AD0C7485F2A9796_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m8D1AF638B114BC37E0A94ED8D8B3100B4A705283_gshared (EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mEDD4C2E8719C60F73919863F06486DF697EA48A8_gshared (EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE EmptyInternalEnumerator_1_get_Current_m48F65C072D4CD934C97FB2CB5DF62922B52C9970_gshared (EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m48F65C072D4CD934C97FB2CB5DF62922B52C9970_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m48F65C072D4CD934C97FB2CB5DF62922B52C9970_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m61B960CEB01F9048939923E7BD41436DEF182209_gshared (EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 *)__this);
Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE L_0 = (( Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE (*) (EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m39B9D591DF5FFCF6A8295F761ADB35B4DC551A1E_gshared (EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m58FB8B7CE73530E50092FF783A99051CDF8668E8_gshared (EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mCDBFC4B22DE4463540100BDAC78F665EEE0E7D4A_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 * L_0 = (EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tC5CD0680EDF58D3BEF5C9866DC3334C745352E85_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mA9FD0226081FB3EF26FE2FAF62E31FC950796A75_gshared (EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m8EF6A87940BF455E4D15564DD31AA2D32D2FC2D1_gshared (EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA EmptyInternalEnumerator_1_get_Current_m0CABA4EE26CC086C7D8C239B67A07B4890E7C8EC_gshared (EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m0CABA4EE26CC086C7D8C239B67A07B4890E7C8EC_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m0CABA4EE26CC086C7D8C239B67A07B4890E7C8EC_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m608E61D81FF69DC904AF0BAC3B7AC59809D9EC03_gshared (EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 *)__this);
Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA L_0 = (( Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA (*) (EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m895BB0FCE49D32C8BAC301ED58A981CF893E714D_gshared (EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m6934B42A8606FB0F18FD689D3E50CD6FE034E817_gshared (EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mCC861504224003003CACF83A945DA71124C6F44C_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 * L_0 = (EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tEFE3D5037437A38A17C1DBF1A284E08F2C694A99_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m98260EC8E0010AF3FBF3A894025E56B50F4DBCE8_gshared (EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mF37D8F8F6D87B47882D38BAB30E97F8EE4717306_gshared (EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D EmptyInternalEnumerator_1_get_Current_m74F78B949FE0A28B76A17D74BD70A9ED83FD0864_gshared (EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m74F78B949FE0A28B76A17D74BD70A9ED83FD0864_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m74F78B949FE0A28B76A17D74BD70A9ED83FD0864_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6BFFED128F043A38F93E3925FCF4B59C86852F04_gshared (EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 *)__this);
Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D L_0 = (( Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D (*) (EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mF1B9BD4212BAF527BC9AC6E26D92158FC54F908E_gshared (EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m8DE8682FFB11A9732C6A919FE54C97CFA41F24EC_gshared (EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m83468D0994ED99116E8B0673DA6451A767A61A60_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 * L_0 = (EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tBB474592B4A12738A3119A0D4EDDA29DE6ADE504_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mFFD90AB25BC8631AC14E7D738827C7E3E35200C0_gshared (EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m30AA775C4ABA275FDE8FCC3B19E3BE4CEEFAF83D_gshared (EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29 EmptyInternalEnumerator_1_get_Current_m4D75CAE0763650D9067F695B43181AD1167219BC_gshared (EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m4D75CAE0763650D9067F695B43181AD1167219BC_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m4D75CAE0763650D9067F695B43181AD1167219BC_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m49BBCEF3E262C27531074F1DC719133745603469_gshared (EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 *)__this);
Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29 L_0 = (( Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29 (*) (EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m98EE0F81826F89F7A1F60A3FC3FC392ECAAA3F6F_gshared (EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mBD749F36DBB171E6D8177002F748EE6F38C873BC_gshared (EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m4950DABBB6B20F01832A418DDFBC3F566FF5735E_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 * L_0 = (EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t213F805CEA647960A7DC4797E2107CE28CC8A975_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m0DB2025107C7B43E6DEDE0359A908AE2DC05B1F3_gshared (EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m0C9D27DA78AB212D8726A3B16A19045DCD85C361_gshared (EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279 EmptyInternalEnumerator_1_get_Current_mEEEA3BB14A06103E355C424A371C59B0968ABC51_gshared (EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mEEEA3BB14A06103E355C424A371C59B0968ABC51_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mEEEA3BB14A06103E355C424A371C59B0968ABC51_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC1F16AD49455952D4E5C4D9E4ABFE4034541EFB6_gshared (EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F *)__this);
Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279 L_0 = (( Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279 (*) (EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m34AE36DA0ACCD8C380F3D41891935031BE385E59_gshared (EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m22F2B4E966FC9E29F9635DB057F233A131CB581E_gshared (EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mA9527356D056AB215B05E0B9B67C080DA6AE2163_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F * L_0 = (EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t887606F29B8A919FD373602FC5DFD84927B4450F_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m9790D04C1C74F7E3BB0E34A8F7CC19BC6CC50F80_gshared (EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m22CB6BB798E7B60A3668F721D80DC4D7BF22E479_gshared (EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B EmptyInternalEnumerator_1_get_Current_m2B71AC61E1D5E112E4E40B79E0FC768F981AF275_gshared (EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m2B71AC61E1D5E112E4E40B79E0FC768F981AF275_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m2B71AC61E1D5E112E4E40B79E0FC768F981AF275_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m4FB36B4F4141E8B682553EFEB167283B44682F71_gshared (EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 *)__this);
KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B L_0 = (( KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B (*) (EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m79F6A2AE06BC11D1CCC850749FFFC676DA79C7F9_gshared (EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m83A136CDB94F993520C41B1BDD8F242510F7CE68_gshared (EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mB9BA58884EE5DAEFE4BFFA8B8347E24F2DFFB16E_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 * L_0 = (EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tE770A5A971D8DBE3EB3E7066ED8C431CB1D464D3_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mBAC811406162E511BB6FBA469A78464D60D4C885_gshared (EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mD43D3E2A26415BF62D1BB67CCB59ACEB935AAF05_gshared (EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937 EmptyInternalEnumerator_1_get_Current_mE2016AE72E368C527141CFB7657D9644FEF1561E_gshared (EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mE2016AE72E368C527141CFB7657D9644FEF1561E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mE2016AE72E368C527141CFB7657D9644FEF1561E_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mF6D596124B49066D34A81973DB0BF3112BFAA033_gshared (EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C *)__this);
KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937 L_0 = (( KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937 (*) (EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mA27096B3C2B591D72DC4FF15263A7BB500302F84_gshared (EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m2E73FA28D003EE5186766A37A54098269B52AE8A_gshared (EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mDF3079E1CF640347E2236D6C9B4C5EEC66AB3548_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C * L_0 = (EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t9CD8E7F09750488F359F33930F12FBEDDB2E644C_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m9389082DAF0E3CB824835F1DC409A89E8F71D272_gshared (EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mC5E58C3866BDEF32662C067C9FFDFA1641D7A33D_gshared (EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78 EmptyInternalEnumerator_1_get_Current_mBEC4557EDCDBE1BCFE4279943CFC23E51EE664A0_gshared (EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mBEC4557EDCDBE1BCFE4279943CFC23E51EE664A0_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mBEC4557EDCDBE1BCFE4279943CFC23E51EE664A0_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m84FF33FDBBD84B95894623A46A5ABFFA1192A3D9_gshared (EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF *)__this);
KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78 L_0 = (( KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78 (*) (EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mC669CF4FC2E974BBE380249612CA412A695DCF67_gshared (EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mC584F4CF9DCA8449232DF19F6646B096CB407B62_gshared (EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m86224F3203FEB3B985181961D794C9ACD8727EAE_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF * L_0 = (EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t2DBCF4BC76913CA103209337C0694038F3124ACF_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m0D4FE3FAEDF8F1ABED5BD3382BBFFDC1AB395E63_gshared (EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m12530971797535AF076AA6A2F31030F9D391F328_gshared (EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE EmptyInternalEnumerator_1_get_Current_m952BF74D0CB1544321A6EC1605BF7919CAFF0896_gshared (EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m952BF74D0CB1544321A6EC1605BF7919CAFF0896_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m952BF74D0CB1544321A6EC1605BF7919CAFF0896_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m81BC7A7A219CB2B171DF4D58B5FED48D07DCDA5C_gshared (EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 *)__this);
KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE L_0 = (( KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE (*) (EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mBF1B3FB2F69FDED48E930D87FDA48AFC26D88FD3_gshared (EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m4FADA0916D87B3F6358D74464FA3BE85B9152B62_gshared (EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m7C7281E9EA139788448FD90B46ED53F6D90A1F4F_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 * L_0 = (EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t564FCD0B08A92565DEF37CF013F5398CA6C5F1E0_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mC12462868A20F4231399264FDC2E34FF14AE1801_gshared (EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m6DBEDF354752FFB5E53B18B63CC0ABCFED142AB7_gshared (EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E EmptyInternalEnumerator_1_get_Current_mA09E0C78D8EF2892E5C4EF4F2DCFBF8DBEFDD8FB_gshared (EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mA09E0C78D8EF2892E5C4EF4F2DCFBF8DBEFDD8FB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mA09E0C78D8EF2892E5C4EF4F2DCFBF8DBEFDD8FB_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6191E40A0A0E783576D1FC4E48B58465FBBB6C6B_gshared (EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF *)__this);
KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E L_0 = (( KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E (*) (EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m2933ED45C484E07AC0891B019E207876E725597D_gshared (EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m9394C74AE58AC4B155E505C6FB99CD4066C8C170_gshared (EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mF63350E961183A69E1FF526AC7554CA38CA4C54B_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF * L_0 = (EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tB7E6E303FAA41561FF7826C9C9FD89D704C4AFAF_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m5D2644643A158EA7A7AE3B2F9FCFA4A6EDB506C9_gshared (EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m2A3CE970E9D40CD4C5A76C84DFB034D4A9C8E4A5_gshared (EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE EmptyInternalEnumerator_1_get_Current_m2D99D91E76466691A4182B87F18C0507601C08C8_gshared (EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m2D99D91E76466691A4182B87F18C0507601C08C8_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m2D99D91E76466691A4182B87F18C0507601C08C8_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mBDB69BAF9EE37F2721B5AD3A3811CB8CF2D5ACEA_gshared (EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 *)__this);
KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE L_0 = (( KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE (*) (EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m1B7A894AB0B9C965A31DCDBA0545217219A4D624_gshared (EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m484DB995ED0D7DDF7EA6CAFC065726903923DE6E_gshared (EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m842779DEB332E5E709AD1B6D15087094D6D3C7D3_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 * L_0 = (EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t077D57541F9916A746A2F0220661FFD69717F687_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m84EB9D6CBE9A1FA2F085C27CD808FD0AD2D00723_gshared (EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m091F18477680715F913802535CB538B87F5EBAE6_gshared (EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6 EmptyInternalEnumerator_1_get_Current_m6E9F5FEA95891488995D987661B9DDDFFA7E2EA4_gshared (EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m6E9F5FEA95891488995D987661B9DDDFFA7E2EA4_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m6E9F5FEA95891488995D987661B9DDDFFA7E2EA4_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m5DF9A865043C8742470DD94C7C3BC56A87B47D96_gshared (EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA *)__this);
KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6 L_0 = (( KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6 (*) (EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mA87153CEF10D5E0151751F1426826A46299595F7_gshared (EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mFDE880DC824FEAE7DE941D9492BF2D174764DD9D_gshared (EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m9D8D00AE0F180E5F43A63CBC0FE09B8CCF1BA359_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA * L_0 = (EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tA71F937821A1B8CEABC6503D7D2AAC14AE3708DA_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m52FB452823E6AE559D5C8009C7EAA52C09D702D3_gshared (EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m7CD4A1E44E9AAFF2BDF163D2C97BBD26E40A573C_gshared (EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4 EmptyInternalEnumerator_1_get_Current_mC1C0DF442F32344DCEA7D870E1301FA676A78DF9_gshared (EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mC1C0DF442F32344DCEA7D870E1301FA676A78DF9_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mC1C0DF442F32344DCEA7D870E1301FA676A78DF9_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB9338A42EAE09A1AE704D86DE8BD359433276299_gshared (EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 *)__this);
KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4 L_0 = (( KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4 (*) (EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m58201AA8DCFD47E8753799302450A8E740AC1422_gshared (EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mA60873ECA364751B5539DAAA767C67B7EB32433C_gshared (EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m3999CEC6566BC6F452212952194940C3F20EE53E_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 * L_0 = (EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t832C80CDA9343F7DC75E208EA114220A85B4F007_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Hashtable_bucket>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m9C4F1A4B99D101028A52EDC81598C2A238AD9905_gshared (EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Collections.Hashtable_bucket>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m76F6C44B14791D87CD5FBF5850B3C422AA95623D_gshared (EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Collections.Hashtable_bucket>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bucket_t1C848488DF65838689F7773D46F9E7E8C881B083 EmptyInternalEnumerator_1_get_Current_mADF4703A99D76C5A2AE37C4DC95E3958DBE9E99C_gshared (EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mADF4703A99D76C5A2AE37C4DC95E3958DBE9E99C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mADF4703A99D76C5A2AE37C4DC95E3958DBE9E99C_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Collections.Hashtable_bucket>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mAA451D7A4D98CE4675C171D70BEEB3A27E12F972_gshared (EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F *)__this);
bucket_t1C848488DF65838689F7773D46F9E7E8C881B083 L_0 = (( bucket_t1C848488DF65838689F7773D46F9E7E8C881B083 (*) (EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
bucket_t1C848488DF65838689F7773D46F9E7E8C881B083 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Hashtable_bucket>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m5626BEE6800A064F9A431337F13F6132068AE810_gshared (EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Hashtable_bucket>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m3A7FD2038E4BE92B25520B5A0171686BDD775DE7_gshared (EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Collections.Hashtable_bucket>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m7B921A5209D6E18FB6586E50B850F7647F6C49E4_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F * L_0 = (EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tBB1E649DE3148205055E45B25E7ECE390764A10F_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.DateTime>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m975F78C3EE48B9E7B06878D23EC9C281B4A952AC_gshared (EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.DateTime>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m49CE8A52CF86E073FFA5CA0E20E6B8197A901785_gshared (EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.DateTime>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 EmptyInternalEnumerator_1_get_Current_mB020239A7A0F12907B4A51FA17738728687ADE59_gshared (EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mB020239A7A0F12907B4A51FA17738728687ADE59_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mB020239A7A0F12907B4A51FA17738728687ADE59_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.DateTime>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m34E5C3FC9F9182A729A5531D266CF00AB61C167C_gshared (EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 *)__this);
DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 L_0 = (( DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 (*) (EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.DateTime>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m34F72582F6B042A07E4D1BA9D9F31879088C74ED_gshared (EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.DateTime>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m49A85B4E3A5570A5A60ED2DBB5357AC1D1113B9D_gshared (EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.DateTime>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m71ABF55994EBEAA11671E0691C86306AAD454754_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 * L_0 = (EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t5337A7DE1FBF48A20C3D2750BB0C129C428A17C0_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Decimal>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m74B143B630B6C36DF654498F2534349A05B3004E_gshared (EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Decimal>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m7CB2B00524CF6698989F3ADAB76AC6679EC60013_gshared (EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Decimal>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 EmptyInternalEnumerator_1_get_Current_m1868AC47033FE9A5533D64C53CBF30CCF4F13274_gshared (EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m1868AC47033FE9A5533D64C53CBF30CCF4F13274_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m1868AC47033FE9A5533D64C53CBF30CCF4F13274_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Decimal>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB386A641CE39D3CF5600D4115EC07CCDD350EC58_gshared (EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 *)__this);
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 L_0 = (( Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 (*) (EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Decimal>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m5FAF648AAB4ACDDE88EFEE53CB73D671E12DF935_gshared (EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Decimal>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m9DCE943E2CD1719B3B188A672F03301E287EBB3E_gshared (EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Decimal>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m3F50D238678973046FFC8D3F92CEE670DED2839F_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 * L_0 = (EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t4A8CA4001312FA90E581C8E03A6CAAEBC1D32C29_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mF422EB08C95CBB7E56B2648B94274BBB9ADEC923_gshared (EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m19B13AFE66AC4D37AB059EE36B83C8657EBEEED6_gshared (EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A EmptyInternalEnumerator_1_get_Current_mE05BEAE26B082F795117C94E65C14D2930BA5E29_gshared (EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mE05BEAE26B082F795117C94E65C14D2930BA5E29_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mE05BEAE26B082F795117C94E65C14D2930BA5E29_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m56B74078A22B39EF53B454C0F7C652108DC2C510_gshared (EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB *)__this);
SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A L_0 = (( SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A (*) (EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mBF28CDAE5349C086F422C3BB883C21D3A9C76831_gshared (EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m2C7924F345DD08C8CFA859314649B122B6317B6F_gshared (EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m3C69F1B9EE615A8075407A47945FB09B35C872B6_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB * L_0 = (EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t946CC412A8A003281BFB44D643BDF4684842F5AB_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m0C7712208EE9DD0000B8AE464E2AC460534CE28A_gshared (EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m3852B10A84EF40D4521BDCBDD8705F23D5904DBD_gshared (EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B EmptyInternalEnumerator_1_get_Current_mB9F9A8521DE3F36A78F934BB06A77280EC38BC9B_gshared (EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mB9F9A8521DE3F36A78F934BB06A77280EC38BC9B_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mB9F9A8521DE3F36A78F934BB06A77280EC38BC9B_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m20A263F1DEB37F9E88EFB033AB9912B0A2F60FAF_gshared (EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 *)__this);
EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B L_0 = (( EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B (*) (EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m04A8893C4880A2791A1E082C883295D8FB78C921_gshared (EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m2A5F86F454FD5385E94AB22531EF53BCD076F95B_gshared (EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m9A70DAC84E1885339CF7C98D20D114022C450387_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 * L_0 = (EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tEBEEF8B0DC83CA288488AC54FD824640F3264A82_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Double>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m1C0F296370DC4C0DF620181D7C59BCC92FE6F903_gshared (EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Double>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mEACDFE5BD8963A37D7FEAA17901996A233F1F7DA_gshared (EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Double>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR double EmptyInternalEnumerator_1_get_Current_m07E77FDBFD58E5EE65287D586B1E09E258371140_gshared (EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m07E77FDBFD58E5EE65287D586B1E09E258371140_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m07E77FDBFD58E5EE65287D586B1E09E258371140_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Double>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m18C7CFE384FF9F4BAEA300DAFC89B2BE87DACB98_gshared (EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 *)__this);
double L_0 = (( double (*) (EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
double L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Double>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mEA95CAC0536C3620551EDBA9448E936897527EFF_gshared (EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Double>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mDE144228ED4141B446339E6CE8EBE02278951F17_gshared (EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Double>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m1558EF6C3F3653977F5B82895A7791BEE6C36F31_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 * L_0 = (EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tBFC2F27BAD352268BE31DBCAE2A1FBA80E2047F0_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mFFCD87519DAAA0E1D1C378EB81351A3248C365FB_gshared (EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mD6D9768D85D2A48B7B0DC8EEB4DEBB6FCD398B07_gshared (EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4 EmptyInternalEnumerator_1_get_Current_m04B5C2FD10B42EA5CD3BBE88C3B8E1AF021CD27D_gshared (EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m04B5C2FD10B42EA5CD3BBE88C3B8E1AF021CD27D_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m04B5C2FD10B42EA5CD3BBE88C3B8E1AF021CD27D_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD153CDC2F2A5EEFDB3912C153D9C64C1E5BDCB4D_gshared (EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 *)__this);
InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4 L_0 = (( InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4 (*) (EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mEEAD8DA77E8B7917629A8A2768AF63AFB93C17B9_gshared (EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mC24B334D9BBF2578D7D7E9E23EB7C1EAC95E98FA_gshared (EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mFF306DC5119BA67FC8BCBE24361235BC1B56B3A4_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 * L_0 = (EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t7FB466162AB5F00DC0B1C7825701867F65859A81_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m2A376DA133E83DE513AD758D1A692C99DBB0D338_gshared (EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mA4911432D49E92E2F00FA61E960B2BCE9F65F658_gshared (EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211 EmptyInternalEnumerator_1_get_Current_mC1B00DC8F54756D285CE951065DCB3583FA60DBF_gshared (EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mC1B00DC8F54756D285CE951065DCB3583FA60DBF_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mC1B00DC8F54756D285CE951065DCB3583FA60DBF_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mA511963ED3808D5623C40F15FFEAC135F5EC3598_gshared (EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 *)__this);
InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211 L_0 = (( InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211 (*) (EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mA4D30D5A1392D7F4CB9923A74533BB6DA735E29D_gshared (EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mEB624A9D5DA3CF1821513643AFB11A8F204F07B8_gshared (EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mE38D1D7D353975A0E63AE949E9A37B0DF89E49B3_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 * L_0 = (EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tF8CDE0C1B66F1501559647ADF80E7D103DCA2FD3_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Guid>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mD79A1CF5BF73D904F707C603193EF24B74C59F18_gshared (EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Guid>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m484BBE995C3D8765B5CBE445F663D6CB2E82BB47_gshared (EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Guid>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Guid_t EmptyInternalEnumerator_1_get_Current_m74C53F2B3DCAF7CA8A55FD1A12A8A27D6D9A540E_gshared (EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m74C53F2B3DCAF7CA8A55FD1A12A8A27D6D9A540E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m74C53F2B3DCAF7CA8A55FD1A12A8A27D6D9A540E_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Guid>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mF43C2E837BD04546189B0A6E3F935CB779B789C0_gshared (EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 *)__this);
Guid_t L_0 = (( Guid_t (*) (EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Guid_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Guid>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mD666B381F45757E4643A903B7E182CB625D5BD0F_gshared (EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Guid>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mCA8038D1FA9E62BC93D666BA375CFF3C22A03C01_gshared (EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Guid>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mB77BDE9FF54E0D09403B746D50A9D60DF831CF5E_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 * L_0 = (EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tF1F358CDFFF57063D716BBE06BECEA9E84F78455_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int16>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mB711FF68B7807A073FDCED9586CB57B759363DCD_gshared (EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Int16>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mEE41BFDC3186C969183BF06BF18CA3900F985375_gshared (EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Int16>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int16_t EmptyInternalEnumerator_1_get_Current_mBA694D08EB8FDE2B47454EDE7A07F687ED317CCF_gshared (EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mBA694D08EB8FDE2B47454EDE7A07F687ED317CCF_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mBA694D08EB8FDE2B47454EDE7A07F687ED317CCF_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Int16>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m898CFEA6236CCECC7462F1CB3E9945FDA7BEEC02_gshared (EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 *)__this);
int16_t L_0 = (( int16_t (*) (EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
int16_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int16>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m13BEC353607837CB5721A58FA80B78224FE37C6D_gshared (EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int16>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m50CCBF558BB052DAC2E4EB38DC4B11AB9C5CE7F2_gshared (EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int16>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m1F6CD9AEFD2F9BC53E4D955ED432DA1113748A1E_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 * L_0 = (EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tC1A3B279783B25BFE2686093FFF42D64AAFE8611_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int32>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m7292CC4C927081F48ED8CC8A3C8A41367968A307_gshared (EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Int32>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mF4B9304B42ECFF7DEE8C0B2A5FA551D32B732837_gshared (EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Int32>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t EmptyInternalEnumerator_1_get_Current_m688871A0D97BDF5D132509D3C505A14475EF10FA_gshared (EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m688871A0D97BDF5D132509D3C505A14475EF10FA_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m688871A0D97BDF5D132509D3C505A14475EF10FA_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Int32>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m664EB7637F7E249052B18081B5F64276892D60A9_gshared (EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 *)__this);
int32_t L_0 = (( int32_t (*) (EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
int32_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int32>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m330C90101EA19EEAB0101BFF4317D0D2E4BC55FE_gshared (EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int32>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m60CD6D74833DD9D0D52BC9095A7C5B2DC0B21BC3_gshared (EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int32>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m1DD9A2C42CEE1458C54C0E241EBA127FFF05F201_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 * L_0 = (EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t729665C599EE7F164A3DCEE6E240514C599BEC89_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int32Enum>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m2995BFE86A1262608010E0401A910CEB7F668DFC_gshared (EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Int32Enum>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mB471ADE71828B3672FD73EF6205D3DEA915E6BEF_gshared (EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Int32Enum>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t EmptyInternalEnumerator_1_get_Current_m630AF63B3207B43E2ED4C1B2D919B2E336C6859F_gshared (EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m630AF63B3207B43E2ED4C1B2D919B2E336C6859F_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m630AF63B3207B43E2ED4C1B2D919B2E336C6859F_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Int32Enum>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m57D1B50F5EC33382477DD521E620315D280C75E4_gshared (EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B *)__this);
int32_t L_0 = (( int32_t (*) (EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
int32_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int32Enum>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mAAAE4E7225469FD4E7C249FD32C013C588513F8B_gshared (EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int32Enum>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mC7805C0B9061658AE316B55E06A030CA835FE8BC_gshared (EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int32Enum>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mDC9545877D9D593AD36F40F11BAB2C7317D11930_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B * L_0 = (EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t0B1844861F38476142804739BC8C6F811DEB1F5B_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int64>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m1A41F88BF9675BB680CC6D64C730FA987EB75EAE_gshared (EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Int64>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m9E2F9114A4381D11736A1452993EC66D853A9B56_gshared (EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Int64>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t EmptyInternalEnumerator_1_get_Current_m43D211386BFACB64619122C4508DE298757FFDF0_gshared (EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m43D211386BFACB64619122C4508DE298757FFDF0_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m43D211386BFACB64619122C4508DE298757FFDF0_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Int64>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC6C65778DCCCA9EA9A48368903E938803A4C0D06_gshared (EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 *)__this);
int64_t L_0 = (( int64_t (*) (EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
int64_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int64>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m8D362B0F83085C58322BFDC9B04C0EB159724A48_gshared (EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int64>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m03F1E5FF6364909760D254D05EE910DEC4C60216_gshared (EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Int64>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m23B8F76B9C601B074B9E795B46638E8F8F093EE3_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 * L_0 = (EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t83A5517792A4655DCCF74DB780A55428D6BD99C0_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.IntPtr>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m97E901092BE9E349BE25866734C0BEDA2F41D0D9_gshared (EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.IntPtr>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mB83C70306150B7BFE954F93CEFFBE85A16E9DDD6_gshared (EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.IntPtr>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR intptr_t EmptyInternalEnumerator_1_get_Current_m4BBE2ED9520467529E070DEDE2D4EA9BC34FFF46_gshared (EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m4BBE2ED9520467529E070DEDE2D4EA9BC34FFF46_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m4BBE2ED9520467529E070DEDE2D4EA9BC34FFF46_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.IntPtr>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8038D877021A2E00404158479786046C8A82C073_gshared (EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C *)__this);
intptr_t L_0 = (( intptr_t (*) (EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
intptr_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.IntPtr>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m4560BB47417D6F4D9C102D832963D4C39692E7E7_gshared (EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.IntPtr>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m2F8B2EEDFE912D30F92DB900599D751457025323_gshared (EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.IntPtr>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m6C648011298A150BEF13DF2B554A1E69BE319C13_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C * L_0 = (EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tCAAD164E9986CAAAFCCE77752536C6A5408E536C_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Object>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m5DDD72FE1ECEE850FECBE4B27400C628BF3F41A5_gshared (EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Object>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m02AF092F3FCAE014A2392BFFDFEEE5DAD0139C57_gshared (EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Object>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_get_Current_m1CE82E4289FB0185AFB66AE7C7EF92511DC7017E_gshared (EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m1CE82E4289FB0185AFB66AE7C7EF92511DC7017E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m1CE82E4289FB0185AFB66AE7C7EF92511DC7017E_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Object>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD06E915DEC8A96CABFC5E9A34F2D4FDB43C36D7F_gshared (EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A *)__this);
RuntimeObject * L_0 = (( RuntimeObject * (*) (EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
return L_0;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Object>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m9DF4386FCA8A390A1303DA29B991AA5C1D570E5F_gshared (EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Object>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m9B50232A3995677B96B51942B7F65624125C4AAD_gshared (EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Object>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m9F5D8779E996E9EE7EDDCFDADE4C5C39774D0ECC_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A * L_0 = (EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tC611D530FCDA1D5D02613D1AF4E7EB8586C38F8A_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.ParameterizedStrings_FormatParam>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m441772CFD292DD5953CB8364A2236B1419350DAA_gshared (EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.ParameterizedStrings_FormatParam>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mA9477055A4431B44AFE21712985DF8056AD1045E_gshared (EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.ParameterizedStrings_FormatParam>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800 EmptyInternalEnumerator_1_get_Current_m60F72696ADBA60FCDF548CC21844A3852BAA9820_gshared (EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m60F72696ADBA60FCDF548CC21844A3852BAA9820_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m60F72696ADBA60FCDF548CC21844A3852BAA9820_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.ParameterizedStrings_FormatParam>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD7530BE948BFCF516829E9304C36C4D29EDFC125_gshared (EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C *)__this);
FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800 L_0 = (( FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800 (*) (EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.ParameterizedStrings_FormatParam>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mA889F3E24706BA241B0F0D42A3CEC7AE6FA3D422_gshared (EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.ParameterizedStrings_FormatParam>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m5287028BC617C3AA25DF8A8AA6D5D21CFA2447DE_gshared (EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.ParameterizedStrings_FormatParam>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m7ABE7C642DEFC4520AF31BFC99A9D917A9E1C50F_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C * L_0 = (EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tE5866FC28F0D62774BA658B76D6F92361E32099C_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m8D8FC0F059B7393E1A4C306D817C27ED89D85E2B_gshared (EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mA9B8AD39B672406823F09CD2BF9B327D5F7C1CC2_gshared (EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E EmptyInternalEnumerator_1_get_Current_m89E994B29B5FB68A2E132D5BE44DED295944AC41_gshared (EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m89E994B29B5FB68A2E132D5BE44DED295944AC41_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m89E994B29B5FB68A2E132D5BE44DED295944AC41_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mFE50386806D49B77808CF194AD20EE00399ED3CC_gshared (EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 *)__this);
CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E L_0 = (( CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E (*) (EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m220D0C4F58A2ABCC1B633CC3F0095E9F4A92D9B8_gshared (EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mA8EB4A322B4F31788B53CF662BE36F903B338EDA_gshared (EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m9D737FF318402F186F2BE855B5332EC5053D2223_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 * L_0 = (EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t65DD578801F5765D9E2625DBA180E2CD486F4666_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mFA405C9CB4846946BEE698D5B014337722FE00F7_gshared (EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m56399366FAC0B9B554D0EE6E6244484E277E732C_gshared (EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 EmptyInternalEnumerator_1_get_Current_m4A4EFA8829A60E09FE4E94105F12D16C78230B77_gshared (EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m4A4EFA8829A60E09FE4E94105F12D16C78230B77_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m4A4EFA8829A60E09FE4E94105F12D16C78230B77_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m06EEF4E303692988303BFE577EE6395F114022DA_gshared (EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B *)__this);
CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 L_0 = (( CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 (*) (EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m7DCDCFC7252441CA8EDF6EEDE6A2B86FE1C8BA69_gshared (EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mF1C4F421743F87F2DB45A735373B7CC290086DB5_gshared (EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m75641F964606EFF81FABADA7427F17FC33DC4AAB_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B * L_0 = (EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t57745FDC4DBB0CA2E07FA62544800AB60AF24A2B_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Reflection.ParameterModifier>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mD73E8B2E2FABBDAEE43E1E8638A8A0D7F4BECEC1_gshared (EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Reflection.ParameterModifier>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m11235498B567F993814259E23F34B40AA38718A5_gshared (EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Reflection.ParameterModifier>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E EmptyInternalEnumerator_1_get_Current_mF477BCDFC6FB221532EC3FBD8F1711E6D55C1F10_gshared (EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mF477BCDFC6FB221532EC3FBD8F1711E6D55C1F10_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mF477BCDFC6FB221532EC3FBD8F1711E6D55C1F10_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Reflection.ParameterModifier>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6A9BA918B8ABB3DA6490CFF3B5CA1F0C4B805FBA_gshared (EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 *)__this);
ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E L_0 = (( ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E (*) (EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Reflection.ParameterModifier>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m011919ED29CA6DE5DEC842FC0183A7DFF765352B_gshared (EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Reflection.ParameterModifier>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mE59F2CCFBC15FC6FB230B7031D44C34222FC3BD9_gshared (EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Reflection.ParameterModifier>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mF1FD2EEA06572C3233D0B2978A370C5D130D9281_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 * L_0 = (EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t6BADE6B1CE77B3257D90F11B80E5DF6B58283C00_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Resources.ResourceLocator>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mCF7AF21651160BE181FAF7DB14DA32B2B0A75283_gshared (EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Resources.ResourceLocator>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m10A78C0EE239A779FD3F364BF5F17EFDD3D57B30_gshared (EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Resources.ResourceLocator>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C EmptyInternalEnumerator_1_get_Current_m8AFD620D0B3BD3A1F968761903831952C731B3A2_gshared (EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m8AFD620D0B3BD3A1F968761903831952C731B3A2_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m8AFD620D0B3BD3A1F968761903831952C731B3A2_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Resources.ResourceLocator>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD42C3A72403ADD3B7FD102409DD57180712E369A_gshared (EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 *)__this);
ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C L_0 = (( ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C (*) (EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Resources.ResourceLocator>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m4C1A01C24797A9E858CD97E4D0C551FBC3ACAFAA_gshared (EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Resources.ResourceLocator>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mE50E4B7364CB268A00FBB810CB3DEDDE6D5D2D99_gshared (EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Resources.ResourceLocator>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mC1863DE0E63768542BC713004EEDEF3EFD3B4F00_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 * L_0 = (EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t45249F06BBEB21350E1E707D989AD13C07894551_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mA5FA6EF1DB76C24912D4B0BC7006195D1A12AF79_gshared (EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m7868AA7B880A1C98361C1FDE7B505638785EC5AD_gshared (EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA EmptyInternalEnumerator_1_get_Current_m83FBD6CF2834CFCAD3D84A8215C40BCC028353A8_gshared (EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m83FBD6CF2834CFCAD3D84A8215C40BCC028353A8_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m83FBD6CF2834CFCAD3D84A8215C40BCC028353A8_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mE8B2CEA54D056374FD4904575AD2780469381883_gshared (EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 *)__this);
Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA L_0 = (( Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA (*) (EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m7D6398EF70A977FB6CF6A0ED22B6216BDD97F9B2_gshared (EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mC47D4F41979BAF1369935FA501C701DBD8065031_gshared (EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m06CEC1DC1C62E9979D0AFD4012DB1E8821F1844C_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 * L_0 = (EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t783010AC2AF12E1BB5E623633CB9D3D38C3ABE38_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m929359D49D15A9B72BF0275E0A4359ECC950940E_gshared (EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m37C312D9DCB42EB99A8819097C6E3159DAB8AB48_gshared (EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 EmptyInternalEnumerator_1_get_Current_m7FF157DCF930FD6D8E3448441F2EE79E8CB462A9_gshared (EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m7FF157DCF930FD6D8E3448441F2EE79E8CB462A9_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m7FF157DCF930FD6D8E3448441F2EE79E8CB462A9_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m878CA1568C9CB36A2967C10125E5533EBBAC8C66_gshared (EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC *)__this);
GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 L_0 = (( GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 (*) (EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m5E31D2837C571363ABBC356253FC068C01DA00A1_gshared (EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mAC4B71B2FC0FC26A1EFC35E80D20493407C61123_gshared (EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m3CE1AE3DC0E3429F16A121B536321551B07A675C_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC * L_0 = (EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t7685E0CCF75EEA996509C5A0D38065C6C661D7EC_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.SByte>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m92769464B9E318B2D2BE51066CF5FEDD797DAA63_gshared (EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.SByte>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m3988F41B37EA8413C34455B9DFC58B0072C3F3D9_gshared (EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.SByte>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int8_t EmptyInternalEnumerator_1_get_Current_m17E39F6C3ADB920CA93850D89890D0E47C36592D_gshared (EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m17E39F6C3ADB920CA93850D89890D0E47C36592D_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m17E39F6C3ADB920CA93850D89890D0E47C36592D_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.SByte>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m08AB2122386BCCD1CCA73D499D5EC5C306C26310_gshared (EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 *)__this);
int8_t L_0 = (( int8_t (*) (EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
int8_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.SByte>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m68A83D70C3E991DACD60D4EAF0C76DDDE6B66C7A_gshared (EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.SByte>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mB6EDCDD22B46C09071F14F451BF267F40380212B_gshared (EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.SByte>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mF27674DCEA543E4BD5A3CE5A66C17FA54E309849_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 * L_0 = (EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t005672573596D5BBD3713D146144FEDC47BE4343_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Single>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mE8CEAC8C1A93C4B3DCEA53C0F5AE5760A5347C68_gshared (EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Single>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mFC8B73E5C1546F6C1CFAE705FDD87920025CB5E2_gshared (EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Single>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float EmptyInternalEnumerator_1_get_Current_m0C60BE6EA74588A46F15051C3259341BDCB8F58A_gshared (EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m0C60BE6EA74588A46F15051C3259341BDCB8F58A_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m0C60BE6EA74588A46F15051C3259341BDCB8F58A_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Single>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m52A35AF4CA92C48B879F46AF3E81969816AFCA52_gshared (EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 *)__this);
float L_0 = (( float (*) (EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
float L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Single>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mED2110BDB992BC200A62AF4C8917D21E6E42246B_gshared (EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Single>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mDCB2F8754EF95F26BFD283F67F73FC77EB2DCEFE_gshared (EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Single>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m0903AA99F17F7060D0CAE1DAC5764E5A823019FA_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 * L_0 = (EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t87A675C433A2B9B9F8220668E8384DD97CAB0236_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mB1989E973B04D909CCD84550E48B494158BA6D72_gshared (EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m0DC0693ADE7BF7DC3569B2560EC5060DFBC30971_gshared (EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B EmptyInternalEnumerator_1_get_Current_m0FB286FD156C69E50C98EDD6ADF037DC6A46D771_gshared (EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m0FB286FD156C69E50C98EDD6ADF037DC6A46D771_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m0FB286FD156C69E50C98EDD6ADF037DC6A46D771_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mDFDD30A1EF486B0DC2A8BE5409CC0FE4114BFD45_gshared (EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 *)__this);
LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B L_0 = (( LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B (*) (EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m4D83E50ED4BA17341EBEB8C0F7EDA7CE86AD5C77_gshared (EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m61BFA33258B94F937D42F23CF00F895B10E0956A_gshared (EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mB74DE222A903C2FDBFABA115C5C87128C46C4070_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 * L_0 = (EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t2A0A894D345933AB61AD8BECDA3EDFE5904667A4_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.Threading.CancellationTokenRegistration>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m61A49321507F1A6B1497216A3CBD67067B95DCDF_gshared (EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.Threading.CancellationTokenRegistration>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m8089246C330463EC937724A966327647A013EC34_gshared (EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.Threading.CancellationTokenRegistration>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2 EmptyInternalEnumerator_1_get_Current_mB55E0808A4D77A4946F44A0F47F8BE914C329D45_gshared (EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mB55E0808A4D77A4946F44A0F47F8BE914C329D45_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mB55E0808A4D77A4946F44A0F47F8BE914C329D45_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.Threading.CancellationTokenRegistration>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m21EBF0699D602278D4F4D3669390B0DC2D646120_gshared (EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF *)__this);
CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2 L_0 = (( CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2 (*) (EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Threading.CancellationTokenRegistration>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m557F5AE91B32EFBD8862833899CC8854E349A548_gshared (EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Threading.CancellationTokenRegistration>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m7EB18C34EFA4724AAF644A47E5A92596C1E7F476_gshared (EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.Threading.CancellationTokenRegistration>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mBBF3E1257C06D7CE5D4E5A1207F45271716C295D_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF * L_0 = (EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tAE64537C086E6499A6C90F36760061CC92775EDF_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.TimeSpan>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mE2BFB736F6C48245F81862824D489F53A069ABD3_gshared (EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.TimeSpan>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m25DE39443E5D946CA0D720A28189C914C9D8D53F_gshared (EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.TimeSpan>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 EmptyInternalEnumerator_1_get_Current_mEA3554A434E127BEB53A50C0B937A0FDC4155661_gshared (EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mEA3554A434E127BEB53A50C0B937A0FDC4155661_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mEA3554A434E127BEB53A50C0B937A0FDC4155661_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.TimeSpan>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m40418EE331910769FCB1D3865C652CB962B17055_gshared (EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 *)__this);
TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 L_0 = (( TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 (*) (EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.TimeSpan>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mFF789313488DA8B08D17A05F2D2025F4005E2F88_gshared (EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.TimeSpan>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mC75783E910FB954AFB3129A3FAC3425DF406D46A_gshared (EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.TimeSpan>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m8ED04926F7336AEEE9032A9CED5AC0F5B3547F1F_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 * L_0 = (EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t25122E9D49E64133A93E64AB344FCF4333D20BC6_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.UInt16>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m1F6DCDE72D63C52768DDF25B8B452D29EE8EEF3E_gshared (EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.UInt16>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m542E99F8CC7A8A3BF4EBF0463134548A15E87D6A_gshared (EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.UInt16>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t EmptyInternalEnumerator_1_get_Current_mB4538F08D37C1AF8ED2E5A8542368184F34E58E7_gshared (EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mB4538F08D37C1AF8ED2E5A8542368184F34E58E7_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mB4538F08D37C1AF8ED2E5A8542368184F34E58E7_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.UInt16>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mBDEBFFB0845BEDF6280941C51465BE41B528EEF8_gshared (EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 *)__this);
uint16_t L_0 = (( uint16_t (*) (EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
uint16_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.UInt16>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m674E8477DDF4231D46FC0032374D5ADE0BF87F6A_gshared (EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.UInt16>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m23CD02FF0B8E4587E2E951E8C981DF53FB6567D7_gshared (EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.UInt16>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m127AB814BCF4AAF710A2889828B556C98693C2A8_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 * L_0 = (EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t0061E530BB230C919151C3A857CE0A02B62F6611_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.UInt32>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mE48E2F7CD9B23BB8E1FC86D3657BE275130B11FF_gshared (EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.UInt32>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mC78BC71CDB2F9319F454BF452BFABC3803D4411E_gshared (EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.UInt32>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t EmptyInternalEnumerator_1_get_Current_mD41BD65921AA0AFAA9025BD7FBEEE634BF58E633_gshared (EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mD41BD65921AA0AFAA9025BD7FBEEE634BF58E633_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mD41BD65921AA0AFAA9025BD7FBEEE634BF58E633_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.UInt32>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8A3A315ADA83D45DB83B7691646ADECA204E1E00_gshared (EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 *)__this);
uint32_t L_0 = (( uint32_t (*) (EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
uint32_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.UInt32>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mD39CEE2F8588570226A037B2B670B033C1E13FB2_gshared (EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.UInt32>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mD5870B223A3C785AD75AC3A49A44A5C8E2982945_gshared (EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.UInt32>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m656B8F6066A0269AD9B2FF16BCF6BB7A49F2F335_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 * L_0 = (EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t90D8A1E77B94C9D4D71DE84AC8DEAA7378A0A9D6_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.UInt64>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mF93061EF26F11A7B6827498E9B65EB8780F9174B_gshared (EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.UInt64>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mBAA6AB3D0E3D3645B0EB602CFFDFD468F96F97B8_gshared (EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.UInt64>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t EmptyInternalEnumerator_1_get_Current_mC07B792B936AADB3124956F37200AD20909E051B_gshared (EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mC07B792B936AADB3124956F37200AD20909E051B_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mC07B792B936AADB3124956F37200AD20909E051B_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.UInt64>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m55BCE35E2E8E03016DAD3C422B89118129C990E1_gshared (EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD *)__this);
uint64_t L_0 = (( uint64_t (*) (EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
uint64_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.UInt64>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mDA09B90E5062B10E8F60264A5D97CB26A200A744_gshared (EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.UInt64>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m1473E1DA482E76444D08B85FA234FC1AE628C471_gshared (EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.UInt64>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m2EE48BDC2247B38F84502C4370EEB1C352023CD4_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD * L_0 = (EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t0B626AE0A07388A9459977AE9C635AC9E47271AD_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<System.UIntPtr>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mED029235FDB81A71BB681B636C1A8A2A1D33FAC1_gshared (EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<System.UIntPtr>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mF326BDA3667029CF1704F08E7658D9DF2F295EB5_gshared (EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<System.UIntPtr>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uintptr_t EmptyInternalEnumerator_1_get_Current_mDB789AF8B347AAB5B9C449C7519E95F969E9DE87_gshared (EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mDB789AF8B347AAB5B9C449C7519E95F969E9DE87_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mDB789AF8B347AAB5B9C449C7519E95F969E9DE87_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<System.UIntPtr>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m730520F019D9F52A5B5AAB5FD42BAF4DB4CCD155_gshared (EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D *)__this);
uintptr_t L_0 = (( uintptr_t (*) (EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
uintptr_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.UIntPtr>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m2A3E40E0585E435811425F71F532DE7C41C72DA0_gshared (EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.UIntPtr>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m3D0B7F30B9A5E786C36F084E451266F1575F3A53_gshared (EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<System.UIntPtr>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m99A33F3C6B804BEB1499D7A73945ED8CD44FC99C_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D * L_0 = (EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t4D6EB06155FE8AD2FE6D46284E70229D7797BE3D_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mF889C0BB40E631D83C0A913DB5C4C91E28B4D821_gshared (EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mBACD1B9B7D28926773388C5303D845AE5742E199_gshared (EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727 EmptyInternalEnumerator_1_get_Current_m247079442CEC480662FA971CAD91C5A1ED937A9A_gshared (EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m247079442CEC480662FA971CAD91C5A1ED937A9A_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m247079442CEC480662FA971CAD91C5A1ED937A9A_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m66ECEC23E1A7A97334CE7CCBE0E4454AF18C2BAE_gshared (EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E *)__this);
OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727 L_0 = (( OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727 (*) (EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m54FCF5AEDE4FA8E5164D5E65C1E97725DF5AB2CC_gshared (EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mCEFEC6C53E4AD8ACCAC1B22C0852979CC66514F2_gshared (EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mA1FA71B0BE9000F8F8AB60F0E05CBE5234EE1E82_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E * L_0 = (EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tFA4A0C7AAD0B7F6528EB1BF0CA3F81453756410E_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Color32>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mDC28D662574EB6015EBA8AA31C3DBCEBD99F2350_gshared (EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.Color32>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mCC7719AFE4981E35BDA348E5685964B929C2D75A_gshared (EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.Color32>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 EmptyInternalEnumerator_1_get_Current_mC2B8B3B80264600FD8E7FBA9DEBA4BA6FA287810_gshared (EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mC2B8B3B80264600FD8E7FBA9DEBA4BA6FA287810_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mC2B8B3B80264600FD8E7FBA9DEBA4BA6FA287810_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.Color32>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m25E2E081957C0CCC50CCDDF6DC8995CD517BA383_gshared (EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 *)__this);
Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 L_0 = (( Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 (*) (EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Color32>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m0C94A199B7DDD1C14ECC2DB403D8B5A6E58E32BB_gshared (EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Color32>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m16A6A1272029A4A1E3F8DC74E347D0C676C5027B_gshared (EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Color32>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m249DB96D73BB8FEF2FB61DFA482CBC4FE22FADD0_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 * L_0 = (EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tCF7FFC75412DBAE45894E509AF5800A8594BC771_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mFCF59055E1D9E77A0548C3EBCA7EF988CECBAF0F_gshared (EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m8A12271C10136D1CB66B94725DFEDAF012D40C57_gshared (EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91 EmptyInternalEnumerator_1_get_Current_m165DF603BD5CC24DD7D73981775AAEE1DF235094_gshared (EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m165DF603BD5CC24DD7D73981775AAEE1DF235094_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m165DF603BD5CC24DD7D73981775AAEE1DF235094_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC5CD09E851C77737BB0AF82BE676D9BE8DCD8677_gshared (EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 *)__this);
RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91 L_0 = (( RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91 (*) (EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mD9BCF0DABC2033B5DBB6F0855CD899DD55C743F2_gshared (EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mBFFCEADC6259C4E8B1289A8CDDEB08D1D1B4213A_gshared (EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m8E6BAAF356A43BAE15755AE0F36D26ED1F7931E2_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 * L_0 = (EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t6DCD390055BE921752E3C4A1ED7B3FCA57681A05_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m4F4A3E1734266A2A48649A6D24796CECFEBEF148_gshared (EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m5121451D280F4DEA78057C971EC15AE0D6BC249D_gshared (EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2 EmptyInternalEnumerator_1_get_Current_mEA48A914AC1EA8AA2BA4D469555F9A904465F31D_gshared (EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mEA48A914AC1EA8AA2BA4D469555F9A904465F31D_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mEA48A914AC1EA8AA2BA4D469555F9A904465F31D_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m12FE30A8CC333F770010C09F646C8AECD286FF90_gshared (EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 *)__this);
LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2 L_0 = (( LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2 (*) (EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m277371BF346155C92165BBD1F7B9F6338128A170_gshared (EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m574812D52490C7A51600ED17A6EC64C41C5709ED_gshared (EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m63A3C2F2023FEE342DA2C1407C7D2AF73184F612_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 * L_0 = (EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t3D028B13E2B831E3F628FD368EBBE3A968AE02F8_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Keyframe>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m5E969110A961C4AD5CA4652F5F4A96D5DBA66D43_gshared (EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.Keyframe>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mDA21E7F19FD2FA932A2831486BECDEFF15C7AD4F_gshared (EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.Keyframe>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74 EmptyInternalEnumerator_1_get_Current_m5E5746A2F739063EB4AAD252A5755542C93CE3DC_gshared (EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m5E5746A2F739063EB4AAD252A5755542C93CE3DC_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m5E5746A2F739063EB4AAD252A5755542C93CE3DC_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.Keyframe>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mAE60631B2FAAD9126B2771CB5B7446D6736AD230_gshared (EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 *)__this);
Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74 L_0 = (( Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74 (*) (EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Keyframe>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m870C7907DA9B476EE95D7C0DF61BA67C89A430D0_gshared (EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Keyframe>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m5CE5171F083ECE4819D41BF1D86FBB8443CBF3A2_gshared (EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Keyframe>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mF6AC13A53ECFB7C980913F83142C4D0BA2956033_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 * L_0 = (EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t60A3DBECA041DD4E7C8E7C5971821F01C31A6601_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m6CAAD0ECE5C807BF10857BD605283A49B650FD00_gshared (EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m26FC13E8BC67CD60D4BFA3040CF3AB3803529011_gshared (EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93 EmptyInternalEnumerator_1_get_Current_mFECAA6FE620D2B630E8A3AC1615D8F677C5F0C22_gshared (EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mFECAA6FE620D2B630E8A3AC1615D8F677C5F0C22_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mFECAA6FE620D2B630E8A3AC1615D8F677C5F0C22_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC0D765E68FF7E997B264B57F81E1DA611BC8C761_gshared (EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D *)__this);
PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93 L_0 = (( PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93 (*) (EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mC6EF37AB09B58B780E3C264F4DDC7940BA2E7DDF_gshared (EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m72CAB86B13E3296AED82533B39BA8D52E72B8418_gshared (EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mC2CF95F915439E5A2100633A1E64F10225CEDC27_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D * L_0 = (EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tF374CD85188FBAA665DB53025E0400BF912D291D_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Plane>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m4639984F7FB9AF9DFBD94B973EF06090BAA526C8_gshared (EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.Plane>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m34C54A48D7CA9035A9D9C8224FAFA42EE59D82E7_gshared (EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.Plane>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED EmptyInternalEnumerator_1_get_Current_m2E3532B82D1C6D2AE0835E096591EC98D0982AB2_gshared (EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m2E3532B82D1C6D2AE0835E096591EC98D0982AB2_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m2E3532B82D1C6D2AE0835E096591EC98D0982AB2_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.Plane>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m7E9FDBEC2B66E828FB85BC86BE36F05DBD0C336D_gshared (EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 *)__this);
Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED L_0 = (( Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED (*) (EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Plane>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mA20AACA735C464030C168F6F3C8F6597F4E16A23_gshared (EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Plane>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mE6CE21D6A8F692AC74A7E153E8ECC51F2AC9186F_gshared (EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Plane>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m7F4B5140C0AD8C0F6A698EAAAE8CC8ACC04FA940_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 * L_0 = (EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t9821B5B41FB48AEEA93748815781B147245CEF40_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mC2D7C4F4E1AB5AC2EFE2DDA58E85160CCC5184B3_gshared (EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mB49376D3580CF2B883BA0F59956E89FA85A53C73_gshared (EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8 EmptyInternalEnumerator_1_get_Current_mF50B58F842124158245C98B1F976703224B89103_gshared (EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mF50B58F842124158245C98B1F976703224B89103_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mF50B58F842124158245C98B1F976703224B89103_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mE96F397F5E3F956987DB1726EDAEF0CEDE6886CB_gshared (EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED *)__this);
PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8 L_0 = (( PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8 (*) (EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mD0A39576869A94C55893779A20436AAC0D8F5426_gshared (EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m32777A50CC818414A073CD50A482FA6338EE7183_gshared (EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mA0CEA862475C2EBE9B7663507A628B92DFF26A71_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED * L_0 = (EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t20FF65AC3277ADED4654D12730A62C220D22E0ED_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit2D>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mA60D398C5FCAD7F6DB1B570EA917D34D960BA076_gshared (EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit2D>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mB13BF1E5D5054D54B30E468CD6684585031F4E6F_gshared (EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit2D>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE EmptyInternalEnumerator_1_get_Current_m80A2ACBC3B0046EDE292A4DDE0674EEE5ED4861B_gshared (EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m80A2ACBC3B0046EDE292A4DDE0674EEE5ED4861B_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m80A2ACBC3B0046EDE292A4DDE0674EEE5ED4861B_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit2D>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m15293AC84EF6DD80C8451975DECFFB24F4D3BE9A_gshared (EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 *)__this);
RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE L_0 = (( RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE (*) (EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit2D>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m9FA1E94720E8678E41518A8D88AE4DFE6D8ED9D1_gshared (EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit2D>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m95A5540D91754F0CF053172ED218FA10D3F2F2A4_gshared (EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit2D>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mD6936AC2FBC1BEEC1DDB8F10EDF6E43E1E8CD316_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 * L_0 = (EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t225D9CDC9391862F71E9261182050FE6884DEDC0_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mD154522A22B564DD7D9DEC4AD0382BA1A2AC0705_gshared (EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mA6051A48AF41564224349DD3EC6C3E9C063950A5_gshared (EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3 EmptyInternalEnumerator_1_get_Current_m7724FEA10A3B810C3543323AE7A1F3B663972FF5_gshared (EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m7724FEA10A3B810C3543323AE7A1F3B663972FF5_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m7724FEA10A3B810C3543323AE7A1F3B663972FF5_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCBF1F83496AC548766D0710769F4EA774F2C1924_gshared (EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E *)__this);
RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3 L_0 = (( RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3 (*) (EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m7017F8B6F4D0497F6B2E0F002555DD4294DED08B_gshared (EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m93CD212DC63D0C56FFAA8BEE7DF2E77C687AD8CE_gshared (EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.RaycastHit>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m27F83D3D2B619EC057667741684C7DE3BA6B2007_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E * L_0 = (EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t6F20F9CA77382E3686B6E3CEC733870851322F6E_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Rendering.BatchVisibility>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mD809CD69C4E0C6AD2903063961C5AE9D109351BA_gshared (EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.Rendering.BatchVisibility>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m2120DE7E8B001DB150477C35D3196427A06EF1F5_gshared (EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.Rendering.BatchVisibility>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR BatchVisibility_t56334E279A62622BD0640403186E9A1017CF3062 EmptyInternalEnumerator_1_get_Current_m2AF423D17198E438C0EFC65B276D2C53E684A093_gshared (EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m2AF423D17198E438C0EFC65B276D2C53E684A093_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m2AF423D17198E438C0EFC65B276D2C53E684A093_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.Rendering.BatchVisibility>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m5E8900A484192CF525FA0829C0323F61271B1060_gshared (EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 *)__this);
BatchVisibility_t56334E279A62622BD0640403186E9A1017CF3062 L_0 = (( BatchVisibility_t56334E279A62622BD0640403186E9A1017CF3062 (*) (EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
BatchVisibility_t56334E279A62622BD0640403186E9A1017CF3062 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Rendering.BatchVisibility>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m73F4B8A7A83124B7F5D62FB5FEE4BEDD0B7F0DA4_gshared (EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Rendering.BatchVisibility>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m65832E639D346AB1500FFC26711CCE75A759E07E_gshared (EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Rendering.BatchVisibility>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m71221674A967AD07588656CEF06743508A32882C_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 * L_0 = (EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t07C320832EAEC93E6C3D89E030C1CEBC7B8D6E52_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.SendMouseEvents_HitInfo>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m2D59EFCD6394C975399962A2ACBA104CF16F8ACD_gshared (EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.SendMouseEvents_HitInfo>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m2E81D1FFC0A8D6330BD65C4E1D7D2FC265CEEB4D_gshared (EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.SendMouseEvents_HitInfo>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR HitInfo_t2B010E637D28B522E704FDA56FAE6DA9979D8746 EmptyInternalEnumerator_1_get_Current_m8D6D84541FA8C039CE3800A657E8640AFFCD1063_gshared (EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m8D6D84541FA8C039CE3800A657E8640AFFCD1063_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m8D6D84541FA8C039CE3800A657E8640AFFCD1063_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.SendMouseEvents_HitInfo>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m324D1F09EE7EEBCF76F96C9290C9C407DE6A3C14_gshared (EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 *)__this);
HitInfo_t2B010E637D28B522E704FDA56FAE6DA9979D8746 L_0 = (( HitInfo_t2B010E637D28B522E704FDA56FAE6DA9979D8746 (*) (EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
HitInfo_t2B010E637D28B522E704FDA56FAE6DA9979D8746 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.SendMouseEvents_HitInfo>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m2CD701F011AB4442D5845718E38F62BCED2E37EF_gshared (EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.SendMouseEvents_HitInfo>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m36B68EDEE8A066C41C7791C8975965B5712BDDAE_gshared (EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.SendMouseEvents_HitInfo>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m000007BA65CB152CE3BCBA982041FB872CD9D6CA_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 * L_0 = (EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tEAA744866B0662AE1F21F7EBB00A07C988E548B5_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcAchievementData>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mE3EB6A5C71C6D4FBA96CD38F3B988360409E67C2_gshared (EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcAchievementData>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mF159BEF7794646909777D4F1B54CBF1697E3DD17_gshared (EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcAchievementData>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR GcAchievementData_t5CBCF44628981C91C76C552716A7D551670DCE55 EmptyInternalEnumerator_1_get_Current_m70740947394191A6C9D5A4BE101FBE4AB834E6E5_gshared (EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m70740947394191A6C9D5A4BE101FBE4AB834E6E5_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m70740947394191A6C9D5A4BE101FBE4AB834E6E5_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcAchievementData>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m90843AFDDD00C0724E6768A982A1CF0EFAF83D19_gshared (EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 *)__this);
GcAchievementData_t5CBCF44628981C91C76C552716A7D551670DCE55 L_0 = (( GcAchievementData_t5CBCF44628981C91C76C552716A7D551670DCE55 (*) (EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
GcAchievementData_t5CBCF44628981C91C76C552716A7D551670DCE55 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcAchievementData>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m4374CC9E188CAE587AABCDD5F43F99DB91CCBF20_gshared (EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcAchievementData>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mCE60CE4251CA95993C6CF793B2B27A828E421580_gshared (EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcAchievementData>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m1B39B2ECEB6DAFA0417E08E43193682646E4680F_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 * L_0 = (EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t6DF1AE9241018683052636BDD6C611206198DAB1_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcScoreData>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mE3E21EABD5A77312A3322D88D918666F0EDA2175_gshared (EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcScoreData>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m5A4E87ED74B179A1EFDC5D6DF519ECEA84021C2B_gshared (EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcScoreData>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR GcScoreData_t45EF6CC4038C34CE5823D33D1978C5A3F2E0D09A EmptyInternalEnumerator_1_get_Current_m596FBD0FF13E8AC079AF1E3FCBF59FD8BFF0076E_gshared (EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m596FBD0FF13E8AC079AF1E3FCBF59FD8BFF0076E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m596FBD0FF13E8AC079AF1E3FCBF59FD8BFF0076E_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcScoreData>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9B295B7477FC68CE4382358204C4BFB21DA6CEE5_gshared (EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 *)__this);
GcScoreData_t45EF6CC4038C34CE5823D33D1978C5A3F2E0D09A L_0 = (( GcScoreData_t45EF6CC4038C34CE5823D33D1978C5A3F2E0D09A (*) (EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
GcScoreData_t45EF6CC4038C34CE5823D33D1978C5A3F2E0D09A L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcScoreData>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mBEDB4687B0C614A5A6613D57379E97376714D7B6_gshared (EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcScoreData>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m2489F693B934921C994DFF347375396C1212E2E2_gshared (EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.SocialPlatforms.GameCenter.GcScoreData>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m1CC69DE5944E84C6835DA7E65794E04262E6CF2A_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 * L_0 = (EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tB5352BD3258DAE704E86C7E32009BF95F1614D16_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.ColorBlock>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mEC0B0B037FEB3A747AA545783A19018B6918A9E7_gshared (EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.ColorBlock>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m107CE608E39FEA15CC9FED01D3C7E0D75A8E0763_gshared (EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.ColorBlock>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ColorBlock_t93B54DF6E8D65D24CEA9726CA745E48C53E3B1EA EmptyInternalEnumerator_1_get_Current_mA8EDB09064057A0786F373AD65D2D1BD26181070_gshared (EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mA8EDB09064057A0786F373AD65D2D1BD26181070_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mA8EDB09064057A0786F373AD65D2D1BD26181070_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.ColorBlock>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1322C9A3E19F32A024AE02C0785822BA47608AEF_gshared (EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D *)__this);
ColorBlock_t93B54DF6E8D65D24CEA9726CA745E48C53E3B1EA L_0 = (( ColorBlock_t93B54DF6E8D65D24CEA9726CA745E48C53E3B1EA (*) (EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
ColorBlock_t93B54DF6E8D65D24CEA9726CA745E48C53E3B1EA L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.ColorBlock>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m32F7D8F10009CC3759968D782C4CC3D8F1517D72_gshared (EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.ColorBlock>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mC1CE5D504042E680AF89CF74DE5B2DB6BF6E391E_gshared (EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.ColorBlock>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m4C04A5B89B3D6DD863E6520C5259ABCEA51E26C7_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D * L_0 = (EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t580BB4F123AFC13ACA3E68B118A93175F88F921D_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.Navigation>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m41ABEB9B453A3631FFFDFA368CCD18C1E48A5616_gshared (EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.Navigation>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mDBCE008DCEE28982E617169E16410FC5E544893E_gshared (EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.Navigation>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Navigation_t761250C05C09773B75F5E0D52DDCBBFE60288A07 EmptyInternalEnumerator_1_get_Current_mD62451B7245670D9AC8F19B55DD0D3E70E56CD3A_gshared (EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mD62451B7245670D9AC8F19B55DD0D3E70E56CD3A_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mD62451B7245670D9AC8F19B55DD0D3E70E56CD3A_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.Navigation>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m467173561A9CB7439293AF7BAD944F2181CCCD73_gshared (EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 *)__this);
Navigation_t761250C05C09773B75F5E0D52DDCBBFE60288A07 L_0 = (( Navigation_t761250C05C09773B75F5E0D52DDCBBFE60288A07 (*) (EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Navigation_t761250C05C09773B75F5E0D52DDCBBFE60288A07 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.Navigation>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_mCF96FACFC89D4D345EDB66A885EB8F8587C8CCDE_gshared (EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.Navigation>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mB29799154A0BFDB882BB9434C4F69F689926EE02_gshared (EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.Navigation>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mBBDB3F8A0ABB291EAC510E359A4456514761568E_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 * L_0 = (EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tBAADD11CB54B4B4FADEE067DA99738FA924872C2_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.SpriteState>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m7D2B94488217A9131D90E3048E751DD940752CD5_gshared (EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.SpriteState>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mBAC08A40A7B32AB9B51EF67E528C4020AB15FC29_gshared (EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.SpriteState>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR SpriteState_t58B9DD66A79CD69AB4CFC3AD0C41E45DC2192C0A EmptyInternalEnumerator_1_get_Current_m5A7A5AF62CCF46153A47CEF59A43C83C6D92BB56_gshared (EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m5A7A5AF62CCF46153A47CEF59A43C83C6D92BB56_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m5A7A5AF62CCF46153A47CEF59A43C83C6D92BB56_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.SpriteState>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8F8F3B4D9E5959D60DE8DE95C4A5E430530AEC89_gshared (EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA *)__this);
SpriteState_t58B9DD66A79CD69AB4CFC3AD0C41E45DC2192C0A L_0 = (( SpriteState_t58B9DD66A79CD69AB4CFC3AD0C41E45DC2192C0A (*) (EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
SpriteState_t58B9DD66A79CD69AB4CFC3AD0C41E45DC2192C0A L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.SpriteState>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m46F118A087114EE97720896A55D134D7562DEBA3_gshared (EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.SpriteState>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m53BF3EFF9BAA97530331F890B89A1B543019C058_gshared (EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UI.SpriteState>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m35A500252094AACCA194CB4E61D60F3AA2BE1A9A_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA * L_0 = (EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_tBABE923CA4F5D19955F75E3D2580BCBB187356AA_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UICharInfo>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mA5E45F8E7E2AB481C787CFE3810E9282AF433078_gshared (EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.UICharInfo>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mD3D59ABF98B2DBE693895AE4685E0E4536704262_gshared (EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.UICharInfo>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UICharInfo_tB4C92043A686A600D36A92E3108F173C499E318A EmptyInternalEnumerator_1_get_Current_m6B46980E651EA5A3FDFDF0E11A514D4392774364_gshared (EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m6B46980E651EA5A3FDFDF0E11A514D4392774364_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m6B46980E651EA5A3FDFDF0E11A514D4392774364_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.UICharInfo>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m7E272A2E2D1A0AC2E9454F33224FE45C30C1536F_gshared (EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 *)__this);
UICharInfo_tB4C92043A686A600D36A92E3108F173C499E318A L_0 = (( UICharInfo_tB4C92043A686A600D36A92E3108F173C499E318A (*) (EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
UICharInfo_tB4C92043A686A600D36A92E3108F173C499E318A L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UICharInfo>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m36FB135E48B17756356587E52E6767C5411EF34E_gshared (EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UICharInfo>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m30CC63200217E1CBA09844CEBFE3DD1D9331A271_gshared (EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UICharInfo>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m2A21B9878AEC9BD4BB3C18303FEB004E9CC76882_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 * L_0 = (EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t3A0BE135137A57E9DEC74963AFE74EE4C1287600_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UILineInfo>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mB4F4B74EE9A6165236D0F30AC4536F76AF1DF72F_gshared (EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.UILineInfo>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m6B27B17FBDB5E24F612E6426D8E84DC1EA97CB04_gshared (EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.UILineInfo>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UILineInfo_t0AF27251CA07CEE2BC0C1FEF752245596B8033E6 EmptyInternalEnumerator_1_get_Current_mDA9F64CC2753664296C3D3E7AA3AB26DEDDCA164_gshared (EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mDA9F64CC2753664296C3D3E7AA3AB26DEDDCA164_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mDA9F64CC2753664296C3D3E7AA3AB26DEDDCA164_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.UILineInfo>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1419B3FB87D09532CD363F704B6DCAAA0834581B_gshared (EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B *)__this);
UILineInfo_t0AF27251CA07CEE2BC0C1FEF752245596B8033E6 L_0 = (( UILineInfo_t0AF27251CA07CEE2BC0C1FEF752245596B8033E6 (*) (EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
UILineInfo_t0AF27251CA07CEE2BC0C1FEF752245596B8033E6 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UILineInfo>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m86C8E4CA416DD50F25D7711A40B91F23D899BB89_gshared (EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UILineInfo>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m262BE510CF58740852EA27C45D493E7E6393D6F4_gshared (EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UILineInfo>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m72B71364B1DA4A7C8DD66E4DE5F7A834C01AE5D2_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B * L_0 = (EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t499E02D48A3FE44714F9DEF9AF52F06397505B4B_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UIVertex>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m25AC9141B70EF7672E761857483778957F937C5F_gshared (EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.UIVertex>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m4BEDAD1CEBC6798AC2481EFDC220F815AF7DDA63_gshared (EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.UIVertex>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577 EmptyInternalEnumerator_1_get_Current_m8444FDF54FEBD602CA48F528EC463DB1AC8082E6_gshared (EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m8444FDF54FEBD602CA48F528EC463DB1AC8082E6_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m8444FDF54FEBD602CA48F528EC463DB1AC8082E6_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.UIVertex>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m04456036D4A0F0FE1A06B9BF5D2B14A434C297E1_gshared (EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 *)__this);
UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577 L_0 = (( UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577 (*) (EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
UIVertex_t0583C35B730B218B542E80203F5F4BC6F1E9E577 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UIVertex>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m98E6B2CC5A357F3731721AC692C339070CA7FF1D_gshared (EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UIVertex>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m785F57F33D62D0F08630E6A38620E3D58EBC064D_gshared (EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UIVertex>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mF55ED7B3F99A86314E3F7D73BDDB7500C0BA2DCF_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 * L_0 = (EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t2740FD48AD2881871812C41BED5418833BB50EF8_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UnitySynchronizationContext_WorkRequest>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mA76C8463791EBDF7F0D7F27473F43E56F926E159_gshared (EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.UnitySynchronizationContext_WorkRequest>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m013BA51DE1474366B9A3E4D10A15085A668393C2_gshared (EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.UnitySynchronizationContext_WorkRequest>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR WorkRequest_t0247B62D135204EAA95FC0B2EC829CB27B433F94 EmptyInternalEnumerator_1_get_Current_mA06904B635841F0E7F80D2F769DE07A6ED082B01_gshared (EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mA06904B635841F0E7F80D2F769DE07A6ED082B01_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mA06904B635841F0E7F80D2F769DE07A6ED082B01_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.UnitySynchronizationContext_WorkRequest>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m5DAD4EDC5BE8A90F7BC0351132C5625302924E49_gshared (EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 *)__this);
WorkRequest_t0247B62D135204EAA95FC0B2EC829CB27B433F94 L_0 = (( WorkRequest_t0247B62D135204EAA95FC0B2EC829CB27B433F94 (*) (EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
WorkRequest_t0247B62D135204EAA95FC0B2EC829CB27B433F94 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UnitySynchronizationContext_WorkRequest>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m9286D4A4CC7DBEDEB07EFC8394DE5D8120191BF7_gshared (EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UnitySynchronizationContext_WorkRequest>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m4EECC4BE2811165D38A56F56F2D51B58358FBE79_gshared (EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.UnitySynchronizationContext_WorkRequest>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m26E59A8A745C59DDD69BE53431366D5B97127938_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 * L_0 = (EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t8D862EE820CF8AB9C4F52E7392C08EA876B42E27_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector2>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m3658448E0B5767985C528AFF6C4DE5AD782A14CD_gshared (EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector2>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mBBA5FCF8F4C0842ED73416B0DA2B86C4B5D1A2D6_gshared (EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector2>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector2_tA85D2DD88578276CA8A8796756458277E72D073D EmptyInternalEnumerator_1_get_Current_m6F736FA9A64A4731F43C0EB684DEC9FC7827B12F_gshared (EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_m6F736FA9A64A4731F43C0EB684DEC9FC7827B12F_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_m6F736FA9A64A4731F43C0EB684DEC9FC7827B12F_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector2>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m5A3BE141AF235708EF642F4DA946ADE56B387964_gshared (EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 *)__this);
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D L_0 = (( Vector2_tA85D2DD88578276CA8A8796756458277E72D073D (*) (EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Vector2_tA85D2DD88578276CA8A8796756458277E72D073D L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector2>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m286BB7385593F5EB5ADF542E3A2A5800F92E3BF7_gshared (EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector2>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mB88144101A59F21B94E25E998F0ED4FACF57FB6D_gshared (EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector2>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m786657A71FD55FF1E723B8C57B80DAE99B0160ED_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 * L_0 = (EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t9B0D4BFF056ECE2655B8DFAFC80C33C9FC92E508_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector3>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_m0B302018A1FEC194A7C5554790F64292FB1CA62F_gshared (EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector3>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_m72526770163050DACA7D336D671C66CE8DB8B7A4_gshared (EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector3>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 EmptyInternalEnumerator_1_get_Current_mA4E7989BC90D09B31EEDA1BDF04507D72F72A2A8_gshared (EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mA4E7989BC90D09B31EEDA1BDF04507D72F72A2A8_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mA4E7989BC90D09B31EEDA1BDF04507D72F72A2A8_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector3>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_m10838E3814D876DC0A829116CD5958BAFBF091FC_gshared (EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC *)__this);
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 L_0 = (( Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 (*) (EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Vector3_tDCF05E21F632FE2BA260C06E0D10CA81513E6720 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector3>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m85653A4F0E6C0A3EA92D4B3A81A36AD950D46B36_gshared (EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector3>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_mC22C9AA8A5BA65322686E45BFBEE278014A4BF8D_gshared (EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector3>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_m79E766FE359516E0865E69FD5694C230ABBAC28C_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC * L_0 = (EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t812F2999EDAAB9ABAB8F78DE0F38BEF371B235CC_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector4>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_Dispose_mD1F7828EE1D2F1A60110B261CC2D3EF84A78709B_gshared (EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Boolean System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector4>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EmptyInternalEnumerator_1_MoveNext_mC99C5CCA7A63ECA71EADACB69E4F7CA7CC86E2C8_gshared (EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 * __this, const RuntimeMethod* method)
{
{
return (bool)0;
}
}
// T System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector4>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E EmptyInternalEnumerator_1_get_Current_mC5BA4F2C682C18C4A01CECEDC74DE8D4FEAAD27C_gshared (EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (EmptyInternalEnumerator_1_get_Current_mC5BA4F2C682C18C4A01CECEDC74DE8D4FEAAD27C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_0, EmptyInternalEnumerator_1_get_Current_mC5BA4F2C682C18C4A01CECEDC74DE8D4FEAAD27C_RuntimeMethod_var);
}
}
// System.Object System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector4>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * EmptyInternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD97F089B0C34998A140AABD701FEA5EBB48F35EB_gshared (EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 * __this, const RuntimeMethod* method)
{
{
NullCheck((EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 *)__this);
Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E L_0 = (( Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E (*) (EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0)->methodPointer)((EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(method->klass->rgctx_data, 0));
Vector4_tD148D6428C3F8FF6CD998F82090113C2B490B76E L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(method->klass->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector4>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1_System_Collections_IEnumerator_Reset_m3F3D068D4CDEA13B23EA421AB7438DC892192A3F_gshared (EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 * __this, const RuntimeMethod* method)
{
{
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector4>::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__ctor_m79BCD40B26B6FDA4F75DBFDF0CE8729A91432FAA_gshared (EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 * __this, const RuntimeMethod* method)
{
{
NullCheck((RuntimeObject *)__this);
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0((RuntimeObject *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Array_EmptyInternalEnumerator`1<UnityEngine.Vector4>::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void EmptyInternalEnumerator_1__cctor_mB74D19CC5CF30C4BC49340C67BB7E20A08AAB2AC_gshared (const RuntimeMethod* method)
{
{
EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 * L_0 = (EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 *)il2cpp_codegen_object_new(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2));
(( void (*) (EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281 *, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3)->methodPointer)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 3));
((EmptyInternalEnumerator_1_t7F7E008DE3C47E124E84D13777D42CF2DEC1B281_StaticFields*)il2cpp_codegen_static_fields_for(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 4)))->set_Value_0(L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mB435979A4FC207D777BBBEDCBE6DBD47F06FC2D3_gshared (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mB435979A4FC207D777BBBEDCBE6DBD47F06FC2D3_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F *>(__this + _offset);
InternalEnumerator_1__ctor_mB435979A4FC207D777BBBEDCBE6DBD47F06FC2D3(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m9FFA4290ED807AF40BD2E60F26023529593AA5A0_gshared (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m9FFA4290ED807AF40BD2E60F26023529593AA5A0_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F *>(__this + _offset);
InternalEnumerator_1_Dispose_m9FFA4290ED807AF40BD2E60F26023529593AA5A0(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m19B8C2E6A68876BE54C2C35DD948B7C496D98546_gshared (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m19B8C2E6A68876BE54C2C35DD948B7C496D98546_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m19B8C2E6A68876BE54C2C35DD948B7C496D98546(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TableRange_t485CF0807771CC05023466CFCB0AE25C46648100 InternalEnumerator_1_get_Current_m5BF1362D0455A86D563CA0FE18879952C871ABC3_gshared (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m5BF1362D0455A86D563CA0FE18879952C871ABC3_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m5BF1362D0455A86D563CA0FE18879952C871ABC3_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m5BF1362D0455A86D563CA0FE18879952C871ABC3_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
TableRange_t485CF0807771CC05023466CFCB0AE25C46648100 L_8 = (( TableRange_t485CF0807771CC05023466CFCB0AE25C46648100 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C TableRange_t485CF0807771CC05023466CFCB0AE25C46648100 InternalEnumerator_1_get_Current_m5BF1362D0455A86D563CA0FE18879952C871ABC3_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F *>(__this + _offset);
return InternalEnumerator_1_get_Current_m5BF1362D0455A86D563CA0FE18879952C871ABC3(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC74FE1FCF522A51276B59B78AF8420D1E2F6AEA7_gshared (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC74FE1FCF522A51276B59B78AF8420D1E2F6AEA7_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC74FE1FCF522A51276B59B78AF8420D1E2F6AEA7(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer_TableRange>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD6A7480B222C2ED4423DFA000737E0286A78A130_gshared (InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * __this, const RuntimeMethod* method)
{
{
TableRange_t485CF0807771CC05023466CFCB0AE25C46648100 L_0 = InternalEnumerator_1_get_Current_m5BF1362D0455A86D563CA0FE18879952C871ABC3((InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F *)(InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
TableRange_t485CF0807771CC05023466CFCB0AE25C46648100 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD6A7480B222C2ED4423DFA000737E0286A78A130_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8774DE4581B922EC542DFDEAF08CF8AA2C57120F *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD6A7480B222C2ED4423DFA000737E0286A78A130(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Boolean>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mC6576DE9DFD26D645933F33DDFFF5C193BD2C64F_gshared (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mC6576DE9DFD26D645933F33DDFFF5C193BD2C64F_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 *>(__this + _offset);
InternalEnumerator_1__ctor_mC6576DE9DFD26D645933F33DDFFF5C193BD2C64F(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Boolean>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mAA797BBD83F736868FA6A8E186371BEADFC9A7CA_gshared (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mAA797BBD83F736868FA6A8E186371BEADFC9A7CA_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 *>(__this + _offset);
InternalEnumerator_1_Dispose_mAA797BBD83F736868FA6A8E186371BEADFC9A7CA(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Boolean>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m5D14BBDC6E172C9CFF85357EDA146D2F493191EC_gshared (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m5D14BBDC6E172C9CFF85357EDA146D2F493191EC_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m5D14BBDC6E172C9CFF85357EDA146D2F493191EC(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Boolean>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_get_Current_m0E37DD99400FD8E67350E2959B777C353662D4AE_gshared (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m0E37DD99400FD8E67350E2959B777C353662D4AE_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m0E37DD99400FD8E67350E2959B777C353662D4AE_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m0E37DD99400FD8E67350E2959B777C353662D4AE_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
bool L_8 = (( bool (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_get_Current_m0E37DD99400FD8E67350E2959B777C353662D4AE_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m0E37DD99400FD8E67350E2959B777C353662D4AE(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Boolean>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mBF9C54BE8A4A3C352F42280C1B76AD173905241D_gshared (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mBF9C54BE8A4A3C352F42280C1B76AD173905241D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mBF9C54BE8A4A3C352F42280C1B76AD173905241D(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Boolean>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m406897CA7EC01C35D90402E4AA916647716FB767_gshared (InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * __this, const RuntimeMethod* method)
{
{
bool L_0 = InternalEnumerator_1_get_Current_m0E37DD99400FD8E67350E2959B777C353662D4AE((InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 *)(InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
bool L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m406897CA7EC01C35D90402E4AA916647716FB767_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tF5A9E5AD2CED6732444D5ECC4F8FC82526717590 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m406897CA7EC01C35D90402E4AA916647716FB767(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Byte>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mCE5D4D9E3057660C094936737BA70F2ADE3646F9_gshared (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mCE5D4D9E3057660C094936737BA70F2ADE3646F9_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC *>(__this + _offset);
InternalEnumerator_1__ctor_mCE5D4D9E3057660C094936737BA70F2ADE3646F9(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Byte>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mC32656E5117A66CF11FF1BEA4C941AA4034677AC_gshared (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mC32656E5117A66CF11FF1BEA4C941AA4034677AC_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC *>(__this + _offset);
InternalEnumerator_1_Dispose_mC32656E5117A66CF11FF1BEA4C941AA4034677AC(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Byte>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mBA8D7A7C9CD1D0771BB9638FB7A0A4D17F5F7F72_gshared (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mBA8D7A7C9CD1D0771BB9638FB7A0A4D17F5F7F72_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mBA8D7A7C9CD1D0771BB9638FB7A0A4D17F5F7F72(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Byte>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t InternalEnumerator_1_get_Current_m8322D35634EA8F36F950C7FC88EA889817413E87_gshared (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m8322D35634EA8F36F950C7FC88EA889817413E87_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m8322D35634EA8F36F950C7FC88EA889817413E87_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m8322D35634EA8F36F950C7FC88EA889817413E87_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
uint8_t L_8 = (( uint8_t (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C uint8_t InternalEnumerator_1_get_Current_m8322D35634EA8F36F950C7FC88EA889817413E87_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC *>(__this + _offset);
return InternalEnumerator_1_get_Current_m8322D35634EA8F36F950C7FC88EA889817413E87(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Byte>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m52D68F77094EDDD9016386AF3F5A5B5781C974D9_gshared (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m52D68F77094EDDD9016386AF3F5A5B5781C974D9_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m52D68F77094EDDD9016386AF3F5A5B5781C974D9(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Byte>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m92570BB2C86AD0B6EB8845B78FF96396A458D6BE_gshared (InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * __this, const RuntimeMethod* method)
{
{
uint8_t L_0 = InternalEnumerator_1_get_Current_m8322D35634EA8F36F950C7FC88EA889817413E87((InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC *)(InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
uint8_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m92570BB2C86AD0B6EB8845B78FF96396A458D6BE_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t982231C5871D8F29B09EC9C0BE904978F13B83AC *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m92570BB2C86AD0B6EB8845B78FF96396A458D6BE(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Char>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mA816E1C13D866A2558DA3C530799B1D3858F80EF_gshared (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mA816E1C13D866A2558DA3C530799B1D3858F80EF_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B *>(__this + _offset);
InternalEnumerator_1__ctor_mA816E1C13D866A2558DA3C530799B1D3858F80EF(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Char>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mDCC22EFC517EA05A44E470F2DA1919EE5A58F9FA_gshared (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mDCC22EFC517EA05A44E470F2DA1919EE5A58F9FA_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B *>(__this + _offset);
InternalEnumerator_1_Dispose_mDCC22EFC517EA05A44E470F2DA1919EE5A58F9FA(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Char>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m3FAA847DFF670AFBF34878A1F45C9B29F5DD973C_gshared (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m3FAA847DFF670AFBF34878A1F45C9B29F5DD973C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m3FAA847DFF670AFBF34878A1F45C9B29F5DD973C(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Char>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar InternalEnumerator_1_get_Current_mF9D5C23927E856F0D50CD0211DD96DED7A737466_gshared (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mF9D5C23927E856F0D50CD0211DD96DED7A737466_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mF9D5C23927E856F0D50CD0211DD96DED7A737466_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mF9D5C23927E856F0D50CD0211DD96DED7A737466_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
Il2CppChar L_8 = (( Il2CppChar (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C Il2CppChar InternalEnumerator_1_get_Current_mF9D5C23927E856F0D50CD0211DD96DED7A737466_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B *>(__this + _offset);
return InternalEnumerator_1_get_Current_mF9D5C23927E856F0D50CD0211DD96DED7A737466(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Char>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m51B86411AC68CD7F9618FF2523FB1199AA56372E_gshared (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m51B86411AC68CD7F9618FF2523FB1199AA56372E_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m51B86411AC68CD7F9618FF2523FB1199AA56372E(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Char>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mDEDC109FF80129362D85F9A7749B1540AFBD07B7_gshared (InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * __this, const RuntimeMethod* method)
{
{
Il2CppChar L_0 = InternalEnumerator_1_get_Current_mF9D5C23927E856F0D50CD0211DD96DED7A737466((InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B *)(InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
Il2CppChar L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mDEDC109FF80129362D85F9A7749B1540AFBD07B7_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t74BF3B5EFFF3E4B3A21E9B8FA2E7EDF302AC247B *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mDEDC109FF80129362D85F9A7749B1540AFBD07B7(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.DictionaryEntry>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mC0890A26F45EB3D0CE722AA211191F47A7D89CAE_gshared (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mC0890A26F45EB3D0CE722AA211191F47A7D89CAE_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 *>(__this + _offset);
InternalEnumerator_1__ctor_mC0890A26F45EB3D0CE722AA211191F47A7D89CAE(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.DictionaryEntry>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mC2FAA1D4D203A9339BBC1340D21F3ED010DDDBAC_gshared (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mC2FAA1D4D203A9339BBC1340D21F3ED010DDDBAC_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 *>(__this + _offset);
InternalEnumerator_1_Dispose_mC2FAA1D4D203A9339BBC1340D21F3ED010DDDBAC(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.DictionaryEntry>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mCB1B8EAAF7F7CBAFAA5F7514553B6DC1038D4AC4_gshared (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mCB1B8EAAF7F7CBAFAA5F7514553B6DC1038D4AC4_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mCB1B8EAAF7F7CBAFAA5F7514553B6DC1038D4AC4(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.DictionaryEntry>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4 InternalEnumerator_1_get_Current_mF60DB3DFAED76189D44BCCA186D595043C014D3E_gshared (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mF60DB3DFAED76189D44BCCA186D595043C014D3E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mF60DB3DFAED76189D44BCCA186D595043C014D3E_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mF60DB3DFAED76189D44BCCA186D595043C014D3E_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4 L_8 = (( DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4 InternalEnumerator_1_get_Current_mF60DB3DFAED76189D44BCCA186D595043C014D3E_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 *>(__this + _offset);
return InternalEnumerator_1_get_Current_mF60DB3DFAED76189D44BCCA186D595043C014D3E(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.DictionaryEntry>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6CB9F8EC8CBE7FD4FADFAB7F64A37B7A7508D691_gshared (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6CB9F8EC8CBE7FD4FADFAB7F64A37B7A7508D691_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6CB9F8EC8CBE7FD4FADFAB7F64A37B7A7508D691(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.DictionaryEntry>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD1EDD7B929F2A9A91509082AEC0A70709B12CEF8_gshared (InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * __this, const RuntimeMethod* method)
{
{
DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4 L_0 = InternalEnumerator_1_get_Current_mF60DB3DFAED76189D44BCCA186D595043C014D3E((InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 *)(InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
DictionaryEntry_tB5348A26B94274FCC1DD77185BD5946E283B11A4 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD1EDD7B929F2A9A91509082AEC0A70709B12CEF8_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tDAD7C4B47A5DEC60EAE933F701F1585FC7959379 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD1EDD7B929F2A9A91509082AEC0A70709B12CEF8(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m826AE3C40B8AFBE65F21024B99461A8E3435394E_gshared (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m826AE3C40B8AFBE65F21024B99461A8E3435394E_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 *>(__this + _offset);
InternalEnumerator_1__ctor_m826AE3C40B8AFBE65F21024B99461A8E3435394E(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m1CBAB604EC0F2F4558305325B30BC790A0684D54_gshared (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m1CBAB604EC0F2F4558305325B30BC790A0684D54_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 *>(__this + _offset);
InternalEnumerator_1_Dispose_m1CBAB604EC0F2F4558305325B30BC790A0684D54(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m007FB57DED6F561D3EEC01BD59C68BFBD9FEA626_gshared (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m007FB57DED6F561D3EEC01BD59C68BFBD9FEA626_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m007FB57DED6F561D3EEC01BD59C68BFBD9FEA626(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D InternalEnumerator_1_get_Current_m4ABCF333B87FC095F8DB1908EE7CB57702BBB20F_gshared (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m4ABCF333B87FC095F8DB1908EE7CB57702BBB20F_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m4ABCF333B87FC095F8DB1908EE7CB57702BBB20F_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m4ABCF333B87FC095F8DB1908EE7CB57702BBB20F_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D L_8 = (( Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D InternalEnumerator_1_get_Current_m4ABCF333B87FC095F8DB1908EE7CB57702BBB20F_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m4ABCF333B87FC095F8DB1908EE7CB57702BBB20F(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC24466541138E727EBE50B0E0A22F6651161EB71_gshared (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC24466541138E727EBE50B0E0A22F6651161EB71_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC24466541138E727EBE50B0E0A22F6651161EB71(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Int32,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9369158204F4280AA8C76BD2E47E8A91C9FDC053_gshared (InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * __this, const RuntimeMethod* method)
{
{
Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D L_0 = InternalEnumerator_1_get_Current_m4ABCF333B87FC095F8DB1908EE7CB57702BBB20F((InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 *)(InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
Entry_t7D7748D5ED1AF0BF0D2AE30579C5C71A06D98D3D L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9369158204F4280AA8C76BD2E47E8A91C9FDC053_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t02A92EB825760093D375D7DB9530ED1BBACE0EC0 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9369158204F4280AA8C76BD2E47E8A91C9FDC053(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m56019387E27A8E3481BDF2669CDE33C7899A4ECB_gshared (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m56019387E27A8E3481BDF2669CDE33C7899A4ECB_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 *>(__this + _offset);
InternalEnumerator_1__ctor_m56019387E27A8E3481BDF2669CDE33C7899A4ECB(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m1F2BED538F9A714FDD0663B4E12CEF6D82CD9459_gshared (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m1F2BED538F9A714FDD0663B4E12CEF6D82CD9459_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 *>(__this + _offset);
InternalEnumerator_1_Dispose_m1F2BED538F9A714FDD0663B4E12CEF6D82CD9459(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m47F7361F7276ED03BEF7B9E04EC7431ACAAE6906_gshared (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m47F7361F7276ED03BEF7B9E04EC7431ACAAE6906_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m47F7361F7276ED03BEF7B9E04EC7431ACAAE6906(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE InternalEnumerator_1_get_Current_m92BB9CC66A8467F196EA707E00E7186FA64AE48B_gshared (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m92BB9CC66A8467F196EA707E00E7186FA64AE48B_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m92BB9CC66A8467F196EA707E00E7186FA64AE48B_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m92BB9CC66A8467F196EA707E00E7186FA64AE48B_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE L_8 = (( Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE InternalEnumerator_1_get_Current_m92BB9CC66A8467F196EA707E00E7186FA64AE48B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m92BB9CC66A8467F196EA707E00E7186FA64AE48B(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5D43D1F4D741863D821F9E78A4A608F58B2485DF_gshared (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5D43D1F4D741863D821F9E78A4A608F58B2485DF_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5D43D1F4D741863D821F9E78A4A608F58B2485DF(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Int32>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1E60E687D9B216101D35FA36C1D0EF48FF5C5F27_gshared (InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * __this, const RuntimeMethod* method)
{
{
Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE L_0 = InternalEnumerator_1_get_Current_m92BB9CC66A8467F196EA707E00E7186FA64AE48B((InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 *)(InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
Entry_t06E52CC4FA420E7C4AC082F266C2BBBC94AF8ECE L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1E60E687D9B216101D35FA36C1D0EF48FF5C5F27_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t39D8B84AE4BB6C55B6200CDB7081CE440B2B93D2 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1E60E687D9B216101D35FA36C1D0EF48FF5C5F27(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m1593CE384E20D884D915D8C63DB0063790B3A618_gshared (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m1593CE384E20D884D915D8C63DB0063790B3A618_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A *>(__this + _offset);
InternalEnumerator_1__ctor_m1593CE384E20D884D915D8C63DB0063790B3A618(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m4836500B7FEA20ACA83183ECBE1D467826FCE670_gshared (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m4836500B7FEA20ACA83183ECBE1D467826FCE670_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A *>(__this + _offset);
InternalEnumerator_1_Dispose_m4836500B7FEA20ACA83183ECBE1D467826FCE670(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m48BA3A9AC0BA051915D58DFCA32B1AA5C09DE957_gshared (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m48BA3A9AC0BA051915D58DFCA32B1AA5C09DE957_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m48BA3A9AC0BA051915D58DFCA32B1AA5C09DE957(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA InternalEnumerator_1_get_Current_mC2EC065F63466F7E6AD6C9AE9BC86A3B0CF0E07A_gshared (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mC2EC065F63466F7E6AD6C9AE9BC86A3B0CF0E07A_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mC2EC065F63466F7E6AD6C9AE9BC86A3B0CF0E07A_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mC2EC065F63466F7E6AD6C9AE9BC86A3B0CF0E07A_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA L_8 = (( Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA InternalEnumerator_1_get_Current_mC2EC065F63466F7E6AD6C9AE9BC86A3B0CF0E07A_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A *>(__this + _offset);
return InternalEnumerator_1_get_Current_mC2EC065F63466F7E6AD6C9AE9BC86A3B0CF0E07A(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m9C6C41648ADC7B60E8AF51190EEA7BAA8FA93241_gshared (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m9C6C41648ADC7B60E8AF51190EEA7BAA8FA93241_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m9C6C41648ADC7B60E8AF51190EEA7BAA8FA93241(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1536DF98255D34522AB9DC5D47835095718FF3DA_gshared (InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * __this, const RuntimeMethod* method)
{
{
Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA L_0 = InternalEnumerator_1_get_Current_mC2EC065F63466F7E6AD6C9AE9BC86A3B0CF0E07A((InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A *)(InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
Entry_t03898C03E4E291FD6780D28D81A25E3CACF2BADA L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1536DF98255D34522AB9DC5D47835095718FF3DA_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7FA630CCED20A6761747E42B8146CC87AAEA4D0A *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1536DF98255D34522AB9DC5D47835095718FF3DA(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m41F1B4440445674E22696F369E1BE49F6B8B7325_gshared (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m41F1B4440445674E22696F369E1BE49F6B8B7325_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA *>(__this + _offset);
InternalEnumerator_1__ctor_m41F1B4440445674E22696F369E1BE49F6B8B7325(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mEEFF36A65ACDF8534CC4A049CF142B6757C1BC98_gshared (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mEEFF36A65ACDF8534CC4A049CF142B6757C1BC98_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA *>(__this + _offset);
InternalEnumerator_1_Dispose_mEEFF36A65ACDF8534CC4A049CF142B6757C1BC98(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m1CCFAA43E5AEFCE61B8B581971072C0CE3D847C7_gshared (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m1CCFAA43E5AEFCE61B8B581971072C0CE3D847C7_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m1CCFAA43E5AEFCE61B8B581971072C0CE3D847C7(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D InternalEnumerator_1_get_Current_m3B5BD0D9A3A2B90B762F783677926F8ED30B67C1_gshared (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m3B5BD0D9A3A2B90B762F783677926F8ED30B67C1_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m3B5BD0D9A3A2B90B762F783677926F8ED30B67C1_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m3B5BD0D9A3A2B90B762F783677926F8ED30B67C1_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D L_8 = (( Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D InternalEnumerator_1_get_Current_m3B5BD0D9A3A2B90B762F783677926F8ED30B67C1_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA *>(__this + _offset);
return InternalEnumerator_1_get_Current_m3B5BD0D9A3A2B90B762F783677926F8ED30B67C1(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m07F10BD620954A735C3091217347BBD9B523B1CB_gshared (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m07F10BD620954A735C3091217347BBD9B523B1CB_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m07F10BD620954A735C3091217347BBD9B523B1CB(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2A449599FC893C43B822B70233F3E79FD26F6959_gshared (InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * __this, const RuntimeMethod* method)
{
{
Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D L_0 = InternalEnumerator_1_get_Current_m3B5BD0D9A3A2B90B762F783677926F8ED30B67C1((InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA *)(InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
Entry_tF9DF2A46F3E6119E3AF03BA9B2FA24224378770D L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2A449599FC893C43B822B70233F3E79FD26F6959_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t643EC2EA2BC458AEB6722E02F1FA22FE544C13AA *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2A449599FC893C43B822B70233F3E79FD26F6959(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m0BD0412D0302697F86E43B6F22BB445661F64C8F_gshared (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m0BD0412D0302697F86E43B6F22BB445661F64C8F_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E *>(__this + _offset);
InternalEnumerator_1__ctor_m0BD0412D0302697F86E43B6F22BB445661F64C8F(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m63B89FFEB305B542ABA20AD4FA3B515603DF2F56_gshared (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m63B89FFEB305B542ABA20AD4FA3B515603DF2F56_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E *>(__this + _offset);
InternalEnumerator_1_Dispose_m63B89FFEB305B542ABA20AD4FA3B515603DF2F56(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m4462B2E5033D638D7F461862D3245ADC40CB5FFB_gshared (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m4462B2E5033D638D7F461862D3245ADC40CB5FFB_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m4462B2E5033D638D7F461862D3245ADC40CB5FFB(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29 InternalEnumerator_1_get_Current_m902312010187A018147C6FDDC77113E4B125EC6C_gshared (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m902312010187A018147C6FDDC77113E4B125EC6C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m902312010187A018147C6FDDC77113E4B125EC6C_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m902312010187A018147C6FDDC77113E4B125EC6C_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29 L_8 = (( Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29 InternalEnumerator_1_get_Current_m902312010187A018147C6FDDC77113E4B125EC6C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E *>(__this + _offset);
return InternalEnumerator_1_get_Current_m902312010187A018147C6FDDC77113E4B125EC6C(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mAB47E5373DD3C694D393ECB5B841B38C1A908386_gshared (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mAB47E5373DD3C694D393ECB5B841B38C1A908386_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mAB47E5373DD3C694D393ECB5B841B38C1A908386(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Generic.Dictionary`2_Entry<System.UInt64,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCC02E335DAEB2C190189E5DA6C80C283CFF68D13_gshared (InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * __this, const RuntimeMethod* method)
{
{
Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29 L_0 = InternalEnumerator_1_get_Current_m902312010187A018147C6FDDC77113E4B125EC6C((InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E *)(InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
Entry_tF00169F106D087C791655821B46CB7BBDEAC4A29 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCC02E335DAEB2C190189E5DA6C80C283CFF68D13_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC14609DE239C2027BC899ECE2E9BC7179D275E4E *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCC02E335DAEB2C190189E5DA6C80C283CFF68D13(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m2047B6F070C9C5C4D9EF6147976F1ED4E28AF602_gshared (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m2047B6F070C9C5C4D9EF6147976F1ED4E28AF602_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 *>(__this + _offset);
InternalEnumerator_1__ctor_m2047B6F070C9C5C4D9EF6147976F1ED4E28AF602(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m08900DA592D66440E18F7945EAD98B17C6C62404_gshared (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m08900DA592D66440E18F7945EAD98B17C6C62404_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 *>(__this + _offset);
InternalEnumerator_1_Dispose_m08900DA592D66440E18F7945EAD98B17C6C62404(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mB8FCAF454999038E9D103E26E7DE8D471D680DE9_gshared (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mB8FCAF454999038E9D103E26E7DE8D471D680DE9_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mB8FCAF454999038E9D103E26E7DE8D471D680DE9(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279 InternalEnumerator_1_get_Current_m219A6F6D4C2AEE8F86D69E8CED72AB8566CECBFA_gshared (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m219A6F6D4C2AEE8F86D69E8CED72AB8566CECBFA_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m219A6F6D4C2AEE8F86D69E8CED72AB8566CECBFA_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m219A6F6D4C2AEE8F86D69E8CED72AB8566CECBFA_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279 L_8 = (( Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279 InternalEnumerator_1_get_Current_m219A6F6D4C2AEE8F86D69E8CED72AB8566CECBFA_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m219A6F6D4C2AEE8F86D69E8CED72AB8566CECBFA(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m118A29F1EAB9A121242D65B79DCF0199A9640C5B_gshared (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m118A29F1EAB9A121242D65B79DCF0199A9640C5B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m118A29F1EAB9A121242D65B79DCF0199A9640C5B(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Generic.HashSet`1_Slot<System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2370D94B162CCB9AE9DE2667E298F002FBBDDEB7_gshared (InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * __this, const RuntimeMethod* method)
{
{
Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279 L_0 = InternalEnumerator_1_get_Current_m219A6F6D4C2AEE8F86D69E8CED72AB8566CECBFA((InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 *)(InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
Slot_t394A01CC2CDB2C0780E7D536D7851E87E9B85279 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2370D94B162CCB9AE9DE2667E298F002FBBDDEB7_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA30651E9F9C6721484813A1FA4836C7CB2EC1B24 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2370D94B162CCB9AE9DE2667E298F002FBBDDEB7(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mEE2C570D5E7E5426D066B223014819C8AF52C81C_gshared (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mEE2C570D5E7E5426D066B223014819C8AF52C81C_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 *>(__this + _offset);
InternalEnumerator_1__ctor_mEE2C570D5E7E5426D066B223014819C8AF52C81C(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mF13B6674061D28A1BEC4861C9DEC3C64227EC93D_gshared (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mF13B6674061D28A1BEC4861C9DEC3C64227EC93D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 *>(__this + _offset);
InternalEnumerator_1_Dispose_mF13B6674061D28A1BEC4861C9DEC3C64227EC93D(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m4F549A52CFE9F1740D8C1B6F9560C3F199F4A748_gshared (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m4F549A52CFE9F1740D8C1B6F9560C3F199F4A748_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m4F549A52CFE9F1740D8C1B6F9560C3F199F4A748(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B InternalEnumerator_1_get_Current_m5C45B04B93E24CF93F54B15DA1E0A4E5FB0D4F77_gshared (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m5C45B04B93E24CF93F54B15DA1E0A4E5FB0D4F77_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m5C45B04B93E24CF93F54B15DA1E0A4E5FB0D4F77_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m5C45B04B93E24CF93F54B15DA1E0A4E5FB0D4F77_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B L_8 = (( KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B InternalEnumerator_1_get_Current_m5C45B04B93E24CF93F54B15DA1E0A4E5FB0D4F77_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m5C45B04B93E24CF93F54B15DA1E0A4E5FB0D4F77(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDCDCABB85F4DCAFD112EBF0FAE0C6961DBFE301D_gshared (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDCDCABB85F4DCAFD112EBF0FAE0C6961DBFE301D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDCDCABB85F4DCAFD112EBF0FAE0C6961DBFE301D(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.DateTime,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m99CA89EB79E57A9759F9A03DF4D0B26DC43E553A_gshared (InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * __this, const RuntimeMethod* method)
{
{
KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B L_0 = InternalEnumerator_1_get_Current_m5C45B04B93E24CF93F54B15DA1E0A4E5FB0D4F77((InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 *)(InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
KeyValuePair_2_t5DDBBB9A3C8CBE3A4A39721E8F0A10AEBF13737B L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m99CA89EB79E57A9759F9A03DF4D0B26DC43E553A_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tF5EFF4776DC2AC7A5A6FA97DB973F4DF651913C1 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m99CA89EB79E57A9759F9A03DF4D0B26DC43E553A(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m52BE8429C80228377F2B44CF929F869A7B3EB7FB_gshared (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m52BE8429C80228377F2B44CF929F869A7B3EB7FB_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 *>(__this + _offset);
InternalEnumerator_1__ctor_m52BE8429C80228377F2B44CF929F869A7B3EB7FB(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mBE1CDE7FA444201BDA464FFC7DE46B39E8099762_gshared (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mBE1CDE7FA444201BDA464FFC7DE46B39E8099762_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 *>(__this + _offset);
InternalEnumerator_1_Dispose_mBE1CDE7FA444201BDA464FFC7DE46B39E8099762(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mF88FE72FCC8D35935014046A828E263C0B07857E_gshared (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mF88FE72FCC8D35935014046A828E263C0B07857E_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mF88FE72FCC8D35935014046A828E263C0B07857E(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937 InternalEnumerator_1_get_Current_mD3C6FDF318DBC20B66E7B62496085159512C8FB5_gshared (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mD3C6FDF318DBC20B66E7B62496085159512C8FB5_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mD3C6FDF318DBC20B66E7B62496085159512C8FB5_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mD3C6FDF318DBC20B66E7B62496085159512C8FB5_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937 L_8 = (( KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937 InternalEnumerator_1_get_Current_mD3C6FDF318DBC20B66E7B62496085159512C8FB5_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 *>(__this + _offset);
return InternalEnumerator_1_get_Current_mD3C6FDF318DBC20B66E7B62496085159512C8FB5(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mF5166C405A731BC27FEB654DAACAB8BFF8111CBF_gshared (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mF5166C405A731BC27FEB654DAACAB8BFF8111CBF_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mF5166C405A731BC27FEB654DAACAB8BFF8111CBF(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Int32>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mA4A313B9A3753AFFF14915F1CC2C85E78C25BAD7_gshared (InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * __this, const RuntimeMethod* method)
{
{
KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937 L_0 = InternalEnumerator_1_get_Current_mD3C6FDF318DBC20B66E7B62496085159512C8FB5((InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 *)(InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
KeyValuePair_2_t12CFA7FF15603BD4A555CDBFEBC08ECD343F1937 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mA4A313B9A3753AFFF14915F1CC2C85E78C25BAD7_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC6E781DC1833610367E32B8E69DBA8D6321C87A4 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mA4A313B9A3753AFFF14915F1CC2C85E78C25BAD7(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m242214F003D15A119A0C04FFE652998D8FE41522_gshared (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m242214F003D15A119A0C04FFE652998D8FE41522_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 *>(__this + _offset);
InternalEnumerator_1__ctor_m242214F003D15A119A0C04FFE652998D8FE41522(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m5E91FF0A6E2EF0B84CB4158ECB1F8B4A6455CF23_gshared (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m5E91FF0A6E2EF0B84CB4158ECB1F8B4A6455CF23_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 *>(__this + _offset);
InternalEnumerator_1_Dispose_m5E91FF0A6E2EF0B84CB4158ECB1F8B4A6455CF23(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mE4B207058D201EB5E54D576C57360ED5A09C2BE8_gshared (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mE4B207058D201EB5E54D576C57360ED5A09C2BE8_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mE4B207058D201EB5E54D576C57360ED5A09C2BE8(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78 InternalEnumerator_1_get_Current_m0577F355E2082ACD4D2A5281A5D618D2BAEB018C_gshared (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m0577F355E2082ACD4D2A5281A5D618D2BAEB018C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m0577F355E2082ACD4D2A5281A5D618D2BAEB018C_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m0577F355E2082ACD4D2A5281A5D618D2BAEB018C_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78 L_8 = (( KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78 InternalEnumerator_1_get_Current_m0577F355E2082ACD4D2A5281A5D618D2BAEB018C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m0577F355E2082ACD4D2A5281A5D618D2BAEB018C(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mF9EE0D0E138FD359A2F13C49636ACD60C723415C_gshared (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mF9EE0D0E138FD359A2F13C49636ACD60C723415C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mF9EE0D0E138FD359A2F13C49636ACD60C723415C(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Guid,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m43DAB8F8C87A0B6E511C39045473A42294BE62CA_gshared (InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * __this, const RuntimeMethod* method)
{
{
KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78 L_0 = InternalEnumerator_1_get_Current_m0577F355E2082ACD4D2A5281A5D618D2BAEB018C((InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 *)(InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
KeyValuePair_2_tD85A2E33C726647EDFB2F7F8E7EDC766E3C53B78 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m43DAB8F8C87A0B6E511C39045473A42294BE62CA_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7CAF00E6D268359FA5CDD6B530F0E32987FF3550 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m43DAB8F8C87A0B6E511C39045473A42294BE62CA(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m61F868D64FD5C0E79726859694754B78C3A12F13_gshared (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m61F868D64FD5C0E79726859694754B78C3A12F13_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA *>(__this + _offset);
InternalEnumerator_1__ctor_m61F868D64FD5C0E79726859694754B78C3A12F13(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m1BF7479D1C81DB164169EA2E67489072EFAEDB8D_gshared (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m1BF7479D1C81DB164169EA2E67489072EFAEDB8D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA *>(__this + _offset);
InternalEnumerator_1_Dispose_m1BF7479D1C81DB164169EA2E67489072EFAEDB8D(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m70A36FB83C5C0D46465928D98C613AC06DC4555F_gshared (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m70A36FB83C5C0D46465928D98C613AC06DC4555F_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m70A36FB83C5C0D46465928D98C613AC06DC4555F(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE InternalEnumerator_1_get_Current_mB446FB579A0D2052E3021D345FBA2E7BD1E2D8E7_gshared (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mB446FB579A0D2052E3021D345FBA2E7BD1E2D8E7_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mB446FB579A0D2052E3021D345FBA2E7BD1E2D8E7_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mB446FB579A0D2052E3021D345FBA2E7BD1E2D8E7_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE L_8 = (( KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE InternalEnumerator_1_get_Current_mB446FB579A0D2052E3021D345FBA2E7BD1E2D8E7_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA *>(__this + _offset);
return InternalEnumerator_1_get_Current_mB446FB579A0D2052E3021D345FBA2E7BD1E2D8E7(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m19A49279822B4D3317DE80D741A23A1FFBC4AA8D_gshared (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m19A49279822B4D3317DE80D741A23A1FFBC4AA8D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m19A49279822B4D3317DE80D741A23A1FFBC4AA8D(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Int32,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mF99F2E94E6B96C25D18AD365535F6596F6A8976D_gshared (InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * __this, const RuntimeMethod* method)
{
{
KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE L_0 = InternalEnumerator_1_get_Current_mB446FB579A0D2052E3021D345FBA2E7BD1E2D8E7((InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA *)(InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
KeyValuePair_2_t86464C52F9602337EAC68825E6BE06951D7530CE L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mF99F2E94E6B96C25D18AD365535F6596F6A8976D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tAA3F6981EE42DE1B1FBA5F55188E4EFC2269BEDA *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mF99F2E94E6B96C25D18AD365535F6596F6A8976D(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m68CFC035FC3DC1BD21D1ACB9580D1852CC49FF51_gshared (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m68CFC035FC3DC1BD21D1ACB9580D1852CC49FF51_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 *>(__this + _offset);
InternalEnumerator_1__ctor_m68CFC035FC3DC1BD21D1ACB9580D1852CC49FF51(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mDCA828D764CBB14FB3CF31AF0BDC68709FA4DAE7_gshared (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mDCA828D764CBB14FB3CF31AF0BDC68709FA4DAE7_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 *>(__this + _offset);
InternalEnumerator_1_Dispose_mDCA828D764CBB14FB3CF31AF0BDC68709FA4DAE7(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m9B1CF619F7F4E40343409851A9C45D5E2CB9347D_gshared (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m9B1CF619F7F4E40343409851A9C45D5E2CB9347D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m9B1CF619F7F4E40343409851A9C45D5E2CB9347D(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E InternalEnumerator_1_get_Current_mF0C51E221CD4A4E7C605483AF49C78902866C3C5_gshared (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mF0C51E221CD4A4E7C605483AF49C78902866C3C5_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mF0C51E221CD4A4E7C605483AF49C78902866C3C5_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mF0C51E221CD4A4E7C605483AF49C78902866C3C5_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E L_8 = (( KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E InternalEnumerator_1_get_Current_mF0C51E221CD4A4E7C605483AF49C78902866C3C5_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 *>(__this + _offset);
return InternalEnumerator_1_get_Current_mF0C51E221CD4A4E7C605483AF49C78902866C3C5(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mB8AA11D403DCF5974D63F330E5390A13F2521A2B_gshared (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mB8AA11D403DCF5974D63F330E5390A13F2521A2B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mB8AA11D403DCF5974D63F330E5390A13F2521A2B(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9646270AE8A4EB0758936B3CB5A0530524ADFB4C_gshared (InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * __this, const RuntimeMethod* method)
{
{
KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E L_0 = InternalEnumerator_1_get_Current_mF0C51E221CD4A4E7C605483AF49C78902866C3C5((InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 *)(InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
KeyValuePair_2_t3BAB6A80A3894F871F1F6B030436D8F2FF1D398E L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9646270AE8A4EB0758936B3CB5A0530524ADFB4C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEDC11688D96373751A66E805DD85CA5A655B5A14 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9646270AE8A4EB0758936B3CB5A0530524ADFB4C(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m5207FBDBFFFA3362A79214E0F6563073D0739B36_gshared (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m5207FBDBFFFA3362A79214E0F6563073D0739B36_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 *>(__this + _offset);
InternalEnumerator_1__ctor_m5207FBDBFFFA3362A79214E0F6563073D0739B36(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m5D695D1842FAD0CF7E2626EE58BE25188594A063_gshared (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m5D695D1842FAD0CF7E2626EE58BE25188594A063_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 *>(__this + _offset);
InternalEnumerator_1_Dispose_m5D695D1842FAD0CF7E2626EE58BE25188594A063(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mFA644183525E4E7C1DA9E0AB2520DEC0664DB22E_gshared (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mFA644183525E4E7C1DA9E0AB2520DEC0664DB22E_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mFA644183525E4E7C1DA9E0AB2520DEC0664DB22E(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE InternalEnumerator_1_get_Current_m8BCE8ACA1FB9184338A431ADF16C9ADEF01FE5A5_gshared (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m8BCE8ACA1FB9184338A431ADF16C9ADEF01FE5A5_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m8BCE8ACA1FB9184338A431ADF16C9ADEF01FE5A5_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m8BCE8ACA1FB9184338A431ADF16C9ADEF01FE5A5_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE L_8 = (( KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE InternalEnumerator_1_get_Current_m8BCE8ACA1FB9184338A431ADF16C9ADEF01FE5A5_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m8BCE8ACA1FB9184338A431ADF16C9ADEF01FE5A5(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDEA574E3825E771EA4138A2FDBA795680D2D6DDF_gshared (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDEA574E3825E771EA4138A2FDBA795680D2D6DDF_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDEA574E3825E771EA4138A2FDBA795680D2D6DDF(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8F15A6CF9D2375039F3A2922EC07A6F66A911D2E_gshared (InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * __this, const RuntimeMethod* method)
{
{
KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE L_0 = InternalEnumerator_1_get_Current_m8BCE8ACA1FB9184338A431ADF16C9ADEF01FE5A5((InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 *)(InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
KeyValuePair_2_t23481547E419E16E3B96A303578C1EB685C99EEE L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8F15A6CF9D2375039F3A2922EC07A6F66A911D2E_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tBD21A361A5A557D215F263973860F89CDAA6C679 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8F15A6CF9D2375039F3A2922EC07A6F66A911D2E(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m9F3DE26BFE9BF17F177A5DC956AADC3AEC5A7729_gshared (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m9F3DE26BFE9BF17F177A5DC956AADC3AEC5A7729_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C *>(__this + _offset);
InternalEnumerator_1__ctor_m9F3DE26BFE9BF17F177A5DC956AADC3AEC5A7729(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mEA3762DB58F8733CC8196C00787BFB4B1D1BBBFC_gshared (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mEA3762DB58F8733CC8196C00787BFB4B1D1BBBFC_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C *>(__this + _offset);
InternalEnumerator_1_Dispose_mEA3762DB58F8733CC8196C00787BFB4B1D1BBBFC(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m4BECF4142A35A113A6B4932DB906E425F6209742_gshared (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m4BECF4142A35A113A6B4932DB906E425F6209742_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m4BECF4142A35A113A6B4932DB906E425F6209742(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6 InternalEnumerator_1_get_Current_m52F1F50D102498BDAA3DC236872E47AB913F5B5D_gshared (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m52F1F50D102498BDAA3DC236872E47AB913F5B5D_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m52F1F50D102498BDAA3DC236872E47AB913F5B5D_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m52F1F50D102498BDAA3DC236872E47AB913F5B5D_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6 L_8 = (( KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6 InternalEnumerator_1_get_Current_m52F1F50D102498BDAA3DC236872E47AB913F5B5D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C *>(__this + _offset);
return InternalEnumerator_1_get_Current_m52F1F50D102498BDAA3DC236872E47AB913F5B5D(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mB8257FAF3E914823A81665B44108DBB6FF6E676B_gshared (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mB8257FAF3E914823A81665B44108DBB6FF6E676B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mB8257FAF3E914823A81665B44108DBB6FF6E676B(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Resources.ResourceLocator>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCB16D07C75263BD2D00943720593924E2548EC08_gshared (InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * __this, const RuntimeMethod* method)
{
{
KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6 L_0 = InternalEnumerator_1_get_Current_m52F1F50D102498BDAA3DC236872E47AB913F5B5D((InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C *)(InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
KeyValuePair_2_t2D8427F03B42441C4598C9D3AAB86FBA90CDF7F6 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCB16D07C75263BD2D00943720593924E2548EC08_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t632011B8114E218BF0B4A2356B7C33C343B2566C *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCB16D07C75263BD2D00943720593924E2548EC08(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m1A7199B93AA095B50B5B5434C225D227E5F5BB93_gshared (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m1A7199B93AA095B50B5B5434C225D227E5F5BB93_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 *>(__this + _offset);
InternalEnumerator_1__ctor_m1A7199B93AA095B50B5B5434C225D227E5F5BB93(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m9741A20915B57ACCEE417A751E7DD64FFFC93BE6_gshared (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m9741A20915B57ACCEE417A751E7DD64FFFC93BE6_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 *>(__this + _offset);
InternalEnumerator_1_Dispose_m9741A20915B57ACCEE417A751E7DD64FFFC93BE6(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mD78BC91300561B9802E9F3D57821D903E75298B3_gshared (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mD78BC91300561B9802E9F3D57821D903E75298B3_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mD78BC91300561B9802E9F3D57821D903E75298B3(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4 InternalEnumerator_1_get_Current_m588A1C9004B72DEF16E5D6EEEE07D34F994B5E5B_gshared (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m588A1C9004B72DEF16E5D6EEEE07D34F994B5E5B_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m588A1C9004B72DEF16E5D6EEEE07D34F994B5E5B_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m588A1C9004B72DEF16E5D6EEEE07D34F994B5E5B_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4 L_8 = (( KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4 InternalEnumerator_1_get_Current_m588A1C9004B72DEF16E5D6EEEE07D34F994B5E5B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m588A1C9004B72DEF16E5D6EEEE07D34F994B5E5B(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m63EE71FC9ACD0C91B910C5FDC9CDD975807B70B9_gshared (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m63EE71FC9ACD0C91B910C5FDC9CDD975807B70B9_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m63EE71FC9ACD0C91B910C5FDC9CDD975807B70B9(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.UInt64,System.Object>>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB59C149FC8EAA87F79922094A6EF1354971B0A20_gshared (InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * __this, const RuntimeMethod* method)
{
{
KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4 L_0 = InternalEnumerator_1_get_Current_m588A1C9004B72DEF16E5D6EEEE07D34F994B5E5B((InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 *)(InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
KeyValuePair_2_tBCE16D0D06F9AF10E3F89C064C5CCA69892173D4 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB59C149FC8EAA87F79922094A6EF1354971B0A20_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tE99D1BF1A9E692B49E63E8EC5E893667011743C9 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB59C149FC8EAA87F79922094A6EF1354971B0A20(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Collections.Hashtable_bucket>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m5E660A4E0C016C0CA6AE7EA86BC146FAA02B10BF_gshared (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m5E660A4E0C016C0CA6AE7EA86BC146FAA02B10BF_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B *>(__this + _offset);
InternalEnumerator_1__ctor_m5E660A4E0C016C0CA6AE7EA86BC146FAA02B10BF(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Hashtable_bucket>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mE1E9392D5C112D0793D3217A5DA839CDA30E42AE_gshared (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mE1E9392D5C112D0793D3217A5DA839CDA30E42AE_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B *>(__this + _offset);
InternalEnumerator_1_Dispose_mE1E9392D5C112D0793D3217A5DA839CDA30E42AE(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Collections.Hashtable_bucket>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m1BDC4F1B539642F68851541B59BE304AC3EACE73_gshared (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m1BDC4F1B539642F68851541B59BE304AC3EACE73_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m1BDC4F1B539642F68851541B59BE304AC3EACE73(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Collections.Hashtable_bucket>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bucket_t1C848488DF65838689F7773D46F9E7E8C881B083 InternalEnumerator_1_get_Current_mDBE1EC33C2BD728CBA191BA48B16AFD2BCE81F6D_gshared (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mDBE1EC33C2BD728CBA191BA48B16AFD2BCE81F6D_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mDBE1EC33C2BD728CBA191BA48B16AFD2BCE81F6D_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mDBE1EC33C2BD728CBA191BA48B16AFD2BCE81F6D_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
bucket_t1C848488DF65838689F7773D46F9E7E8C881B083 L_8 = (( bucket_t1C848488DF65838689F7773D46F9E7E8C881B083 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C bucket_t1C848488DF65838689F7773D46F9E7E8C881B083 InternalEnumerator_1_get_Current_mDBE1EC33C2BD728CBA191BA48B16AFD2BCE81F6D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B *>(__this + _offset);
return InternalEnumerator_1_get_Current_mDBE1EC33C2BD728CBA191BA48B16AFD2BCE81F6D(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Collections.Hashtable_bucket>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6BEEA4996FE2FAD1230E143C6C160BD2811C445B_gshared (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6BEEA4996FE2FAD1230E143C6C160BD2811C445B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6BEEA4996FE2FAD1230E143C6C160BD2811C445B(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Collections.Hashtable_bucket>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m898C99F1A17C87AE5BB8AE238571C8D449A9C8A1_gshared (InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * __this, const RuntimeMethod* method)
{
{
bucket_t1C848488DF65838689F7773D46F9E7E8C881B083 L_0 = InternalEnumerator_1_get_Current_mDBE1EC33C2BD728CBA191BA48B16AFD2BCE81F6D((InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B *)(InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
bucket_t1C848488DF65838689F7773D46F9E7E8C881B083 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m898C99F1A17C87AE5BB8AE238571C8D449A9C8A1_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t958A1CB7BD60AE893EDA6472870C327FB92BF21B *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m898C99F1A17C87AE5BB8AE238571C8D449A9C8A1(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.DateTime>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m38FF15007E4EC72548A334D194D158343AA99CC7_gshared (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m38FF15007E4EC72548A334D194D158343AA99CC7_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C *>(__this + _offset);
InternalEnumerator_1__ctor_m38FF15007E4EC72548A334D194D158343AA99CC7(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.DateTime>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m706D65100CBE250B47E0D87A75E13164F9CAB601_gshared (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m706D65100CBE250B47E0D87A75E13164F9CAB601_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C *>(__this + _offset);
InternalEnumerator_1_Dispose_m706D65100CBE250B47E0D87A75E13164F9CAB601(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.DateTime>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mAD2E5315BA13D08E0B7FEBC36D5C029DCD48A00B_gshared (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mAD2E5315BA13D08E0B7FEBC36D5C029DCD48A00B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mAD2E5315BA13D08E0B7FEBC36D5C029DCD48A00B(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.DateTime>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 InternalEnumerator_1_get_Current_mC41E15442C38B131C7AD1E88876963F01A4868CB_gshared (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mC41E15442C38B131C7AD1E88876963F01A4868CB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mC41E15442C38B131C7AD1E88876963F01A4868CB_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mC41E15442C38B131C7AD1E88876963F01A4868CB_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 L_8 = (( DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 InternalEnumerator_1_get_Current_mC41E15442C38B131C7AD1E88876963F01A4868CB_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C *>(__this + _offset);
return InternalEnumerator_1_get_Current_mC41E15442C38B131C7AD1E88876963F01A4868CB(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.DateTime>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m99164482C6858CCA3B028445F1A836FED67A353B_gshared (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m99164482C6858CCA3B028445F1A836FED67A353B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m99164482C6858CCA3B028445F1A836FED67A353B(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.DateTime>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1668301F0BFBFB089DAFB2BCF55CFD464CC218C2_gshared (InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * __this, const RuntimeMethod* method)
{
{
DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 L_0 = InternalEnumerator_1_get_Current_mC41E15442C38B131C7AD1E88876963F01A4868CB((InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C *)(InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
DateTime_t349B7449FBAAFF4192636E2B7A07694DA9236132 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1668301F0BFBFB089DAFB2BCF55CFD464CC218C2_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8501E4029651E6A824D836A3278C5F7F47E5CB8C *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1668301F0BFBFB089DAFB2BCF55CFD464CC218C2(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Decimal>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m9FA8DEA90071FEC73528075A9F1100D76CDE99D5_gshared (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m9FA8DEA90071FEC73528075A9F1100D76CDE99D5_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 *>(__this + _offset);
InternalEnumerator_1__ctor_m9FA8DEA90071FEC73528075A9F1100D76CDE99D5(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Decimal>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m2CDB317CD290A3CF69F8CFFB4740A174FBCB4957_gshared (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m2CDB317CD290A3CF69F8CFFB4740A174FBCB4957_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 *>(__this + _offset);
InternalEnumerator_1_Dispose_m2CDB317CD290A3CF69F8CFFB4740A174FBCB4957(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Decimal>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m8BFF576A59DF1CA270FBA8F1ED3FC4F57A491229_gshared (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m8BFF576A59DF1CA270FBA8F1ED3FC4F57A491229_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m8BFF576A59DF1CA270FBA8F1ED3FC4F57A491229(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Decimal>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 InternalEnumerator_1_get_Current_mB1B90708ED55CB1E651BF9E5FA629B28E8E5977A_gshared (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mB1B90708ED55CB1E651BF9E5FA629B28E8E5977A_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mB1B90708ED55CB1E651BF9E5FA629B28E8E5977A_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mB1B90708ED55CB1E651BF9E5FA629B28E8E5977A_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 L_8 = (( Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 InternalEnumerator_1_get_Current_mB1B90708ED55CB1E651BF9E5FA629B28E8E5977A_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 *>(__this + _offset);
return InternalEnumerator_1_get_Current_mB1B90708ED55CB1E651BF9E5FA629B28E8E5977A(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Decimal>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mE109263B389473C6F2F6821A32E6273D52722A5D_gshared (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mE109263B389473C6F2F6821A32E6273D52722A5D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mE109263B389473C6F2F6821A32E6273D52722A5D(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Decimal>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mBF9B03E2327F706D52248C6F35FCAD49FB6C2F98_gshared (InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * __this, const RuntimeMethod* method)
{
{
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 L_0 = InternalEnumerator_1_get_Current_mB1B90708ED55CB1E651BF9E5FA629B28E8E5977A((InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 *)(InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
Decimal_t44EE9DA309A1BF848308DE4DDFC070CAE6D95EE8 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mBF9B03E2327F706D52248C6F35FCAD49FB6C2F98_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t257599E95CDE322D0A0F62BC4DF648368930E7C1 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mBF9B03E2327F706D52248C6F35FCAD49FB6C2F98(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mDDF607BB20488A6FA7CA084A5224268E0338C52C_gshared (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mDDF607BB20488A6FA7CA084A5224268E0338C52C_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 *>(__this + _offset);
InternalEnumerator_1__ctor_mDDF607BB20488A6FA7CA084A5224268E0338C52C(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mADC6EE407FA72D81123E076FBBFF257865478FF1_gshared (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mADC6EE407FA72D81123E076FBBFF257865478FF1_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 *>(__this + _offset);
InternalEnumerator_1_Dispose_mADC6EE407FA72D81123E076FBBFF257865478FF1(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m3652AD403099B49406A1E024990598169861FC38_gshared (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m3652AD403099B49406A1E024990598169861FC38_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m3652AD403099B49406A1E024990598169861FC38(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A InternalEnumerator_1_get_Current_m868993F9E581D2FDE89D311B0D0E7F043B5526EE_gshared (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m868993F9E581D2FDE89D311B0D0E7F043B5526EE_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m868993F9E581D2FDE89D311B0D0E7F043B5526EE_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m868993F9E581D2FDE89D311B0D0E7F043B5526EE_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A L_8 = (( SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A InternalEnumerator_1_get_Current_m868993F9E581D2FDE89D311B0D0E7F043B5526EE_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m868993F9E581D2FDE89D311B0D0E7F043B5526EE(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m0A1DEAFFFA545BF34F3B2B8B5C4ABBD0D762860F_gshared (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m0A1DEAFFFA545BF34F3B2B8B5C4ABBD0D762860F_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m0A1DEAFFFA545BF34F3B2B8B5C4ABBD0D762860F(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Diagnostics.Tracing.EventProvider_SessionInfo>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB3B98E6648B86023BBCBA7071A37A9DF18C899BF_gshared (InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * __this, const RuntimeMethod* method)
{
{
SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A L_0 = InternalEnumerator_1_get_Current_m868993F9E581D2FDE89D311B0D0E7F043B5526EE((InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 *)(InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
SessionInfo_tEAFEEFE3C65BFE4DCD6DBA6F4B1F525553E17F4A L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB3B98E6648B86023BBCBA7071A37A9DF18C899BF_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tE292E5362B60EA297C746B05A7DF275F32F7E395 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB3B98E6648B86023BBCBA7071A37A9DF18C899BF(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m70FD5955510D3C8C60F9432DC1576FEA4BF298D6_gshared (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m70FD5955510D3C8C60F9432DC1576FEA4BF298D6_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB *>(__this + _offset);
InternalEnumerator_1__ctor_m70FD5955510D3C8C60F9432DC1576FEA4BF298D6(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m068CDEACC21774C02CAE19D8DA4DD58BA70A77FA_gshared (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m068CDEACC21774C02CAE19D8DA4DD58BA70A77FA_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB *>(__this + _offset);
InternalEnumerator_1_Dispose_m068CDEACC21774C02CAE19D8DA4DD58BA70A77FA(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mF47AB1403AEA819AC6C6F83E75A8E6B630274601_gshared (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mF47AB1403AEA819AC6C6F83E75A8E6B630274601_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mF47AB1403AEA819AC6C6F83E75A8E6B630274601(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B InternalEnumerator_1_get_Current_m209A56D6C53AC134B236FD1E3808E42C2DA0F378_gshared (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m209A56D6C53AC134B236FD1E3808E42C2DA0F378_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m209A56D6C53AC134B236FD1E3808E42C2DA0F378_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m209A56D6C53AC134B236FD1E3808E42C2DA0F378_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B L_8 = (( EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B InternalEnumerator_1_get_Current_m209A56D6C53AC134B236FD1E3808E42C2DA0F378_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB *>(__this + _offset);
return InternalEnumerator_1_get_Current_m209A56D6C53AC134B236FD1E3808E42C2DA0F378(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mEDDD49DFA18C451495C8E8128854D370181D0C12_gshared (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mEDDD49DFA18C451495C8E8128854D370181D0C12_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mEDDD49DFA18C451495C8E8128854D370181D0C12(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Diagnostics.Tracing.EventSource_EventMetadata>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mA1E541F561DF486D84527601ABB2404DD6501DA3_gshared (InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * __this, const RuntimeMethod* method)
{
{
EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B L_0 = InternalEnumerator_1_get_Current_m209A56D6C53AC134B236FD1E3808E42C2DA0F378((InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB *)(InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
EventMetadata_tDC146079349635A3A29F84F4655C39D480BBCF0B L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mA1E541F561DF486D84527601ABB2404DD6501DA3_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t5F90AB54A2916017F9071E920BBCDB363B8B1BBB *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mA1E541F561DF486D84527601ABB2404DD6501DA3(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Double>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m2EB3647F564935D58525C6BF0F365C22D0F86EEF_gshared (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m2EB3647F564935D58525C6BF0F365C22D0F86EEF_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 *>(__this + _offset);
InternalEnumerator_1__ctor_m2EB3647F564935D58525C6BF0F365C22D0F86EEF(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Double>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m897B005D5C7B05B9946D2CA717A24D642DC3B692_gshared (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m897B005D5C7B05B9946D2CA717A24D642DC3B692_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 *>(__this + _offset);
InternalEnumerator_1_Dispose_m897B005D5C7B05B9946D2CA717A24D642DC3B692(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Double>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mC78350B2B7286550FF3DCEA2105FAF745425F5F6_gshared (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mC78350B2B7286550FF3DCEA2105FAF745425F5F6_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mC78350B2B7286550FF3DCEA2105FAF745425F5F6(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Double>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR double InternalEnumerator_1_get_Current_m4CF2B380D638F22E5C70B4E41F35AD95FB71FE26_gshared (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m4CF2B380D638F22E5C70B4E41F35AD95FB71FE26_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m4CF2B380D638F22E5C70B4E41F35AD95FB71FE26_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m4CF2B380D638F22E5C70B4E41F35AD95FB71FE26_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
double L_8 = (( double (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C double InternalEnumerator_1_get_Current_m4CF2B380D638F22E5C70B4E41F35AD95FB71FE26_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m4CF2B380D638F22E5C70B4E41F35AD95FB71FE26(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Double>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m2E70BDAD683DCC0CBD56FF1B3F1C1DC7B86565A3_gshared (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m2E70BDAD683DCC0CBD56FF1B3F1C1DC7B86565A3_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m2E70BDAD683DCC0CBD56FF1B3F1C1DC7B86565A3(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Double>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2E95A3A4607ED179D9FE2D702C7E6109ACF36269_gshared (InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * __this, const RuntimeMethod* method)
{
{
double L_0 = InternalEnumerator_1_get_Current_m4CF2B380D638F22E5C70B4E41F35AD95FB71FE26((InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 *)(InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
double L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2E95A3A4607ED179D9FE2D702C7E6109ACF36269_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t551D44E67C0C4F28271D64D2DC1D530E49694C55 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2E95A3A4607ED179D9FE2D702C7E6109ACF36269(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m99BBAA2F747C901A1EAED9DD8F28837B642E16D9_gshared (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m99BBAA2F747C901A1EAED9DD8F28837B642E16D9_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 *>(__this + _offset);
InternalEnumerator_1__ctor_m99BBAA2F747C901A1EAED9DD8F28837B642E16D9(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m190F2C8765ECDC1A19A67DEE686CDAE334DD238F_gshared (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m190F2C8765ECDC1A19A67DEE686CDAE334DD238F_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 *>(__this + _offset);
InternalEnumerator_1_Dispose_m190F2C8765ECDC1A19A67DEE686CDAE334DD238F(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m5874180E5D0BF8559989E93AD753745463CCE784_gshared (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m5874180E5D0BF8559989E93AD753745463CCE784_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m5874180E5D0BF8559989E93AD753745463CCE784(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4 InternalEnumerator_1_get_Current_m5E3D89E57206E983F95400F30010E1922D7E1A1C_gshared (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m5E3D89E57206E983F95400F30010E1922D7E1A1C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m5E3D89E57206E983F95400F30010E1922D7E1A1C_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m5E3D89E57206E983F95400F30010E1922D7E1A1C_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4 L_8 = (( InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4 InternalEnumerator_1_get_Current_m5E3D89E57206E983F95400F30010E1922D7E1A1C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m5E3D89E57206E983F95400F30010E1922D7E1A1C(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mAC88F8333D9BC850EB955235E4FF7B49A2EB9ADA_gshared (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mAC88F8333D9BC850EB955235E4FF7B49A2EB9ADA_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mAC88F8333D9BC850EB955235E4FF7B49A2EB9ADA(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Globalization.InternalCodePageDataItem>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mADD52706A60B65EF430A9A8361D76CE2FB08FBF4_gshared (InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * __this, const RuntimeMethod* method)
{
{
InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4 L_0 = InternalEnumerator_1_get_Current_m5E3D89E57206E983F95400F30010E1922D7E1A1C((InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 *)(InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
InternalCodePageDataItem_t34EE39DE4A481B875348BB9BC6751E2A109AD0D4 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mADD52706A60B65EF430A9A8361D76CE2FB08FBF4_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t6DDCB6670988C6CC77FED8E0879A4AF1E90F90E7 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mADD52706A60B65EF430A9A8361D76CE2FB08FBF4(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mC0268A706CA7F19506CC886359704ED873A74811_gshared (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mC0268A706CA7F19506CC886359704ED873A74811_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D *>(__this + _offset);
InternalEnumerator_1__ctor_mC0268A706CA7F19506CC886359704ED873A74811(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m829CDAF898E571D63C974F1031E986662BE6A7B4_gshared (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m829CDAF898E571D63C974F1031E986662BE6A7B4_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D *>(__this + _offset);
InternalEnumerator_1_Dispose_m829CDAF898E571D63C974F1031E986662BE6A7B4(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mA4049184F49FCF2BB8D8164C53BC2F9A98DE1528_gshared (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mA4049184F49FCF2BB8D8164C53BC2F9A98DE1528_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mA4049184F49FCF2BB8D8164C53BC2F9A98DE1528(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211 InternalEnumerator_1_get_Current_m7CE9128839CB0EC4AF3B0BAF875A178ED4EA9E42_gshared (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m7CE9128839CB0EC4AF3B0BAF875A178ED4EA9E42_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m7CE9128839CB0EC4AF3B0BAF875A178ED4EA9E42_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m7CE9128839CB0EC4AF3B0BAF875A178ED4EA9E42_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211 L_8 = (( InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211 InternalEnumerator_1_get_Current_m7CE9128839CB0EC4AF3B0BAF875A178ED4EA9E42_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D *>(__this + _offset);
return InternalEnumerator_1_get_Current_m7CE9128839CB0EC4AF3B0BAF875A178ED4EA9E42(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m9B5A4FBEB36F25AB04EC9A082999D3C5C960F2B2_gshared (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m9B5A4FBEB36F25AB04EC9A082999D3C5C960F2B2_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m9B5A4FBEB36F25AB04EC9A082999D3C5C960F2B2(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Globalization.InternalEncodingDataItem>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0864F6C06C70CAE51CC7A38AA55CCF704BB674A8_gshared (InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * __this, const RuntimeMethod* method)
{
{
InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211 L_0 = InternalEnumerator_1_get_Current_m7CE9128839CB0EC4AF3B0BAF875A178ED4EA9E42((InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D *)(InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
InternalEncodingDataItem_t34BEF550D56496035752E8E0607127CD43378211 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0864F6C06C70CAE51CC7A38AA55CCF704BB674A8_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t4701E706C2E9271C97A4DA02D5A427C454E2511D *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0864F6C06C70CAE51CC7A38AA55CCF704BB674A8(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Guid>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m9903677C8275AC12400E4CF7DD8F9CA715E93EF7_gshared (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m9903677C8275AC12400E4CF7DD8F9CA715E93EF7_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 *>(__this + _offset);
InternalEnumerator_1__ctor_m9903677C8275AC12400E4CF7DD8F9CA715E93EF7(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Guid>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mD354E2C453E6A047D967B2B456259FF544320E3B_gshared (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mD354E2C453E6A047D967B2B456259FF544320E3B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 *>(__this + _offset);
InternalEnumerator_1_Dispose_mD354E2C453E6A047D967B2B456259FF544320E3B(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Guid>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mE7E1CD869291B4E596B1A67E0863CC7D6F4D7186_gshared (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mE7E1CD869291B4E596B1A67E0863CC7D6F4D7186_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mE7E1CD869291B4E596B1A67E0863CC7D6F4D7186(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Guid>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Guid_t InternalEnumerator_1_get_Current_m654F712F9682ADAE03DA5A38B8EA05099AB77864_gshared (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m654F712F9682ADAE03DA5A38B8EA05099AB77864_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m654F712F9682ADAE03DA5A38B8EA05099AB77864_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m654F712F9682ADAE03DA5A38B8EA05099AB77864_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
Guid_t L_8 = (( Guid_t (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C Guid_t InternalEnumerator_1_get_Current_m654F712F9682ADAE03DA5A38B8EA05099AB77864_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m654F712F9682ADAE03DA5A38B8EA05099AB77864(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Guid>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mCC1FF18F89CE70BE3D2AD5ED3FEE3E244F2885C5_gshared (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mCC1FF18F89CE70BE3D2AD5ED3FEE3E244F2885C5_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mCC1FF18F89CE70BE3D2AD5ED3FEE3E244F2885C5(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Guid>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m99DD87F3BFD258C3366BA0846CA059840BA2D0CE_gshared (InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * __this, const RuntimeMethod* method)
{
{
Guid_t L_0 = InternalEnumerator_1_get_Current_m654F712F9682ADAE03DA5A38B8EA05099AB77864((InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 *)(InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
Guid_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m99DD87F3BFD258C3366BA0846CA059840BA2D0CE_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t9AE8C5991408C212786085A557847BB17A5272C1 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m99DD87F3BFD258C3366BA0846CA059840BA2D0CE(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Int16>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m8EE54AB2215933CFD3514ACDD75A87A8BE8B60AE_gshared (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m8EE54AB2215933CFD3514ACDD75A87A8BE8B60AE_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 *>(__this + _offset);
InternalEnumerator_1__ctor_m8EE54AB2215933CFD3514ACDD75A87A8BE8B60AE(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Int16>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m3C2D5CADD976B0AD79CDC5BBE3EACFA5E1EAEC14_gshared (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m3C2D5CADD976B0AD79CDC5BBE3EACFA5E1EAEC14_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 *>(__this + _offset);
InternalEnumerator_1_Dispose_m3C2D5CADD976B0AD79CDC5BBE3EACFA5E1EAEC14(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Int16>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m454457EA339027D7DAE0DD53FF1EA7C34A6CD7EE_gshared (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m454457EA339027D7DAE0DD53FF1EA7C34A6CD7EE_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m454457EA339027D7DAE0DD53FF1EA7C34A6CD7EE(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Int16>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int16_t InternalEnumerator_1_get_Current_mFFD60C69E1F8CF93C20492F2A58FBC09CEB6188F_gshared (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mFFD60C69E1F8CF93C20492F2A58FBC09CEB6188F_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mFFD60C69E1F8CF93C20492F2A58FBC09CEB6188F_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mFFD60C69E1F8CF93C20492F2A58FBC09CEB6188F_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
int16_t L_8 = (( int16_t (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C int16_t InternalEnumerator_1_get_Current_mFFD60C69E1F8CF93C20492F2A58FBC09CEB6188F_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 *>(__this + _offset);
return InternalEnumerator_1_get_Current_mFFD60C69E1F8CF93C20492F2A58FBC09CEB6188F(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Int16>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA81C0DBCEBF6CFD70EC6FD73CD4F84CE65DDB260_gshared (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA81C0DBCEBF6CFD70EC6FD73CD4F84CE65DDB260_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA81C0DBCEBF6CFD70EC6FD73CD4F84CE65DDB260(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Int16>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m51CF0FAA9202E3C70397E473B6F312B1977D0861_gshared (InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * __this, const RuntimeMethod* method)
{
{
int16_t L_0 = InternalEnumerator_1_get_Current_mFFD60C69E1F8CF93C20492F2A58FBC09CEB6188F((InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 *)(InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
int16_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m51CF0FAA9202E3C70397E473B6F312B1977D0861_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t1A3BE99A7E93AFDEE3326117AB9BC91FCC8E5A91 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m51CF0FAA9202E3C70397E473B6F312B1977D0861(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Int32>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mFD68B921CD29713A2BEB038318C202A9E4E9B5CE_gshared (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mFD68B921CD29713A2BEB038318C202A9E4E9B5CE_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D *>(__this + _offset);
InternalEnumerator_1__ctor_mFD68B921CD29713A2BEB038318C202A9E4E9B5CE(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Int32>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mBFEAB58E625616898F0E0ED1A11935920DD0A34E_gshared (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mBFEAB58E625616898F0E0ED1A11935920DD0A34E_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D *>(__this + _offset);
InternalEnumerator_1_Dispose_mBFEAB58E625616898F0E0ED1A11935920DD0A34E(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Int32>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mEABDC1E82F7AAE1B3B6DE2F40F0B7FDE199312C3_gshared (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mEABDC1E82F7AAE1B3B6DE2F40F0B7FDE199312C3_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mEABDC1E82F7AAE1B3B6DE2F40F0B7FDE199312C3(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Int32>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t InternalEnumerator_1_get_Current_m70AA9F95B052891AAD4AB638CA09537554ABE683_gshared (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m70AA9F95B052891AAD4AB638CA09537554ABE683_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m70AA9F95B052891AAD4AB638CA09537554ABE683_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m70AA9F95B052891AAD4AB638CA09537554ABE683_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
int32_t L_8 = (( int32_t (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C int32_t InternalEnumerator_1_get_Current_m70AA9F95B052891AAD4AB638CA09537554ABE683_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D *>(__this + _offset);
return InternalEnumerator_1_get_Current_m70AA9F95B052891AAD4AB638CA09537554ABE683(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Int32>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5215F161D6643BFA30010228E401FFA587630F25_gshared (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5215F161D6643BFA30010228E401FFA587630F25_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5215F161D6643BFA30010228E401FFA587630F25(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Int32>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m95E1A22E55B29BD2BE8001BDB1E13CC3DE23A2D7_gshared (InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = InternalEnumerator_1_get_Current_m70AA9F95B052891AAD4AB638CA09537554ABE683((InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D *)(InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
int32_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m95E1A22E55B29BD2BE8001BDB1E13CC3DE23A2D7_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA5E761BB55ACBAB41554465F72F0696F7108A43D *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m95E1A22E55B29BD2BE8001BDB1E13CC3DE23A2D7(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Int32Enum>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mBF8E58BAA9971C4074B8EEC028434A1BAEB0748F_gshared (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mBF8E58BAA9971C4074B8EEC028434A1BAEB0748F_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A *>(__this + _offset);
InternalEnumerator_1__ctor_mBF8E58BAA9971C4074B8EEC028434A1BAEB0748F(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Int32Enum>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m4A6D2508A0C1EFE6CB0DDCCA0057F8EC22168204_gshared (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m4A6D2508A0C1EFE6CB0DDCCA0057F8EC22168204_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A *>(__this + _offset);
InternalEnumerator_1_Dispose_m4A6D2508A0C1EFE6CB0DDCCA0057F8EC22168204(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Int32Enum>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mDD38EA99C85E3EE7271D7786026B1523054CC257_gshared (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mDD38EA99C85E3EE7271D7786026B1523054CC257_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mDD38EA99C85E3EE7271D7786026B1523054CC257(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Int32Enum>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t InternalEnumerator_1_get_Current_m079C9B7D950F47EBDDE3290AF721C64568541238_gshared (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m079C9B7D950F47EBDDE3290AF721C64568541238_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m079C9B7D950F47EBDDE3290AF721C64568541238_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m079C9B7D950F47EBDDE3290AF721C64568541238_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
int32_t L_8 = (( int32_t (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C int32_t InternalEnumerator_1_get_Current_m079C9B7D950F47EBDDE3290AF721C64568541238_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A *>(__this + _offset);
return InternalEnumerator_1_get_Current_m079C9B7D950F47EBDDE3290AF721C64568541238(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Int32Enum>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mEA4ADBA1D47E80688B0470DF0C297444612C7311_gshared (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mEA4ADBA1D47E80688B0470DF0C297444612C7311_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mEA4ADBA1D47E80688B0470DF0C297444612C7311(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Int32Enum>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC2955E66B742022B3C37F449E2DAFDA6CED420C0_gshared (InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = InternalEnumerator_1_get_Current_m079C9B7D950F47EBDDE3290AF721C64568541238((InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A *)(InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
int32_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC2955E66B742022B3C37F449E2DAFDA6CED420C0_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC7F1CBDAE31330F9D7386E67FD78B1C06F46422A *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC2955E66B742022B3C37F449E2DAFDA6CED420C0(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Int64>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m68F9020151CD964322723D3C02977C30EA0F189E_gshared (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m68F9020151CD964322723D3C02977C30EA0F189E_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F *>(__this + _offset);
InternalEnumerator_1__ctor_m68F9020151CD964322723D3C02977C30EA0F189E(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Int64>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mD7021BD3B9CF1E4B5A10D78E753CDB276A8631AD_gshared (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mD7021BD3B9CF1E4B5A10D78E753CDB276A8631AD_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F *>(__this + _offset);
InternalEnumerator_1_Dispose_mD7021BD3B9CF1E4B5A10D78E753CDB276A8631AD(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Int64>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m3921385986D9A6472FAAAD1EEFBB0AFBEE0A98AE_gshared (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m3921385986D9A6472FAAAD1EEFBB0AFBEE0A98AE_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m3921385986D9A6472FAAAD1EEFBB0AFBEE0A98AE(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Int64>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t InternalEnumerator_1_get_Current_m9A73AB58D1A8BE0B72C490559F3DB7A1A8194174_gshared (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m9A73AB58D1A8BE0B72C490559F3DB7A1A8194174_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m9A73AB58D1A8BE0B72C490559F3DB7A1A8194174_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m9A73AB58D1A8BE0B72C490559F3DB7A1A8194174_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
int64_t L_8 = (( int64_t (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C int64_t InternalEnumerator_1_get_Current_m9A73AB58D1A8BE0B72C490559F3DB7A1A8194174_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F *>(__this + _offset);
return InternalEnumerator_1_get_Current_m9A73AB58D1A8BE0B72C490559F3DB7A1A8194174(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Int64>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC3C01ADBFB01FCDD97526280A73422955CA7898F_gshared (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC3C01ADBFB01FCDD97526280A73422955CA7898F_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC3C01ADBFB01FCDD97526280A73422955CA7898F(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Int64>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m7CDD9680E17A3B80D1D3332A68A89353FFAA0D87_gshared (InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * __this, const RuntimeMethod* method)
{
{
int64_t L_0 = InternalEnumerator_1_get_Current_m9A73AB58D1A8BE0B72C490559F3DB7A1A8194174((InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F *)(InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
int64_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m7CDD9680E17A3B80D1D3332A68A89353FFAA0D87_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA5586E86516FCB0C7894D3F96D7ADECB3275AA4F *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m7CDD9680E17A3B80D1D3332A68A89353FFAA0D87(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.IntPtr>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mCC5889C0F1785F416EB4E3EB0EE4BE48D0A055C8_gshared (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mCC5889C0F1785F416EB4E3EB0EE4BE48D0A055C8_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE *>(__this + _offset);
InternalEnumerator_1__ctor_mCC5889C0F1785F416EB4E3EB0EE4BE48D0A055C8(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.IntPtr>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m2404F9B209B37D0B37621E1D7FB27D3E7C105719_gshared (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m2404F9B209B37D0B37621E1D7FB27D3E7C105719_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE *>(__this + _offset);
InternalEnumerator_1_Dispose_m2404F9B209B37D0B37621E1D7FB27D3E7C105719(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.IntPtr>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mF114574B4163E7D82DCB1FD35E3AF796F8F1A868_gshared (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mF114574B4163E7D82DCB1FD35E3AF796F8F1A868_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mF114574B4163E7D82DCB1FD35E3AF796F8F1A868(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.IntPtr>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR intptr_t InternalEnumerator_1_get_Current_m94C0D13214FB1EC791B1CC5DFE5A82E2AAE63406_gshared (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m94C0D13214FB1EC791B1CC5DFE5A82E2AAE63406_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m94C0D13214FB1EC791B1CC5DFE5A82E2AAE63406_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m94C0D13214FB1EC791B1CC5DFE5A82E2AAE63406_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
intptr_t L_8 = (( intptr_t (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return (intptr_t)L_8;
}
}
IL2CPP_EXTERN_C intptr_t InternalEnumerator_1_get_Current_m94C0D13214FB1EC791B1CC5DFE5A82E2AAE63406_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE *>(__this + _offset);
return InternalEnumerator_1_get_Current_m94C0D13214FB1EC791B1CC5DFE5A82E2AAE63406(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.IntPtr>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m491E05099AFA8FC0AED0F826973AF0A2565B1E9B_gshared (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m491E05099AFA8FC0AED0F826973AF0A2565B1E9B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m491E05099AFA8FC0AED0F826973AF0A2565B1E9B(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.IntPtr>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m87769ABA238DC3B1539ABAEFB4A723EDB7F0DF9C_gshared (InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * __this, const RuntimeMethod* method)
{
{
intptr_t L_0 = InternalEnumerator_1_get_Current_m94C0D13214FB1EC791B1CC5DFE5A82E2AAE63406((InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE *)(InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
intptr_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m87769ABA238DC3B1539ABAEFB4A723EDB7F0DF9C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t14D32DF33683F99069D9258BB89E49055A16F9AE *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m87769ABA238DC3B1539ABAEFB4A723EDB7F0DF9C(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Object>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mD75F701A17A7159EEF2877D9FE74845402AC4201_gshared (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mD75F701A17A7159EEF2877D9FE74845402AC4201_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F *>(__this + _offset);
InternalEnumerator_1__ctor_mD75F701A17A7159EEF2877D9FE74845402AC4201(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Object>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m8EAB86BD597ACADB2C2CACC4EE1C95C2AF4B7FE0_gshared (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m8EAB86BD597ACADB2C2CACC4EE1C95C2AF4B7FE0_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F *>(__this + _offset);
InternalEnumerator_1_Dispose_m8EAB86BD597ACADB2C2CACC4EE1C95C2AF4B7FE0(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Object>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m940227577EE2352E678C755A533CD684708D464C_gshared (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m940227577EE2352E678C755A533CD684708D464C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m940227577EE2352E678C755A533CD684708D464C(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Object>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_get_Current_m4CE05D9509A3134EAC31E8340F36EC2B4B54703F_gshared (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m4CE05D9509A3134EAC31E8340F36EC2B4B54703F_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m4CE05D9509A3134EAC31E8340F36EC2B4B54703F_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m4CE05D9509A3134EAC31E8340F36EC2B4B54703F_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
RuntimeObject * L_8 = (( RuntimeObject * (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_get_Current_m4CE05D9509A3134EAC31E8340F36EC2B4B54703F_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F *>(__this + _offset);
return InternalEnumerator_1_get_Current_m4CE05D9509A3134EAC31E8340F36EC2B4B54703F(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Object>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m7BC7629BA183FA12CC79E5271FB346EC4F200C4D_gshared (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m7BC7629BA183FA12CC79E5271FB346EC4F200C4D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m7BC7629BA183FA12CC79E5271FB346EC4F200C4D(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Object>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0A567B403B179EFB6D4D15CF7700244CB66E5AEA_gshared (InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * __this, const RuntimeMethod* method)
{
{
RuntimeObject * L_0 = InternalEnumerator_1_get_Current_m4CE05D9509A3134EAC31E8340F36EC2B4B54703F((InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F *)(InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
return L_0;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0A567B403B179EFB6D4D15CF7700244CB66E5AEA_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tABC4127CF1BC4E9CF08C555CFF56D3286AA53B0F *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0A567B403B179EFB6D4D15CF7700244CB66E5AEA(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.ParameterizedStrings_FormatParam>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mAEB0249C2146033E833B7EBDA3EB88B9A9F90659_gshared (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mAEB0249C2146033E833B7EBDA3EB88B9A9F90659_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 *>(__this + _offset);
InternalEnumerator_1__ctor_mAEB0249C2146033E833B7EBDA3EB88B9A9F90659(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.ParameterizedStrings_FormatParam>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m68BF57EDA1103571F0E0FE5001194B0BB8F3A78F_gshared (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m68BF57EDA1103571F0E0FE5001194B0BB8F3A78F_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 *>(__this + _offset);
InternalEnumerator_1_Dispose_m68BF57EDA1103571F0E0FE5001194B0BB8F3A78F(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.ParameterizedStrings_FormatParam>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mD624D66316245A1A440D7492A5A3C940E1FA3EFC_gshared (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mD624D66316245A1A440D7492A5A3C940E1FA3EFC_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mD624D66316245A1A440D7492A5A3C940E1FA3EFC(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.ParameterizedStrings_FormatParam>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800 InternalEnumerator_1_get_Current_m80B0AC143205EB914B0C033876B87B4C3B344F57_gshared (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m80B0AC143205EB914B0C033876B87B4C3B344F57_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m80B0AC143205EB914B0C033876B87B4C3B344F57_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m80B0AC143205EB914B0C033876B87B4C3B344F57_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800 L_8 = (( FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800 InternalEnumerator_1_get_Current_m80B0AC143205EB914B0C033876B87B4C3B344F57_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m80B0AC143205EB914B0C033876B87B4C3B344F57(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.ParameterizedStrings_FormatParam>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m3485D18CB013850FA9EB78958297150717F3C5EF_gshared (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m3485D18CB013850FA9EB78958297150717F3C5EF_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m3485D18CB013850FA9EB78958297150717F3C5EF(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.ParameterizedStrings_FormatParam>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2979F5923AFE9DF4D43A441505AFDC088D016C8E_gshared (InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * __this, const RuntimeMethod* method)
{
{
FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800 L_0 = InternalEnumerator_1_get_Current_m80B0AC143205EB914B0C033876B87B4C3B344F57((InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 *)(InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
FormatParam_t1901DD0E7CD1B3A17B09040A6E2FCA5307328800 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2979F5923AFE9DF4D43A441505AFDC088D016C8E_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t17674EAEE6107395A98D769397CC3A5E40AE2B41 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2979F5923AFE9DF4D43A441505AFDC088D016C8E(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m226870CF6B7D12848BF991EACF40C735345AB28B_gshared (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m226870CF6B7D12848BF991EACF40C735345AB28B_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 *>(__this + _offset);
InternalEnumerator_1__ctor_m226870CF6B7D12848BF991EACF40C735345AB28B(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m6C8EBC317B2CFAA7DA0D992C194FD95A92926413_gshared (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m6C8EBC317B2CFAA7DA0D992C194FD95A92926413_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 *>(__this + _offset);
InternalEnumerator_1_Dispose_m6C8EBC317B2CFAA7DA0D992C194FD95A92926413(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m0CACB620368208A8F7576489AE8CE43D3CF50ACB_gshared (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m0CACB620368208A8F7576489AE8CE43D3CF50ACB_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m0CACB620368208A8F7576489AE8CE43D3CF50ACB(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E InternalEnumerator_1_get_Current_m1AB3F2C70645660A20831F4A4FDBB1AB61DB8420_gshared (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m1AB3F2C70645660A20831F4A4FDBB1AB61DB8420_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m1AB3F2C70645660A20831F4A4FDBB1AB61DB8420_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m1AB3F2C70645660A20831F4A4FDBB1AB61DB8420_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E L_8 = (( CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E InternalEnumerator_1_get_Current_m1AB3F2C70645660A20831F4A4FDBB1AB61DB8420_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m1AB3F2C70645660A20831F4A4FDBB1AB61DB8420(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC0F15D2E68613F49046B87ACA9F38FA69335EAE4_gshared (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC0F15D2E68613F49046B87ACA9F38FA69335EAE4_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC0F15D2E68613F49046B87ACA9F38FA69335EAE4(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Reflection.CustomAttributeNamedArgument>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m5842A354F96DCDF6DB6E8B1A2A7FE11B12912965_gshared (InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * __this, const RuntimeMethod* method)
{
{
CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E L_0 = InternalEnumerator_1_get_Current_m1AB3F2C70645660A20831F4A4FDBB1AB61DB8420((InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 *)(InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
CustomAttributeNamedArgument_t08BA731A94FD7F173551DF3098384CB9B3056E9E L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m5842A354F96DCDF6DB6E8B1A2A7FE11B12912965_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tDA662EF0D142C3E10EE85A638D895E8ED9560969 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m5842A354F96DCDF6DB6E8B1A2A7FE11B12912965(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m5FF7EDC8E7C9A9250B548F9C9EB5CF3360E889FB_gshared (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m5FF7EDC8E7C9A9250B548F9C9EB5CF3360E889FB_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 *>(__this + _offset);
InternalEnumerator_1__ctor_m5FF7EDC8E7C9A9250B548F9C9EB5CF3360E889FB(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m4EF1DF22F31CAA58E4F6DD4B579E722157C60B68_gshared (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m4EF1DF22F31CAA58E4F6DD4B579E722157C60B68_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 *>(__this + _offset);
InternalEnumerator_1_Dispose_m4EF1DF22F31CAA58E4F6DD4B579E722157C60B68(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mB92131A3838FF515C4E84AFEE0EFBBB0D9CEE12D_gshared (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mB92131A3838FF515C4E84AFEE0EFBBB0D9CEE12D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mB92131A3838FF515C4E84AFEE0EFBBB0D9CEE12D(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 InternalEnumerator_1_get_Current_m3D123B39BCDA4F165484915F8DD3940962AECBF0_gshared (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m3D123B39BCDA4F165484915F8DD3940962AECBF0_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m3D123B39BCDA4F165484915F8DD3940962AECBF0_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m3D123B39BCDA4F165484915F8DD3940962AECBF0_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 L_8 = (( CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 InternalEnumerator_1_get_Current_m3D123B39BCDA4F165484915F8DD3940962AECBF0_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m3D123B39BCDA4F165484915F8DD3940962AECBF0(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m55E5E22BB6ECFA78AD2DA166F453D831C80A0454_gshared (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m55E5E22BB6ECFA78AD2DA166F453D831C80A0454_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m55E5E22BB6ECFA78AD2DA166F453D831C80A0454(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Reflection.CustomAttributeTypedArgument>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m24102447F4216E92F9D6C5449EFA7C4D0303B3A0_gshared (InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * __this, const RuntimeMethod* method)
{
{
CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 L_0 = InternalEnumerator_1_get_Current_m3D123B39BCDA4F165484915F8DD3940962AECBF0((InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 *)(InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
CustomAttributeTypedArgument_t238ACCB3A438CB5EDE4A924C637B288CCEC958E8 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m24102447F4216E92F9D6C5449EFA7C4D0303B3A0_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tFDF713891D6C54C1B5751BA6F9BAB6813215B451 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m24102447F4216E92F9D6C5449EFA7C4D0303B3A0(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Reflection.ParameterModifier>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mDEBB2C6716C9789C8928EC4E44AF6AAB5C270D3C_gshared (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mDEBB2C6716C9789C8928EC4E44AF6AAB5C270D3C_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 *>(__this + _offset);
InternalEnumerator_1__ctor_mDEBB2C6716C9789C8928EC4E44AF6AAB5C270D3C(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Reflection.ParameterModifier>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m0E64CEABEE646480E8568420A7019690D7649941_gshared (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m0E64CEABEE646480E8568420A7019690D7649941_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 *>(__this + _offset);
InternalEnumerator_1_Dispose_m0E64CEABEE646480E8568420A7019690D7649941(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Reflection.ParameterModifier>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m730B50E3F1654202F07EA4CF4B79E444DA499268_gshared (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m730B50E3F1654202F07EA4CF4B79E444DA499268_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m730B50E3F1654202F07EA4CF4B79E444DA499268(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Reflection.ParameterModifier>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E InternalEnumerator_1_get_Current_m81C0B3258A94D63BA8AF4BE1C02FC30E77BCA1C4_gshared (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m81C0B3258A94D63BA8AF4BE1C02FC30E77BCA1C4_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m81C0B3258A94D63BA8AF4BE1C02FC30E77BCA1C4_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m81C0B3258A94D63BA8AF4BE1C02FC30E77BCA1C4_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E L_8 = (( ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E InternalEnumerator_1_get_Current_m81C0B3258A94D63BA8AF4BE1C02FC30E77BCA1C4_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m81C0B3258A94D63BA8AF4BE1C02FC30E77BCA1C4(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Reflection.ParameterModifier>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m77F8981C0DA5CA0ED4BBF6CA038792DC61AA2B07_gshared (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m77F8981C0DA5CA0ED4BBF6CA038792DC61AA2B07_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m77F8981C0DA5CA0ED4BBF6CA038792DC61AA2B07(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Reflection.ParameterModifier>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCD8241095A16E48C02661D5E39C42E18D7F8AD5B_gshared (InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * __this, const RuntimeMethod* method)
{
{
ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E L_0 = InternalEnumerator_1_get_Current_m81C0B3258A94D63BA8AF4BE1C02FC30E77BCA1C4((InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 *)(InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
ParameterModifier_t7BEFF7C52C8D7CD73D787BDAE6A1A50196204E3E L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCD8241095A16E48C02661D5E39C42E18D7F8AD5B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t44527618586A2D396FEAE6DEC17252812D8D2E93 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mCD8241095A16E48C02661D5E39C42E18D7F8AD5B(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Resources.ResourceLocator>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m3E014CF0DDF2BDBCED19F196342255153BDBA51E_gshared (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m3E014CF0DDF2BDBCED19F196342255153BDBA51E_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B *>(__this + _offset);
InternalEnumerator_1__ctor_m3E014CF0DDF2BDBCED19F196342255153BDBA51E(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Resources.ResourceLocator>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m52FBDFDBF43E58009C49B5F1C21DE59215820C75_gshared (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m52FBDFDBF43E58009C49B5F1C21DE59215820C75_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B *>(__this + _offset);
InternalEnumerator_1_Dispose_m52FBDFDBF43E58009C49B5F1C21DE59215820C75(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Resources.ResourceLocator>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mD4C121CEDFFEFB31C6EC9302CBC1192E51F2093A_gshared (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mD4C121CEDFFEFB31C6EC9302CBC1192E51F2093A_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mD4C121CEDFFEFB31C6EC9302CBC1192E51F2093A(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Resources.ResourceLocator>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C InternalEnumerator_1_get_Current_m5474D37CD91A506826F57EEEA5BA8900CC2A212D_gshared (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m5474D37CD91A506826F57EEEA5BA8900CC2A212D_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m5474D37CD91A506826F57EEEA5BA8900CC2A212D_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m5474D37CD91A506826F57EEEA5BA8900CC2A212D_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C L_8 = (( ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C InternalEnumerator_1_get_Current_m5474D37CD91A506826F57EEEA5BA8900CC2A212D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B *>(__this + _offset);
return InternalEnumerator_1_get_Current_m5474D37CD91A506826F57EEEA5BA8900CC2A212D(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Resources.ResourceLocator>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA76FFEF1093C75431297838B18FFBF048A4CB917_gshared (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA76FFEF1093C75431297838B18FFBF048A4CB917_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA76FFEF1093C75431297838B18FFBF048A4CB917(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Resources.ResourceLocator>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6D49286C74B3A35243C731877CCE06A79725DCF9_gshared (InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * __this, const RuntimeMethod* method)
{
{
ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C L_0 = InternalEnumerator_1_get_Current_m5474D37CD91A506826F57EEEA5BA8900CC2A212D((InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B *)(InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
ResourceLocator_t1783916E271C27CB09DF57E7E5ED08ECA4B3275C L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6D49286C74B3A35243C731877CCE06A79725DCF9_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t24E15B5C952B4EE799B582E16877F7F37FA1B70B *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6D49286C74B3A35243C731877CCE06A79725DCF9(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m9E14CFB1C79CC7C9D79DD72B62C9B0F353F8BAB4_gshared (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m9E14CFB1C79CC7C9D79DD72B62C9B0F353F8BAB4_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 *>(__this + _offset);
InternalEnumerator_1__ctor_m9E14CFB1C79CC7C9D79DD72B62C9B0F353F8BAB4(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m969B47D66A78D205B0B3A1CA537C3A9FBCB6EC5D_gshared (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m969B47D66A78D205B0B3A1CA537C3A9FBCB6EC5D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 *>(__this + _offset);
InternalEnumerator_1_Dispose_m969B47D66A78D205B0B3A1CA537C3A9FBCB6EC5D(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m1CD5357A6497F1DB261EA284D09EC306D38ADF48_gshared (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m1CD5357A6497F1DB261EA284D09EC306D38ADF48_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m1CD5357A6497F1DB261EA284D09EC306D38ADF48(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA InternalEnumerator_1_get_Current_mCFB8564C9D825B393AABF73A69BAE8E986796895_gshared (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mCFB8564C9D825B393AABF73A69BAE8E986796895_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mCFB8564C9D825B393AABF73A69BAE8E986796895_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mCFB8564C9D825B393AABF73A69BAE8E986796895_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA L_8 = (( Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA InternalEnumerator_1_get_Current_mCFB8564C9D825B393AABF73A69BAE8E986796895_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 *>(__this + _offset);
return InternalEnumerator_1_get_Current_mCFB8564C9D825B393AABF73A69BAE8E986796895(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m29C2E6DA559A8EBC643267E932846423DBDA5858_gshared (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m29C2E6DA559A8EBC643267E932846423DBDA5858_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m29C2E6DA559A8EBC643267E932846423DBDA5858(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Runtime.CompilerServices.Ephemeron>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0CBEFE2675B461D8C9459F86D1554C6C4E1F80D0_gshared (InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * __this, const RuntimeMethod* method)
{
{
Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA L_0 = InternalEnumerator_1_get_Current_mCFB8564C9D825B393AABF73A69BAE8E986796895((InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 *)(InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
Ephemeron_t6F0B12401657FF132AB44052E5BCD06D358FF1BA L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0CBEFE2675B461D8C9459F86D1554C6C4E1F80D0_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tB642E1D8EF7ED44B1273CC5D1216CFB3FCD005C5 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0CBEFE2675B461D8C9459F86D1554C6C4E1F80D0(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mA819F7E05D294E7B7E037030EB0FD992FB346FC6_gshared (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mA819F7E05D294E7B7E037030EB0FD992FB346FC6_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE *>(__this + _offset);
InternalEnumerator_1__ctor_mA819F7E05D294E7B7E037030EB0FD992FB346FC6(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mD4D3F12484F4B6379333FAC08508D39808224D91_gshared (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mD4D3F12484F4B6379333FAC08508D39808224D91_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE *>(__this + _offset);
InternalEnumerator_1_Dispose_mD4D3F12484F4B6379333FAC08508D39808224D91(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mA2DBBC0E980B2978432B2B220B1189909B91F03F_gshared (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mA2DBBC0E980B2978432B2B220B1189909B91F03F_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mA2DBBC0E980B2978432B2B220B1189909B91F03F(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 InternalEnumerator_1_get_Current_m95BBA6E2E51E7EFE7672D9D8A78D29B9FFDFEAEE_gshared (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m95BBA6E2E51E7EFE7672D9D8A78D29B9FFDFEAEE_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m95BBA6E2E51E7EFE7672D9D8A78D29B9FFDFEAEE_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m95BBA6E2E51E7EFE7672D9D8A78D29B9FFDFEAEE_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 L_8 = (( GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 InternalEnumerator_1_get_Current_m95BBA6E2E51E7EFE7672D9D8A78D29B9FFDFEAEE_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE *>(__this + _offset);
return InternalEnumerator_1_get_Current_m95BBA6E2E51E7EFE7672D9D8A78D29B9FFDFEAEE(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC0579D55B4A9F531AF1351053125A484DB0095F7_gshared (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC0579D55B4A9F531AF1351053125A484DB0095F7_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mC0579D55B4A9F531AF1351053125A484DB0095F7(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Runtime.InteropServices.GCHandle>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8AD84D9CB10EB751A7052B86C5316EBB2BF7717A_gshared (InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * __this, const RuntimeMethod* method)
{
{
GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 L_0 = InternalEnumerator_1_get_Current_m95BBA6E2E51E7EFE7672D9D8A78D29B9FFDFEAEE((InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE *)(InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
GCHandle_t39FAEE3EA592432C93B574A31DD83B87F1847DE3 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8AD84D9CB10EB751A7052B86C5316EBB2BF7717A_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t6E5A69DF1F7B590047C88D1865523046E41013BE *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8AD84D9CB10EB751A7052B86C5316EBB2BF7717A(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.SByte>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mE9379D2FF2800845F39295ECC82CC75C1BFAD2A2_gshared (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mE9379D2FF2800845F39295ECC82CC75C1BFAD2A2_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 *>(__this + _offset);
InternalEnumerator_1__ctor_mE9379D2FF2800845F39295ECC82CC75C1BFAD2A2(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.SByte>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m05749D31B7EEEF1517775595FCB5BDD0873722C1_gshared (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m05749D31B7EEEF1517775595FCB5BDD0873722C1_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 *>(__this + _offset);
InternalEnumerator_1_Dispose_m05749D31B7EEEF1517775595FCB5BDD0873722C1(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.SByte>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m7A514CDCE03B1914EA0CC2EC436A9BDB88026FA7_gshared (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m7A514CDCE03B1914EA0CC2EC436A9BDB88026FA7_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m7A514CDCE03B1914EA0CC2EC436A9BDB88026FA7(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.SByte>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int8_t InternalEnumerator_1_get_Current_mCEBACD4CF4D2DF7FDB7FF8031CCE8725B75DA540_gshared (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mCEBACD4CF4D2DF7FDB7FF8031CCE8725B75DA540_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mCEBACD4CF4D2DF7FDB7FF8031CCE8725B75DA540_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mCEBACD4CF4D2DF7FDB7FF8031CCE8725B75DA540_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
int8_t L_8 = (( int8_t (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C int8_t InternalEnumerator_1_get_Current_mCEBACD4CF4D2DF7FDB7FF8031CCE8725B75DA540_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 *>(__this + _offset);
return InternalEnumerator_1_get_Current_mCEBACD4CF4D2DF7FDB7FF8031CCE8725B75DA540(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.SByte>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6B6DFDBA279C13F9F632240CF4F9CEEF91DB0530_gshared (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6B6DFDBA279C13F9F632240CF4F9CEEF91DB0530_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6B6DFDBA279C13F9F632240CF4F9CEEF91DB0530(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.SByte>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m003EC0581DCE444D5CFBFF92BEF7664C66963B76_gshared (InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * __this, const RuntimeMethod* method)
{
{
int8_t L_0 = InternalEnumerator_1_get_Current_mCEBACD4CF4D2DF7FDB7FF8031CCE8725B75DA540((InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 *)(InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
int8_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m003EC0581DCE444D5CFBFF92BEF7664C66963B76_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tC06CF9ECC04980456B57D662F3199983470BAC33 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m003EC0581DCE444D5CFBFF92BEF7664C66963B76(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Single>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mAA128A1D51031DF02D178B5C5A7316CC7D6C22BE_gshared (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mAA128A1D51031DF02D178B5C5A7316CC7D6C22BE_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 *>(__this + _offset);
InternalEnumerator_1__ctor_mAA128A1D51031DF02D178B5C5A7316CC7D6C22BE(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Single>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m88C5741AF3B1D2EA397DB46512535BC34C871D3C_gshared (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m88C5741AF3B1D2EA397DB46512535BC34C871D3C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 *>(__this + _offset);
InternalEnumerator_1_Dispose_m88C5741AF3B1D2EA397DB46512535BC34C871D3C(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Single>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m61CFF397E0E8740BC9F65E736C1507C05D8FCF32_gshared (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m61CFF397E0E8740BC9F65E736C1507C05D8FCF32_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m61CFF397E0E8740BC9F65E736C1507C05D8FCF32(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Single>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float InternalEnumerator_1_get_Current_m8C4CCAC66EBAE129B0DCCA46A73041A2B0F3B999_gshared (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m8C4CCAC66EBAE129B0DCCA46A73041A2B0F3B999_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m8C4CCAC66EBAE129B0DCCA46A73041A2B0F3B999_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m8C4CCAC66EBAE129B0DCCA46A73041A2B0F3B999_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
float L_8 = (( float (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C float InternalEnumerator_1_get_Current_m8C4CCAC66EBAE129B0DCCA46A73041A2B0F3B999_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m8C4CCAC66EBAE129B0DCCA46A73041A2B0F3B999(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Single>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5F8FEAC529452CDE3CAF154E65C3F0E8B7EDD6C6_gshared (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5F8FEAC529452CDE3CAF154E65C3F0E8B7EDD6C6_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5F8FEAC529452CDE3CAF154E65C3F0E8B7EDD6C6(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Single>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m607EFC7537C7AF61B9224D93F36EDF50577EFE62_gshared (InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * __this, const RuntimeMethod* method)
{
{
float L_0 = InternalEnumerator_1_get_Current_m8C4CCAC66EBAE129B0DCCA46A73041A2B0F3B999((InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 *)(InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
float L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m607EFC7537C7AF61B9224D93F36EDF50577EFE62_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t03E207B84B6F06EAF9F77E2BD1D1D00EA1990DA1 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m607EFC7537C7AF61B9224D93F36EDF50577EFE62(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m7F748D6834D2CDDE775D0EEE50FBF11138CFF61F_gshared (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m7F748D6834D2CDDE775D0EEE50FBF11138CFF61F_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B *>(__this + _offset);
InternalEnumerator_1__ctor_m7F748D6834D2CDDE775D0EEE50FBF11138CFF61F(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m44FBA1A533BB2AD3EDF8E6570E5E0032549BCCE1_gshared (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m44FBA1A533BB2AD3EDF8E6570E5E0032549BCCE1_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B *>(__this + _offset);
InternalEnumerator_1_Dispose_m44FBA1A533BB2AD3EDF8E6570E5E0032549BCCE1(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m6E63B51D31ABC06C44F6EC10392F44AF29319A72_gshared (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m6E63B51D31ABC06C44F6EC10392F44AF29319A72_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m6E63B51D31ABC06C44F6EC10392F44AF29319A72(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B InternalEnumerator_1_get_Current_m4BFF9065A44EB1D4FB065F5709238C6489E5A0C5_gshared (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m4BFF9065A44EB1D4FB065F5709238C6489E5A0C5_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m4BFF9065A44EB1D4FB065F5709238C6489E5A0C5_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m4BFF9065A44EB1D4FB065F5709238C6489E5A0C5_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B L_8 = (( LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B InternalEnumerator_1_get_Current_m4BFF9065A44EB1D4FB065F5709238C6489E5A0C5_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B *>(__this + _offset);
return InternalEnumerator_1_get_Current_m4BFF9065A44EB1D4FB065F5709238C6489E5A0C5(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m61DB74B19C84DF5D0586793E8AE60599FD8D9E3E_gshared (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m61DB74B19C84DF5D0586793E8AE60599FD8D9E3E_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m61DB74B19C84DF5D0586793E8AE60599FD8D9E3E(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Text.RegularExpressions.RegexCharClass_LowerCaseMapping>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mAA35E609F68D4AA4808C8518DBEA1A5DC84FD2F8_gshared (InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * __this, const RuntimeMethod* method)
{
{
LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B L_0 = InternalEnumerator_1_get_Current_m4BFF9065A44EB1D4FB065F5709238C6489E5A0C5((InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B *)(InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
LowerCaseMapping_t3F087D71A4D7A309FD5492CE33501FD4F4709D7B L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mAA35E609F68D4AA4808C8518DBEA1A5DC84FD2F8_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7809E17B643ABB1E006F813D31F8BC3666B5532B *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mAA35E609F68D4AA4808C8518DBEA1A5DC84FD2F8(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m3F65E1A1CF891ED1F8E134CE2EE25E149C327F19_gshared (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m3F65E1A1CF891ED1F8E134CE2EE25E149C327F19_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 *>(__this + _offset);
InternalEnumerator_1__ctor_m3F65E1A1CF891ED1F8E134CE2EE25E149C327F19(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m39C85AF12F54B32A18A618ED54AEB5BABC90F776_gshared (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m39C85AF12F54B32A18A618ED54AEB5BABC90F776_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 *>(__this + _offset);
InternalEnumerator_1_Dispose_m39C85AF12F54B32A18A618ED54AEB5BABC90F776(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m0DBCE94BE0EA9EFB33DA7667DF03CCF8F83E7585_gshared (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m0DBCE94BE0EA9EFB33DA7667DF03CCF8F83E7585_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m0DBCE94BE0EA9EFB33DA7667DF03CCF8F83E7585(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2 InternalEnumerator_1_get_Current_m2EF8D8561F60AAA02F2B3BD2EC7176E50BCD5E52_gshared (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m2EF8D8561F60AAA02F2B3BD2EC7176E50BCD5E52_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m2EF8D8561F60AAA02F2B3BD2EC7176E50BCD5E52_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m2EF8D8561F60AAA02F2B3BD2EC7176E50BCD5E52_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2 L_8 = (( CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2 InternalEnumerator_1_get_Current_m2EF8D8561F60AAA02F2B3BD2EC7176E50BCD5E52_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m2EF8D8561F60AAA02F2B3BD2EC7176E50BCD5E52(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mBEA53E27186A3117450CEAFB374CEB5B73313997_gshared (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mBEA53E27186A3117450CEAFB374CEB5B73313997_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mBEA53E27186A3117450CEAFB374CEB5B73313997(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.Threading.CancellationTokenRegistration>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m343A40850C40793147C70F0A503FD2CB6E4CE4AE_gshared (InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * __this, const RuntimeMethod* method)
{
{
CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2 L_0 = InternalEnumerator_1_get_Current_m2EF8D8561F60AAA02F2B3BD2EC7176E50BCD5E52((InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 *)(InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
CancellationTokenRegistration_tCDB9825D1854DD0D7FF737C82B099FC468107BB2 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m343A40850C40793147C70F0A503FD2CB6E4CE4AE_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t85FC781CD035D7288F957603C85D75D39E11D275 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m343A40850C40793147C70F0A503FD2CB6E4CE4AE(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.TimeSpan>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mC1AEF444A58A2261E281DD76B188FF7538F424EA_gshared (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mC1AEF444A58A2261E281DD76B188FF7538F424EA_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 *>(__this + _offset);
InternalEnumerator_1__ctor_mC1AEF444A58A2261E281DD76B188FF7538F424EA(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.TimeSpan>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mCD40BF3A7626144872F2642F3B34F182DA518793_gshared (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mCD40BF3A7626144872F2642F3B34F182DA518793_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 *>(__this + _offset);
InternalEnumerator_1_Dispose_mCD40BF3A7626144872F2642F3B34F182DA518793(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.TimeSpan>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m5ECDBB64DF2420FD59C457CFD882942454EFEC65_gshared (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m5ECDBB64DF2420FD59C457CFD882942454EFEC65_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m5ECDBB64DF2420FD59C457CFD882942454EFEC65(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.TimeSpan>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 InternalEnumerator_1_get_Current_m08ED2C8C47D5621377FB042EFFFF6038160D427C_gshared (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m08ED2C8C47D5621377FB042EFFFF6038160D427C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m08ED2C8C47D5621377FB042EFFFF6038160D427C_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m08ED2C8C47D5621377FB042EFFFF6038160D427C_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 L_8 = (( TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 InternalEnumerator_1_get_Current_m08ED2C8C47D5621377FB042EFFFF6038160D427C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m08ED2C8C47D5621377FB042EFFFF6038160D427C(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.TimeSpan>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m061C2085607EF3A620F7914BBDFABB38E2F988E5_gshared (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m061C2085607EF3A620F7914BBDFABB38E2F988E5_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m061C2085607EF3A620F7914BBDFABB38E2F988E5(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.TimeSpan>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9D8A5C3B19CDB3A2FA242A18C34301E6D95865C8_gshared (InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * __this, const RuntimeMethod* method)
{
{
TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 L_0 = InternalEnumerator_1_get_Current_m08ED2C8C47D5621377FB042EFFFF6038160D427C((InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 *)(InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
TimeSpan_tA8069278ACE8A74D6DF7D514A9CD4432433F64C4 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9D8A5C3B19CDB3A2FA242A18C34301E6D95865C8_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t3825F16AE52F48A96EE82CCB93F297BF93DDE8F6 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m9D8A5C3B19CDB3A2FA242A18C34301E6D95865C8(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.UInt16>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mFE4EF7DC9B7656A8F9541C6DB174623D677CA6CD_gshared (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mFE4EF7DC9B7656A8F9541C6DB174623D677CA6CD_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F *>(__this + _offset);
InternalEnumerator_1__ctor_mFE4EF7DC9B7656A8F9541C6DB174623D677CA6CD(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.UInt16>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mF86968B10A7E2847776ADFBF834C522CDB599961_gshared (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mF86968B10A7E2847776ADFBF834C522CDB599961_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F *>(__this + _offset);
InternalEnumerator_1_Dispose_mF86968B10A7E2847776ADFBF834C522CDB599961(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.UInt16>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mB8CE82E4885258C6A341B97A978720422A1E9738_gshared (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mB8CE82E4885258C6A341B97A978720422A1E9738_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mB8CE82E4885258C6A341B97A978720422A1E9738(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.UInt16>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t InternalEnumerator_1_get_Current_mB4EDDDE7A9FD306176CCDDC4E9693B40EF7B984B_gshared (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mB4EDDDE7A9FD306176CCDDC4E9693B40EF7B984B_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mB4EDDDE7A9FD306176CCDDC4E9693B40EF7B984B_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mB4EDDDE7A9FD306176CCDDC4E9693B40EF7B984B_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
uint16_t L_8 = (( uint16_t (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C uint16_t InternalEnumerator_1_get_Current_mB4EDDDE7A9FD306176CCDDC4E9693B40EF7B984B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F *>(__this + _offset);
return InternalEnumerator_1_get_Current_mB4EDDDE7A9FD306176CCDDC4E9693B40EF7B984B(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.UInt16>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m116599B0F101CFB030D78D7AFD984D465A4C6F83_gshared (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m116599B0F101CFB030D78D7AFD984D465A4C6F83_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m116599B0F101CFB030D78D7AFD984D465A4C6F83(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.UInt16>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1F016830E08D4370DEE1C0F0136A9F75CB608CE0_gshared (InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * __this, const RuntimeMethod* method)
{
{
uint16_t L_0 = InternalEnumerator_1_get_Current_mB4EDDDE7A9FD306176CCDDC4E9693B40EF7B984B((InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F *)(InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
uint16_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1F016830E08D4370DEE1C0F0136A9F75CB608CE0_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t1E63AA3D1031EDFCDD5492D233629B5909AEAF2F *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1F016830E08D4370DEE1C0F0136A9F75CB608CE0(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.UInt32>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m577E98213388A2A32E776481E79087B4BEC45B01_gshared (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m577E98213388A2A32E776481E79087B4BEC45B01_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 *>(__this + _offset);
InternalEnumerator_1__ctor_m577E98213388A2A32E776481E79087B4BEC45B01(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.UInt32>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m8FF972AE2AF8D8C8EBF974D4B9CC114114E76C8B_gshared (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m8FF972AE2AF8D8C8EBF974D4B9CC114114E76C8B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 *>(__this + _offset);
InternalEnumerator_1_Dispose_m8FF972AE2AF8D8C8EBF974D4B9CC114114E76C8B(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.UInt32>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m8D45F4F482D6E2899C7E9A9E11CE3A9E7390D10C_gshared (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m8D45F4F482D6E2899C7E9A9E11CE3A9E7390D10C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m8D45F4F482D6E2899C7E9A9E11CE3A9E7390D10C(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.UInt32>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t InternalEnumerator_1_get_Current_m7A52D8C9B31569083E11811B585B6D3BABA3A948_gshared (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m7A52D8C9B31569083E11811B585B6D3BABA3A948_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m7A52D8C9B31569083E11811B585B6D3BABA3A948_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m7A52D8C9B31569083E11811B585B6D3BABA3A948_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
uint32_t L_8 = (( uint32_t (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C uint32_t InternalEnumerator_1_get_Current_m7A52D8C9B31569083E11811B585B6D3BABA3A948_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m7A52D8C9B31569083E11811B585B6D3BABA3A948(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.UInt32>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mE3C9251CD4163687394B2503AEEF0E2E7EB2ECC5_gshared (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mE3C9251CD4163687394B2503AEEF0E2E7EB2ECC5_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mE3C9251CD4163687394B2503AEEF0E2E7EB2ECC5(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.UInt32>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m886F80208845CAF7BEB08CD40275D4453CA3427A_gshared (InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = InternalEnumerator_1_get_Current_m7A52D8C9B31569083E11811B585B6D3BABA3A948((InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 *)(InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
uint32_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m886F80208845CAF7BEB08CD40275D4453CA3427A_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEBADE0A4696976CF836588C8812305FAB47500E8 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m886F80208845CAF7BEB08CD40275D4453CA3427A(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.UInt64>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m7292D20FBAECFA8BCEA4475F6BBE6AC30075B45E_gshared (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m7292D20FBAECFA8BCEA4475F6BBE6AC30075B45E_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A *>(__this + _offset);
InternalEnumerator_1__ctor_m7292D20FBAECFA8BCEA4475F6BBE6AC30075B45E(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.UInt64>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mD466713709A8E59C335DBE0FFF5EFA8855CE93C9_gshared (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mD466713709A8E59C335DBE0FFF5EFA8855CE93C9_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A *>(__this + _offset);
InternalEnumerator_1_Dispose_mD466713709A8E59C335DBE0FFF5EFA8855CE93C9(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.UInt64>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m4F5A6CEDFCDD55DFACBF1BF4FE66A19BDAA14CBF_gshared (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m4F5A6CEDFCDD55DFACBF1BF4FE66A19BDAA14CBF_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m4F5A6CEDFCDD55DFACBF1BF4FE66A19BDAA14CBF(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.UInt64>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t InternalEnumerator_1_get_Current_mEACBD5ABDAC498CC39F2D794C276AFCB4B23D5A6_gshared (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mEACBD5ABDAC498CC39F2D794C276AFCB4B23D5A6_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mEACBD5ABDAC498CC39F2D794C276AFCB4B23D5A6_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mEACBD5ABDAC498CC39F2D794C276AFCB4B23D5A6_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
uint64_t L_8 = (( uint64_t (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C uint64_t InternalEnumerator_1_get_Current_mEACBD5ABDAC498CC39F2D794C276AFCB4B23D5A6_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A *>(__this + _offset);
return InternalEnumerator_1_get_Current_mEACBD5ABDAC498CC39F2D794C276AFCB4B23D5A6(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.UInt64>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mED2DD8750E377B5B9B3D6C18B841712DCC6B79A7_gshared (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mED2DD8750E377B5B9B3D6C18B841712DCC6B79A7_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mED2DD8750E377B5B9B3D6C18B841712DCC6B79A7(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.UInt64>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD46DCC366FA87AE6E061E4789BB1C74A5DA10B3B_gshared (InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * __this, const RuntimeMethod* method)
{
{
uint64_t L_0 = InternalEnumerator_1_get_Current_mEACBD5ABDAC498CC39F2D794C276AFCB4B23D5A6((InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A *)(InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
uint64_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD46DCC366FA87AE6E061E4789BB1C74A5DA10B3B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t18780D970F20B0B5C0B9CD2F694765170404909A *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mD46DCC366FA87AE6E061E4789BB1C74A5DA10B3B(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<System.UIntPtr>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mFA2C0D7C19279B4FE83F179D8BB3FE277CD6BB40_gshared (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mFA2C0D7C19279B4FE83F179D8BB3FE277CD6BB40_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 *>(__this + _offset);
InternalEnumerator_1__ctor_mFA2C0D7C19279B4FE83F179D8BB3FE277CD6BB40(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<System.UIntPtr>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m8EB8FF6C30EC949B10E0008F0FCF5E0AEA78F6D6_gshared (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m8EB8FF6C30EC949B10E0008F0FCF5E0AEA78F6D6_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 *>(__this + _offset);
InternalEnumerator_1_Dispose_m8EB8FF6C30EC949B10E0008F0FCF5E0AEA78F6D6(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<System.UIntPtr>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m872C83B5D2E2C798AB5482B0919DCC9EF3E0D613_gshared (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m872C83B5D2E2C798AB5482B0919DCC9EF3E0D613_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m872C83B5D2E2C798AB5482B0919DCC9EF3E0D613(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<System.UIntPtr>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uintptr_t InternalEnumerator_1_get_Current_m898EF6FD732B94B5BA3C6CFC17B8C3897D0C5B6B_gshared (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m898EF6FD732B94B5BA3C6CFC17B8C3897D0C5B6B_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m898EF6FD732B94B5BA3C6CFC17B8C3897D0C5B6B_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m898EF6FD732B94B5BA3C6CFC17B8C3897D0C5B6B_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
uintptr_t L_8 = (( uintptr_t (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C uintptr_t InternalEnumerator_1_get_Current_m898EF6FD732B94B5BA3C6CFC17B8C3897D0C5B6B_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m898EF6FD732B94B5BA3C6CFC17B8C3897D0C5B6B(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<System.UIntPtr>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDF094F535B0402FBE582B4CBF3B943D5919FB798_gshared (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDF094F535B0402FBE582B4CBF3B943D5919FB798_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mDF094F535B0402FBE582B4CBF3B943D5919FB798(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<System.UIntPtr>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m868092AD29D3DEA8DFA21574DCA9D751BCD65B6C_gshared (InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * __this, const RuntimeMethod* method)
{
{
uintptr_t L_0 = InternalEnumerator_1_get_Current_m898EF6FD732B94B5BA3C6CFC17B8C3897D0C5B6B((InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 *)(InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
uintptr_t L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m868092AD29D3DEA8DFA21574DCA9D751BCD65B6C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t46883D49972CD2D1DC7ED8D9AE6D9CC0DC8DD490 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m868092AD29D3DEA8DFA21574DCA9D751BCD65B6C(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m0CE98768FA95BB57698E7D51B48485337983B3A6_gshared (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m0CE98768FA95BB57698E7D51B48485337983B3A6_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 *>(__this + _offset);
InternalEnumerator_1__ctor_m0CE98768FA95BB57698E7D51B48485337983B3A6(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m720EC1E93AD8CBDB05BB4E9DE7B14892F51DE771_gshared (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m720EC1E93AD8CBDB05BB4E9DE7B14892F51DE771_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 *>(__this + _offset);
InternalEnumerator_1_Dispose_m720EC1E93AD8CBDB05BB4E9DE7B14892F51DE771(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mE291D66A15F236A0AF25EC165D0AB1C3322A1685_gshared (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mE291D66A15F236A0AF25EC165D0AB1C3322A1685_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mE291D66A15F236A0AF25EC165D0AB1C3322A1685(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727 InternalEnumerator_1_get_Current_mF3A24C3ABE3B152A3C3A30863E92D79103A50BA1_gshared (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mF3A24C3ABE3B152A3C3A30863E92D79103A50BA1_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mF3A24C3ABE3B152A3C3A30863E92D79103A50BA1_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mF3A24C3ABE3B152A3C3A30863E92D79103A50BA1_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727 L_8 = (( OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727 InternalEnumerator_1_get_Current_mF3A24C3ABE3B152A3C3A30863E92D79103A50BA1_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 *>(__this + _offset);
return InternalEnumerator_1_get_Current_mF3A24C3ABE3B152A3C3A30863E92D79103A50BA1(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m067658D2CA96B529EB660B05302D2CE3B39C7E1A_gshared (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m067658D2CA96B529EB660B05302D2CE3B39C7E1A_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m067658D2CA96B529EB660B05302D2CE3B39C7E1A(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<UnityEngine.BeforeRenderHelper_OrderBlock>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m78F6CCA9BF95D5E77745394EFA9DA416D89098C0_gshared (InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * __this, const RuntimeMethod* method)
{
{
OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727 L_0 = InternalEnumerator_1_get_Current_mF3A24C3ABE3B152A3C3A30863E92D79103A50BA1((InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 *)(InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
OrderBlock_t3B2BBCE8320FAEC3DB605F7DC9AB641102F53727 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m78F6CCA9BF95D5E77745394EFA9DA416D89098C0_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tD82DDB412EA40C89BC64A6C92E3EE836B0491C20 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m78F6CCA9BF95D5E77745394EFA9DA416D89098C0(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Color32>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mA76CB6C92F93D4D154DEF97B62B04875E9DD0C0C_gshared (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mA76CB6C92F93D4D154DEF97B62B04875E9DD0C0C_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 *>(__this + _offset);
InternalEnumerator_1__ctor_mA76CB6C92F93D4D154DEF97B62B04875E9DD0C0C(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Color32>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mE55774E2396C5AE20E56EC04F520945363A489B9_gshared (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mE55774E2396C5AE20E56EC04F520945363A489B9_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 *>(__this + _offset);
InternalEnumerator_1_Dispose_mE55774E2396C5AE20E56EC04F520945363A489B9(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<UnityEngine.Color32>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m677EA6BD7E9DF5EE4A08D0A7A229D4F099D15B70_gshared (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m677EA6BD7E9DF5EE4A08D0A7A229D4F099D15B70_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m677EA6BD7E9DF5EE4A08D0A7A229D4F099D15B70(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<UnityEngine.Color32>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 InternalEnumerator_1_get_Current_m80E4BACA28C64E50461E74B92DEE28DD5C49A580_gshared (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m80E4BACA28C64E50461E74B92DEE28DD5C49A580_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m80E4BACA28C64E50461E74B92DEE28DD5C49A580_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m80E4BACA28C64E50461E74B92DEE28DD5C49A580_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 L_8 = (( Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 InternalEnumerator_1_get_Current_m80E4BACA28C64E50461E74B92DEE28DD5C49A580_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m80E4BACA28C64E50461E74B92DEE28DD5C49A580(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Color32>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5E4EBF6B2AAA4014717EA1653979D34CEECE24CA_gshared (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5E4EBF6B2AAA4014717EA1653979D34CEECE24CA_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m5E4EBF6B2AAA4014717EA1653979D34CEECE24CA(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<UnityEngine.Color32>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mE73D1EC7DC5AEA554051C0D37A9E295058779760_gshared (InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * __this, const RuntimeMethod* method)
{
{
Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 L_0 = InternalEnumerator_1_get_Current_m80E4BACA28C64E50461E74B92DEE28DD5C49A580((InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 *)(InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
Color32_t23ABC4AE0E0BDFD2E22EE1FA0DA3904FFE5F6E23 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mE73D1EC7DC5AEA554051C0D37A9E295058779760_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tEDC15E304166341C3089DF741B003631E7DED5F9 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mE73D1EC7DC5AEA554051C0D37A9E295058779760(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m2009C5E8886D700C065C716EF1D08BACA6B8087F_gshared (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m2009C5E8886D700C065C716EF1D08BACA6B8087F_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 *>(__this + _offset);
InternalEnumerator_1__ctor_m2009C5E8886D700C065C716EF1D08BACA6B8087F(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m77AAB4FA0C543E276DDD0B102DFBE7FCDA30EF84_gshared (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m77AAB4FA0C543E276DDD0B102DFBE7FCDA30EF84_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 *>(__this + _offset);
InternalEnumerator_1_Dispose_m77AAB4FA0C543E276DDD0B102DFBE7FCDA30EF84(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m39F2F8FCB3BA39695FB2A1DEC28855172B6E5D4A_gshared (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m39F2F8FCB3BA39695FB2A1DEC28855172B6E5D4A_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m39F2F8FCB3BA39695FB2A1DEC28855172B6E5D4A(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91 InternalEnumerator_1_get_Current_mB7A85C3324689374F5BBE1813C0439798CDFF9CB_gshared (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mB7A85C3324689374F5BBE1813C0439798CDFF9CB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mB7A85C3324689374F5BBE1813C0439798CDFF9CB_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mB7A85C3324689374F5BBE1813C0439798CDFF9CB_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91 L_8 = (( RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91 InternalEnumerator_1_get_Current_mB7A85C3324689374F5BBE1813C0439798CDFF9CB_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 *>(__this + _offset);
return InternalEnumerator_1_get_Current_mB7A85C3324689374F5BBE1813C0439798CDFF9CB(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m853CB9E446725D1B5FCA19FD9A4D48B5B5FECB63_gshared (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m853CB9E446725D1B5FCA19FD9A4D48B5B5FECB63_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m853CB9E446725D1B5FCA19FD9A4D48B5B5FECB63(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<UnityEngine.EventSystems.RaycastResult>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8E1C99A6B2906E3087932AFEF36212027CC4061D_gshared (InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * __this, const RuntimeMethod* method)
{
{
RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91 L_0 = InternalEnumerator_1_get_Current_mB7A85C3324689374F5BBE1813C0439798CDFF9CB((InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 *)(InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
RaycastResult_t991BCED43A91EDD8580F39631DA07B1F88C58B91 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8E1C99A6B2906E3087932AFEF36212027CC4061D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7EB7634ED0C887F88FEE64219734A39C3617ED84 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m8E1C99A6B2906E3087932AFEF36212027CC4061D(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m090BB39068F5FAEBC457FE64EBE4DA412ED1EFDC_gshared (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m090BB39068F5FAEBC457FE64EBE4DA412ED1EFDC_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 *>(__this + _offset);
InternalEnumerator_1__ctor_m090BB39068F5FAEBC457FE64EBE4DA412ED1EFDC(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m17AD15A48F9CDF8D46E8580E3CEFC6F5D2836901_gshared (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m17AD15A48F9CDF8D46E8580E3CEFC6F5D2836901_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 *>(__this + _offset);
InternalEnumerator_1_Dispose_m17AD15A48F9CDF8D46E8580E3CEFC6F5D2836901(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m26900C6C96A7B745F63A23F111699B6C143AAE16_gshared (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m26900C6C96A7B745F63A23F111699B6C143AAE16_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m26900C6C96A7B745F63A23F111699B6C143AAE16(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2 InternalEnumerator_1_get_Current_mA90DEF143C9B52AABD722C59391860F4421B8D6C_gshared (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mA90DEF143C9B52AABD722C59391860F4421B8D6C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mA90DEF143C9B52AABD722C59391860F4421B8D6C_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mA90DEF143C9B52AABD722C59391860F4421B8D6C_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2 L_8 = (( LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2 InternalEnumerator_1_get_Current_mA90DEF143C9B52AABD722C59391860F4421B8D6C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 *>(__this + _offset);
return InternalEnumerator_1_get_Current_mA90DEF143C9B52AABD722C59391860F4421B8D6C(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6910B345DBCBBF0C51B12306365DDC4490D26FDE_gshared (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6910B345DBCBBF0C51B12306365DDC4490D26FDE_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m6910B345DBCBBF0C51B12306365DDC4490D26FDE(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC8201A170A6AE7E43400EEE1DC7DD3A78CAE3A86_gshared (InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * __this, const RuntimeMethod* method)
{
{
LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2 L_0 = InternalEnumerator_1_get_Current_mA90DEF143C9B52AABD722C59391860F4421B8D6C((InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 *)(InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
LightDataGI_t922D8894A3151C4F87AFD0A3562252320CA3B2A2 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC8201A170A6AE7E43400EEE1DC7DD3A78CAE3A86_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t8D40E423A143613E114B594A0507E3D3D43D7888 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mC8201A170A6AE7E43400EEE1DC7DD3A78CAE3A86(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Keyframe>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m53F1CFC38C88469A9029DF819DCDDCE98487450A_gshared (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m53F1CFC38C88469A9029DF819DCDDCE98487450A_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 *>(__this + _offset);
InternalEnumerator_1__ctor_m53F1CFC38C88469A9029DF819DCDDCE98487450A(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Keyframe>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_mA73E7B7883E5D7E92D433DF0A315C5D93999F3BC_gshared (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_mA73E7B7883E5D7E92D433DF0A315C5D93999F3BC_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 *>(__this + _offset);
InternalEnumerator_1_Dispose_mA73E7B7883E5D7E92D433DF0A315C5D93999F3BC(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<UnityEngine.Keyframe>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m5AF8DEADCAFA428FB19D5A6BD9AB03ACBC4E2529_gshared (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m5AF8DEADCAFA428FB19D5A6BD9AB03ACBC4E2529_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m5AF8DEADCAFA428FB19D5A6BD9AB03ACBC4E2529(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<UnityEngine.Keyframe>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74 InternalEnumerator_1_get_Current_m423DED00D8E4A4F471ACF4A96345C45C4378F556_gshared (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m423DED00D8E4A4F471ACF4A96345C45C4378F556_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m423DED00D8E4A4F471ACF4A96345C45C4378F556_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m423DED00D8E4A4F471ACF4A96345C45C4378F556_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74 L_8 = (( Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74 InternalEnumerator_1_get_Current_m423DED00D8E4A4F471ACF4A96345C45C4378F556_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m423DED00D8E4A4F471ACF4A96345C45C4378F556(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Keyframe>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m883E5884C422A9F29875971082BB78699FB05CC2_gshared (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m883E5884C422A9F29875971082BB78699FB05CC2_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m883E5884C422A9F29875971082BB78699FB05CC2(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<UnityEngine.Keyframe>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m43B13AEAA9229073FEC9D245DD86BA6C7271C778_gshared (InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * __this, const RuntimeMethod* method)
{
{
Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74 L_0 = InternalEnumerator_1_get_Current_m423DED00D8E4A4F471ACF4A96345C45C4378F556((InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 *)(InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
Keyframe_t9E945CACC5AC36E067B15A634096A223A06D2D74 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m43B13AEAA9229073FEC9D245DD86BA6C7271C778_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t7A5024384E3A020AA1432ACA92E569DADE321F07 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m43B13AEAA9229073FEC9D245DD86BA6C7271C778(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m02C8360860C5438D895C11BB0AD8FC4F1A84B31A_gshared (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m02C8360860C5438D895C11BB0AD8FC4F1A84B31A_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 *>(__this + _offset);
InternalEnumerator_1__ctor_m02C8360860C5438D895C11BB0AD8FC4F1A84B31A(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m7089BC2386B69BD1D6A077BAB7EF4FC870FBF3A4_gshared (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m7089BC2386B69BD1D6A077BAB7EF4FC870FBF3A4_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 *>(__this + _offset);
InternalEnumerator_1_Dispose_m7089BC2386B69BD1D6A077BAB7EF4FC870FBF3A4(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m3DE3F342FDB99BAF186349D0A92573B0457B5E8D_gshared (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m3DE3F342FDB99BAF186349D0A92573B0457B5E8D_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m3DE3F342FDB99BAF186349D0A92573B0457B5E8D(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93 InternalEnumerator_1_get_Current_mCF3BFAF3BCAACDF803583C88DD293C5B812A145C_gshared (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mCF3BFAF3BCAACDF803583C88DD293C5B812A145C_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mCF3BFAF3BCAACDF803583C88DD293C5B812A145C_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mCF3BFAF3BCAACDF803583C88DD293C5B812A145C_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93 L_8 = (( PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93 InternalEnumerator_1_get_Current_mCF3BFAF3BCAACDF803583C88DD293C5B812A145C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 *>(__this + _offset);
return InternalEnumerator_1_get_Current_mCF3BFAF3BCAACDF803583C88DD293C5B812A145C(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m8ED9FEB6CB357866559DA8F1EB2357D2A2AF4C12_gshared (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m8ED9FEB6CB357866559DA8F1EB2357D2A2AF4C12_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m8ED9FEB6CB357866559DA8F1EB2357D2A2AF4C12(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<UnityEngine.LowLevel.PlayerLoopSystem>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mFE74BD11BA547725F31D73E2B0D9D52E766974A0_gshared (InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * __this, const RuntimeMethod* method)
{
{
PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93 L_0 = InternalEnumerator_1_get_Current_mCF3BFAF3BCAACDF803583C88DD293C5B812A145C((InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 *)(InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
PlayerLoopSystem_t4F3CE091F496538800DC1FF6E750BFA72FEB8C93 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mFE74BD11BA547725F31D73E2B0D9D52E766974A0_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tA49F87207D9C71EB0F5BD0C0AF3A7F08A6AD9769 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mFE74BD11BA547725F31D73E2B0D9D52E766974A0(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Plane>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mEB73FE451C65A512459AF88DD8D0FE7380EDF3D0_gshared (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mEB73FE451C65A512459AF88DD8D0FE7380EDF3D0_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 *>(__this + _offset);
InternalEnumerator_1__ctor_mEB73FE451C65A512459AF88DD8D0FE7380EDF3D0(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Plane>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m180D8619B6A23257FC75B397E08E49A799C4FE21_gshared (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m180D8619B6A23257FC75B397E08E49A799C4FE21_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 *>(__this + _offset);
InternalEnumerator_1_Dispose_m180D8619B6A23257FC75B397E08E49A799C4FE21(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<UnityEngine.Plane>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m3C69C6DCCF2CD3D57E04836C025D1F6A6C4C6968_gshared (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m3C69C6DCCF2CD3D57E04836C025D1F6A6C4C6968_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m3C69C6DCCF2CD3D57E04836C025D1F6A6C4C6968(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<UnityEngine.Plane>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED InternalEnumerator_1_get_Current_mE52FE5CD07FFC9C64D612B428D4C9CE7BD68C140_gshared (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_mE52FE5CD07FFC9C64D612B428D4C9CE7BD68C140_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_mE52FE5CD07FFC9C64D612B428D4C9CE7BD68C140_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_mE52FE5CD07FFC9C64D612B428D4C9CE7BD68C140_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED L_8 = (( Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED InternalEnumerator_1_get_Current_mE52FE5CD07FFC9C64D612B428D4C9CE7BD68C140_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 *>(__this + _offset);
return InternalEnumerator_1_get_Current_mE52FE5CD07FFC9C64D612B428D4C9CE7BD68C140(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Plane>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m8CEF9D7220336ED895EDC381CFB017FD626D28BD_gshared (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m8CEF9D7220336ED895EDC381CFB017FD626D28BD_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m8CEF9D7220336ED895EDC381CFB017FD626D28BD(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<UnityEngine.Plane>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB6DF41AE2CF0E39492CBF01D41C79A2AD588D93F_gshared (InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * __this, const RuntimeMethod* method)
{
{
Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED L_0 = InternalEnumerator_1_get_Current_mE52FE5CD07FFC9C64D612B428D4C9CE7BD68C140((InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 *)(InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
Plane_t0903921088DEEDE1BCDEA5BF279EDBCFC9679AED L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB6DF41AE2CF0E39492CBF01D41C79A2AD588D93F_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t58DEC4E77A6650C8845F8986DE756BA539846722 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mB6DF41AE2CF0E39492CBF01D41C79A2AD588D93F(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_mF99DDB9595945AEC3CB62FAAF94AE0B1DC69ADDB_gshared (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_mF99DDB9595945AEC3CB62FAAF94AE0B1DC69ADDB_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 *>(__this + _offset);
InternalEnumerator_1__ctor_mF99DDB9595945AEC3CB62FAAF94AE0B1DC69ADDB(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m51B757A0306D3F268AD6471871FBEEBB522A61D6_gshared (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m51B757A0306D3F268AD6471871FBEEBB522A61D6_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 *>(__this + _offset);
InternalEnumerator_1_Dispose_m51B757A0306D3F268AD6471871FBEEBB522A61D6(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m06838EFE676483F59B23F9AED5EDC25307714819_gshared (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m06838EFE676483F59B23F9AED5EDC25307714819_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m06838EFE676483F59B23F9AED5EDC25307714819(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8 InternalEnumerator_1_get_Current_m409E760F9CBF152E005D1ABB74D0D4208D56227F_gshared (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m409E760F9CBF152E005D1ABB74D0D4208D56227F_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m409E760F9CBF152E005D1ABB74D0D4208D56227F_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m409E760F9CBF152E005D1ABB74D0D4208D56227F_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8 L_8 = (( PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8 InternalEnumerator_1_get_Current_m409E760F9CBF152E005D1ABB74D0D4208D56227F_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m409E760F9CBF152E005D1ABB74D0D4208D56227F(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m544181F0799962E6A3C803D778B166694730EB37_gshared (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m544181F0799962E6A3C803D778B166694730EB37_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m544181F0799962E6A3C803D778B166694730EB37(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<UnityEngine.Playables.PlayableBinding>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0D484DEF2526C455371ED5D16CB02AD3FAD8C523_gshared (InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * __this, const RuntimeMethod* method)
{
{
PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8 L_0 = InternalEnumerator_1_get_Current_m409E760F9CBF152E005D1ABB74D0D4208D56227F((InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 *)(InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
PlayableBinding_t4D92F4CF16B8608DD83947E5D40CB7690F23F9C8 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0D484DEF2526C455371ED5D16CB02AD3FAD8C523_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tFC7038FDBC7930D18917601A9B699057989B9429 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m0D484DEF2526C455371ED5D16CB02AD3FAD8C523(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<UnityEngine.RaycastHit2D>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m830814E57A2D1219D886501A9029DEED40DD6635_gshared (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m830814E57A2D1219D886501A9029DEED40DD6635_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD *>(__this + _offset);
InternalEnumerator_1__ctor_m830814E57A2D1219D886501A9029DEED40DD6635(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.RaycastHit2D>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m210975609AF4E5F2A41A9E2D0CFFF0CAA90B5585_gshared (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m210975609AF4E5F2A41A9E2D0CFFF0CAA90B5585_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD *>(__this + _offset);
InternalEnumerator_1_Dispose_m210975609AF4E5F2A41A9E2D0CFFF0CAA90B5585(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<UnityEngine.RaycastHit2D>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_mCDA22D571C4E009906699C4AB8BA2DE7A3D94302_gshared (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_mCDA22D571C4E009906699C4AB8BA2DE7A3D94302_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD *>(__this + _offset);
return InternalEnumerator_1_MoveNext_mCDA22D571C4E009906699C4AB8BA2DE7A3D94302(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<UnityEngine.RaycastHit2D>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE InternalEnumerator_1_get_Current_m8DD1DD354BD2CCD8BF53308EE859FD91BAC319F4_gshared (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m8DD1DD354BD2CCD8BF53308EE859FD91BAC319F4_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m8DD1DD354BD2CCD8BF53308EE859FD91BAC319F4_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m8DD1DD354BD2CCD8BF53308EE859FD91BAC319F4_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE L_8 = (( RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE InternalEnumerator_1_get_Current_m8DD1DD354BD2CCD8BF53308EE859FD91BAC319F4_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD *>(__this + _offset);
return InternalEnumerator_1_get_Current_m8DD1DD354BD2CCD8BF53308EE859FD91BAC319F4(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.RaycastHit2D>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA7B96D62B276CF6419B4931598F51F617FBAD8C4_gshared (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA7B96D62B276CF6419B4931598F51F617FBAD8C4_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_mA7B96D62B276CF6419B4931598F51F617FBAD8C4(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<UnityEngine.RaycastHit2D>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mFABE9B6A837F021896FCC9A5575D1AD8A90B0C40_gshared (InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * __this, const RuntimeMethod* method)
{
{
RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE L_0 = InternalEnumerator_1_get_Current_m8DD1DD354BD2CCD8BF53308EE859FD91BAC319F4((InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD *)(InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
RaycastHit2D_t5E8A7F96317BAF2033362FC780F4D72DC72764BE L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mFABE9B6A837F021896FCC9A5575D1AD8A90B0C40_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_tD7C0F82796D37564733877089E26C2B2D2B950AD *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_mFABE9B6A837F021896FCC9A5575D1AD8A90B0C40(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Array_InternalEnumerator`1<UnityEngine.RaycastHit>::.ctor(System.Array)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1__ctor_m116E15DD07CF4905FCA6B327A46E6DC056560A77_gshared (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
{
RuntimeArray * L_0 = ___array0;
__this->set_array_0(L_0);
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1__ctor_m116E15DD07CF4905FCA6B327A46E6DC056560A77_AdjustorThunk (RuntimeObject * __this, RuntimeArray * ___array0, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 *>(__this + _offset);
InternalEnumerator_1__ctor_m116E15DD07CF4905FCA6B327A46E6DC056560A77(_thisAdjusted, ___array0, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.RaycastHit>::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_Dispose_m213BB289521A11B41BDA96FDCBC473571C0F7134_gshared (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method)
{
{
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_Dispose_m213BB289521A11B41BDA96FDCBC473571C0F7134_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 *>(__this + _offset);
InternalEnumerator_1_Dispose_m213BB289521A11B41BDA96FDCBC473571C0F7134(_thisAdjusted, method);
}
// System.Boolean System.Array_InternalEnumerator`1<UnityEngine.RaycastHit>::MoveNext()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool InternalEnumerator_1_MoveNext_m102F72F47F424F98374FB84922BF92F939ACE282_gshared (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001b;
}
}
{
RuntimeArray * L_1 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_1);
int32_t L_2 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_1, /*hidden argument*/NULL);
__this->set_idx_1(L_2);
}
IL_001b:
{
int32_t L_3 = (int32_t)__this->get_idx_1();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_003c;
}
}
{
int32_t L_4 = (int32_t)__this->get_idx_1();
V_0 = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_4, (int32_t)1));
int32_t L_5 = V_0;
__this->set_idx_1(L_5);
int32_t L_6 = V_0;
return (bool)((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
IL_003c:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C bool InternalEnumerator_1_MoveNext_m102F72F47F424F98374FB84922BF92F939ACE282_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 *>(__this + _offset);
return InternalEnumerator_1_MoveNext_m102F72F47F424F98374FB84922BF92F939ACE282(_thisAdjusted, method);
}
// T System.Array_InternalEnumerator`1<UnityEngine.RaycastHit>::get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3 InternalEnumerator_1_get_Current_m7DAF45BE6246754B95E518F44152AB86F6F01503_gshared (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (InternalEnumerator_1_get_Current_m7DAF45BE6246754B95E518F44152AB86F6F01503_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0015;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_1 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_1, (String_t*)_stringLiteral2743196813A5635EC097418239BD515966A50491, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, InternalEnumerator_1_get_Current_m7DAF45BE6246754B95E518F44152AB86F6F01503_RuntimeMethod_var);
}
IL_0015:
{
int32_t L_2 = (int32_t)__this->get_idx_1();
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0029;
}
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_3 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_3, (String_t*)_stringLiteral81B88171F853E60535AA475D08BD5584CD5E2503, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, InternalEnumerator_1_get_Current_m7DAF45BE6246754B95E518F44152AB86F6F01503_RuntimeMethod_var);
}
IL_0029:
{
RuntimeArray * L_4 = (RuntimeArray *)__this->get_array_0();
RuntimeArray * L_5 = (RuntimeArray *)__this->get_array_0();
NullCheck((RuntimeArray *)L_5);
int32_t L_6 = Array_get_Length_m2239B6393651C3F4631D900EFC1B05DBE8F5466D((RuntimeArray *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)__this->get_idx_1();
NullCheck((RuntimeArray *)L_4);
RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3 L_8 = (( RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3 (*) (RuntimeArray *, int32_t, const RuntimeMethod*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0)->methodPointer)((RuntimeArray *)L_4, (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_6, (int32_t)1)), (int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 0));
return L_8;
}
}
IL2CPP_EXTERN_C RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3 InternalEnumerator_1_get_Current_m7DAF45BE6246754B95E518F44152AB86F6F01503_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 *>(__this + _offset);
return InternalEnumerator_1_get_Current_m7DAF45BE6246754B95E518F44152AB86F6F01503(_thisAdjusted, method);
}
// System.Void System.Array_InternalEnumerator`1<UnityEngine.RaycastHit>::System.Collections.IEnumerator.Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m42B612DDDCBC1C31AC83DDDAA4382E7C8FED7384_gshared (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method)
{
{
__this->set_idx_1(((int32_t)-2));
return;
}
}
IL2CPP_EXTERN_C void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m42B612DDDCBC1C31AC83DDDAA4382E7C8FED7384_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 *>(__this + _offset);
InternalEnumerator_1_System_Collections_IEnumerator_Reset_m42B612DDDCBC1C31AC83DDDAA4382E7C8FED7384(_thisAdjusted, method);
}
// System.Object System.Array_InternalEnumerator`1<UnityEngine.RaycastHit>::System.Collections.IEnumerator.get_Current()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6AB1B76B5D46EFE4ACDA056F38B79D9449AE806E_gshared (InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * __this, const RuntimeMethod* method)
{
{
RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3 L_0 = InternalEnumerator_1_get_Current_m7DAF45BE6246754B95E518F44152AB86F6F01503((InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 *)(InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->klass)->rgctx_data, 1));
RaycastHit_t19695F18F9265FE5425062BBA6A4D330480538C3 L_1 = L_0;
RuntimeObject * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->klass)->rgctx_data, 2), &L_1);
return L_2;
}
}
IL2CPP_EXTERN_C RuntimeObject * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6AB1B76B5D46EFE4ACDA056F38B79D9449AE806E_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
int32_t _offset = 1;
InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 * _thisAdjusted = reinterpret_cast<InternalEnumerator_1_t34829C5FB85B3F38559760F59924458D62074B95 *>(__this + _offset);
return InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m6AB1B76B5D46EFE4ACDA056F38B79D9449AE806E(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"[email protected]"
] | |
6be6eee1613f4f519e74886686359cc482ec851d | a5a46d6b7a1b348d895e85f2918f9a48676d760e | /src/Application.cpp | 8aa4c8cb3af14d4e1b6e18e460c8da4e8201418b | [] | no_license | dAmihl/ppg-visualizer | 39704ed3745046747c6884e8129e99a2154b1138 | 222adf02f04f425da11f5813dc38693b69acf3d4 | refs/heads/master | 2023-07-30T03:57:46.318733 | 2021-09-28T14:37:04 | 2021-09-28T14:37:04 | 410,973,219 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 983 | cpp | #include "Yaml2Puzzle.h"
#include "imgui.h"
#include "imgui_impl_glfw.h"
#include "imgui_impl_opengl3.h"
#include <stdio.h>
#include <GLFW/glfw3.h> // Will drag system OpenGL headers
#include "WindowContext.h"
int main(int, char**)
{
PPGViz::WindowContext w;
ImGuiIO& io = ImGui::GetIO(); (void)io;
Yaml2Puzzle y2p;
auto P = y2p.generatePuzzleByFile("resources/universe1.yaml");
auto roots = P->getGraphRepresentation();
auto& pairs = P->getRelation().getPairs();
// Main loop
while (!w.shouldClose())
{
w.update();
{
ImGui::Begin("Puzzle Text");
ImGui::Text(P->getExtendedTextualRepresentation().c_str());
ImGui::End();
}
{
ImGui::Begin("Puzzle Events");
for (auto& e : P->getContext().getEvents())
{
auto btnText = (e->getRelatedObject().getObjectName() + ":" + e->getEventName());
if (ImGui::Button(btnText.c_str()))
{
P->handleEvent(*e);
}
}
ImGui::End();
}
w.drawPuzzle(*P);
w.render();
}
return 0;
} | [
"[email protected]"
] | |
54a7bf61ce6fc80ef1243c5dde4218e878c5247e | 0bab33d355ee30502c2f5cead12e5390709197ac | /CompassExample/CompassExample.ino | 442cd2f71fcdea1d73a3e6ad3120b266cbe53b43 | [] | no_license | infinity922/ENGG160_Repo | 03ecbc61a77439900195d4eac94f08da93e6e6f7 | 8006f95a6972ce5e65107bf0ebd08b987455a020 | refs/heads/master | 2020-12-18T12:05:18.099415 | 2020-04-08T23:41:07 | 2020-04-08T23:41:07 | 235,373,469 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,180 | ino | /* This example uses the magnetometer in the Zumo Shield's onboard
* LSM303DLHC to help the Zumo make precise 90-degree turns and drive
* in squares. It uses ZumoMotors, Pushbutton, and the LSM303
* (compass) library.
*
* This program first calibrates the compass to account for offsets in
* its output. Calibration is accomplished in setup().
*
* In loop(), The driving angle then changes its offset by 90 degrees
* from the heading every second. Essentially, this navigates the
* Zumo to drive in square patterns.
*
* It is important to note that stray magnetic fields from electric
* current (including from the Zumo's own motors) and the environment
* (for example, steel rebar in a concrete floor) might adversely
* affect readings from the LSM303 compass and make them less
* reliable.
*/
#include <Wire.h>
#include <ZumoShield.h>
#define SPEED 200 // Maximum motor speed when going straight; variable speed when turning
#define TURN_BASE_SPEED 100 // Base speed when turning (added to variable speed)
#define CALIBRATION_SAMPLES 70 // Number of compass readings to take when calibrating
#define CRB_REG_M_2_5GAUSS 0x60 // CRB_REG_M value for magnetometer +/-2.5 gauss full scale
#define CRA_REG_M_220HZ 0x1C // CRA_REG_M value for magnetometer 220 Hz update rate
// Allowed deviation (in degrees) relative to target angle that must be achieved before driving straight
#define DEVIATION_THRESHOLD 5
ZumoMotors motors;
Pushbutton button(ZUMO_BUTTON);
LSM303 compass;
// Setup will calibrate our compass by finding maximum/minimum magnetic readings
void setup()
{
// The highest possible magnetic value to read in any direction is 2047
// The lowest possible magnetic value to read in any direction is -2047
LSM303::vector<int16_t> running_min = {32767, 32767, 32767}, running_max = {-32767, -32767, -32767};
unsigned char index;
Serial.begin(9600);
// Initiate the Wire library and join the I2C bus as a master
Wire.begin();
// Initiate LSM303
compass.init();
// Enables accelerometer and magnetometer
compass.enableDefault();
compass.writeReg(LSM303::CRB_REG_M, CRB_REG_M_2_5GAUSS); // +/- 2.5 gauss sensitivity to hopefully avoid overflow problems
compass.writeReg(LSM303::CRA_REG_M, CRA_REG_M_220HZ); // 220 Hz compass update rate
button.waitForButton();
Serial.println("starting calibration");
// To calibrate the magnetometer, the Zumo spins to find the max/min
// magnetic vectors. This information is used to correct for offsets
// in the magnetometer data.
motors.setLeftSpeed(SPEED);
motors.setRightSpeed(-SPEED);
for(index = 0; index < CALIBRATION_SAMPLES; index ++)
{
// Take a reading of the magnetic vector and store it in compass.m
compass.read();
running_min.x = min(running_min.x, compass.m.x);
running_min.y = min(running_min.y, compass.m.y);
running_max.x = max(running_max.x, compass.m.x);
running_max.y = max(running_max.y, compass.m.y);
Serial.println(index);
delay(50);
}
motors.setLeftSpeed(0);
motors.setRightSpeed(0);
Serial.print("max.x ");
Serial.print(running_max.x);
Serial.println();
Serial.print("max.y ");
Serial.print(running_max.y);
Serial.println();
Serial.print("min.x ");
Serial.print(running_min.x);
Serial.println();
Serial.print("min.y ");
Serial.print(running_min.y);
Serial.println();
// Set calibrated values to compass.m_max and compass.m_min
compass.m_max.x = running_max.x;
compass.m_max.y = running_max.y;
compass.m_min.x = running_min.x;
compass.m_min.y = running_min.y;
button.waitForButton();
}
void loop()
{
float heading, relative_heading;
int speed;
static float target_heading = averageHeading();
// Heading is given in degrees away from the magnetic vector, increasing clockwise
heading = averageHeading();
// This gives us the relative heading with respect to the target angle
relative_heading = relativeHeading(heading, target_heading);
Serial.print("Target heading: ");
Serial.print(target_heading);
Serial.print(" Actual heading: ");
Serial.print(heading);
Serial.print(" Difference: ");
Serial.print(relative_heading);
// If the Zumo has turned to the direction it wants to be pointing, go straight and then do another turn
if(abs(relative_heading) < DEVIATION_THRESHOLD)
{
motors.setSpeeds(SPEED, SPEED);
Serial.print(" Straight");
delay(1000);
// Turn off motors and wait a short time to reduce interference from motors
motors.setSpeeds(0, 0);
delay(100);
// Turn 90 degrees relative to the direction we are pointing.
// This will help account for variable magnetic field, as opposed
// to using fixed increments of 90 degrees from the initial
// heading (which might have been measured in a different magnetic
// field than the one the Zumo is experiencing now).
// Note: fmod() is floating point modulo
target_heading = fmod(averageHeading() + 90, 360);
}
else
{
// To avoid overshooting, the closer the Zumo gets to the target
// heading, the slower it should turn. Set the motor speeds to a
// minimum base amount plus an additional variable amount based
// on the heading difference.
speed = SPEED*relative_heading/180;
if (speed < 0)
speed -= TURN_BASE_SPEED;
else
speed += TURN_BASE_SPEED;
motors.setSpeeds(speed, -speed);
Serial.print(" Turn");
}
Serial.println();
}
// Converts x and y components of a vector to a heading in degrees.
// This function is used instead of LSM303::heading() because we don't
// want the acceleration of the Zumo to factor spuriously into the
// tilt compensation that LSM303::heading() performs. This calculation
// assumes that the Zumo is always level.
template <typename T> float heading(LSM303::vector<T> v)
{
float x_scaled = 2.0*(float)(v.x - compass.m_min.x) / ( compass.m_max.x - compass.m_min.x) - 1.0;
float y_scaled = 2.0*(float)(v.y - compass.m_min.y) / (compass.m_max.y - compass.m_min.y) - 1.0;
float angle = atan2(y_scaled, x_scaled)*180 / M_PI;
if (angle < 0)
angle += 360;
return angle;
}
// Yields the angle difference in degrees between two headings
float relativeHeading(float heading_from, float heading_to)
{
float relative_heading = heading_to - heading_from;
// constrain to -180 to 180 degree range
if (relative_heading > 180)
relative_heading -= 360;
if (relative_heading < -180)
relative_heading += 360;
return relative_heading;
}
// Average 10 vectors to get a better measurement and help smooth out
// the motors' magnetic interference.
float averageHeading()
{
LSM303::vector<int32_t> avg = {0, 0, 0};
for(int i = 0; i < 10; i ++)
{
compass.read();
avg.x += compass.m.x;
avg.y += compass.m.y;
}
avg.x /= 10.0;
avg.y /= 10.0;
// avg is the average measure of the magnetic vector.
return heading(avg);
}
| [
"[email protected]"
] | |
3ead1f8c0f657482c10d99ab5ce6f6a9351744d7 | 2851759f8e9b36197858e9ae5307ea6239da5e2e | /system/ulib/inspect/include/lib/inspect/snapshot.h | f1b592346e42d95f53058d3a7c5f7422f3393830 | [
"BSD-3-Clause",
"MIT"
] | permissive | Allegra42/zircon | a1a809f005c04d4cf2af672c47a2f13161848ca0 | 50d20f11275ecdd47faa393e3ff6465cee07a670 | refs/heads/master | 2020-04-05T08:02:40.558430 | 2018-12-29T00:28:46 | 2018-12-29T23:42:27 | 156,698,935 | 1 | 1 | NOASSERTION | 2018-11-08T11:48:25 | 2018-11-08T11:48:24 | null | UTF-8 | C++ | false | false | 3,379 | h | // Copyright 2019 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#pragma once
#include <fbl/array.h>
#include <fbl/function.h>
#include <lib/inspect/block.h>
#include <lib/zx/vmo.h>
#include <unistd.h>
#include <zircon/types.h>
namespace inspect {
// |Snapshot| parses an incoming VMO buffer and produces a snapshot of
// the VMO contents. |Snapshot::Options| determines the behavior of
// snapshotting if a concurrent write potentially occurred.
//
// Example:
// fbl::unique_ptr<Snapshot> snapshot;
// zx_status_t status = Snapshot::Create(std::move(vmo),
// {.read_attempts = 1024, .skip_consistency_check = false},
// &snapshot);
//
// Test Example:
// zx_status_t status = Snapshot::Create(std::move(vmo),
// {.read_attempts = 1024, .skip_consistency_check = false},
// fbl::make_unique<TestCallback>(),
// &snapshot);
class Snapshot final {
public:
struct Options {
// The number of attempts to read a consistent snapshot.
// Reading fails if the number of attempts exceeds this number.
int read_attempts;
// If true, skip checking the buffer for consistency.
bool skip_consistency_check;
};
// Type for observing reads on the VMO.
using ReadObserver = fbl::Function<void(uint8_t* buffer, size_t buffer_size)>;
// By default, ensure consistency of the incoming Inspect VMO and retry up to
// 1024 times.
static constexpr Options kDefaultOptions = {.read_attempts = 1024,
.skip_consistency_check = false};
// Create a new snapshot of the given VMO and default options.
static zx_status_t Create(zx::vmo vmo, Snapshot* out_snapshot);
// Create a new snapshot of the given VMO and given options.
static zx_status_t Create(zx::vmo vmo, Options options, Snapshot* out_snapshot);
// Create a new snapshot of the given VMO, given options, and the given read observer
// for observing snapshot operations.
static zx_status_t Create(zx::vmo vmo, Options options, ReadObserver read_observer,
Snapshot* out_snapshot);
Snapshot() = default;
~Snapshot() = default;
Snapshot(Snapshot&&) = default;
Snapshot& operator=(Snapshot&&) = default;
operator bool() const { return buffer_.size() > 0; }
// Returns the start of the snapshot data, if valid.
const uint8_t* data() const { return buffer_.begin(); }
// Returns the size of the snapshot, if valid.
size_t size() const { return buffer_.size(); }
// Get a pointer to a block in the buffer by index.
// Returns nullptr if the index is out of bounds.
internal::Block* GetBlock(internal::BlockIndex index) const;
private:
// Read from the VMO into a buffer.
static zx_status_t Read(zx::vmo& vmo, size_t size, uint8_t* buffer);
// Parse the header from a buffer and obtain the generation count.
static zx_status_t ParseHeader(uint8_t* buffer, uint64_t* out_generation_count);
// Take a new snapshot of the VMO with default options.
// If reading fails, the boolean value of the constructed |Snapshot| will be false.
explicit Snapshot(fbl::Array<uint8_t> buffer);
// The buffer storing the snapshot.
fbl::Array<uint8_t> buffer_;
};
} // namespace inspect
| [
"[email protected]"
] | |
20889aad9d10a79ccec694b3d32fc1d1bafa4e1b | 73935c1814a8fe260167d4aa1b01d39de72f5c0f | /src/server/game/Grids/Notifiers/GridNotifiers.h | c6ed6fd45b80426966655a618bddcae8ce034b9a | [] | no_license | planee/Mop-548 | e794ed978237f355efa813c2be8f8fb14d1907dc | a852cc0be53fcc2951b51452e3ebaa9f1d7d7397 | refs/heads/master | 2022-12-23T01:08:51.566255 | 2020-09-25T03:55:52 | 2020-09-25T03:55:52 | 298,549,776 | 1 | 7 | null | 2020-09-25T11:10:28 | 2020-09-25T11:10:27 | null | UTF-8 | C++ | false | false | 57,385 | h | /*
* Copyright (C) 2008-2012 TrinityCore <http://www.trinitycore.org/>
* Copyright (C) 2005-2009 MaNGOS <http://getmangos.com/>
*
* This program is free software; you can redistribute it and/or modify it
* under the terms of the GNU General Public License as published by the
* Free Software Foundation; either version 2 of the License, or (at your
* option) any later version.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for
* more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*/
#ifndef TRINITY_GRIDNOTIFIERS_H
#define TRINITY_GRIDNOTIFIERS_H
#include "ObjectGridLoader.h"
#include "UpdateData.h"
#include <iostream>
#include "Corpse.h"
#include "Object.h"
#include "AreaTrigger.h"
#include "DynamicObject.h"
#include "GameObject.h"
#include "Player.h"
#include "Unit.h"
#include "CreatureAI.h"
#include "Spell.h"
class Player;
//class Map;
namespace WoWSource
{
struct VisibleNotifier
{
Player &i_player;
UpdateData i_data;
std::set<Unit*> i_visibleNow;
Player::ClientGUIDs vis_guids;
VisibleNotifier(Player &player) : i_player(player), i_data(player.GetMapId()), vis_guids(player.m_clientGUIDs) {}
template<class T> void Visit(GridRefManager<T> &m);
void SendToSelf(void);
};
struct VisibleChangesNotifier
{
WorldObject &i_object;
explicit VisibleChangesNotifier(WorldObject &object) : i_object(object) {}
template<class T> void Visit(GridRefManager<T> &) {}
void Visit(PlayerMapType &);
void Visit(CreatureMapType &);
void Visit(DynamicObjectMapType &);
};
struct PlayerRelocationNotifier : public VisibleNotifier
{
PlayerRelocationNotifier(Player &player) : VisibleNotifier(player) {}
template<class T> void Visit(GridRefManager<T> &m) { VisibleNotifier::Visit(m); }
void Visit(CreatureMapType &);
void Visit(PlayerMapType &);
};
struct CreatureRelocationNotifier
{
Creature &i_creature;
CreatureRelocationNotifier(Creature &c) : i_creature(c) {}
template<class T> void Visit(GridRefManager<T> &) {}
void Visit(CreatureMapType &);
void Visit(PlayerMapType &);
};
struct DelayedUnitRelocation
{
Map &i_map;
Cell &cell;
CellCoord &p;
const float i_radius;
DelayedUnitRelocation(Cell &c, CellCoord &pair, Map &map, float radius) :
i_map(map), cell(c), p(pair), i_radius(radius) {}
template<class T> void Visit(GridRefManager<T> &) {}
void Visit(CreatureMapType &);
void Visit(PlayerMapType &);
};
struct AIRelocationNotifier
{
Unit &i_unit;
bool isCreature;
explicit AIRelocationNotifier(Unit &unit) : i_unit(unit), isCreature(unit.GetTypeId() == TYPEID_UNIT) {}
template<class T> void Visit(GridRefManager<T> &) {}
void Visit(CreatureMapType &);
};
struct GridUpdater
{
GridType &i_grid;
uint32 i_timeDiff;
GridUpdater(GridType &grid, uint32 diff) : i_grid(grid), i_timeDiff(diff) {}
template<class T> void updateObjects(GridRefManager<T> &m)
{
for (typename GridRefManager<T>::iterator iter = m.begin(); iter != m.end(); ++iter)
iter->getSource()->Update(i_timeDiff);
}
void Visit(PlayerMapType &m) { updateObjects<Player>(m); }
void Visit(CreatureMapType &m){ updateObjects<Creature>(m); }
void Visit(GameObjectMapType &m) { updateObjects<GameObject>(m); }
void Visit(DynamicObjectMapType &m) { updateObjects<DynamicObject>(m); }
void Visit(CorpseMapType &m) { updateObjects<Corpse>(m); }
void Visit(AreaTriggerMapType &m) { updateObjects<AreaTrigger>(m); }
};
struct MessageDistDeliverer
{
WorldObject* i_source;
WorldPacket* i_message;
uint32 i_phaseMask;
float i_distSq;
uint32 team;
Player const* skipped_receiver;
MessageDistDeliverer(WorldObject* src, WorldPacket* msg, float dist, bool own_team_only = false, Player const* skipped = NULL)
: i_source(src), i_message(msg), i_phaseMask(src->GetPhaseMask()), i_distSq(dist * dist)
, team((own_team_only && src->GetTypeId() == TYPEID_PLAYER) ? ((Player*)src)->GetTeam() : 0)
, skipped_receiver(skipped)
{
}
void Visit(PlayerMapType &m);
void Visit(CreatureMapType &m);
void Visit(DynamicObjectMapType &m);
template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
void SendPacket(Player* player)
{
// never send packet to self
if (player == i_source || (team && player->GetTeam() != team) || skipped_receiver == player)
return;
if (!player->HaveAtClient(i_source))
return;
if (WorldSession* session = player->GetSession())
session->SendPacket(i_message);
}
};
struct UnfriendlyMessageDistDeliverer
{
Unit* i_source;
WorldPacket* i_message;
uint32 i_phaseMask;
float i_distSq;
UnfriendlyMessageDistDeliverer(Unit* src, WorldPacket* msg, float dist)
: i_source(src), i_message(msg), i_phaseMask(src->GetPhaseMask()), i_distSq(dist * dist)
{
}
void Visit(PlayerMapType &m);
template<class SKIP> void Visit(GridRefManager<SKIP> &) {}
void SendPacket(Player* player)
{
// never send packet to self
if (player == i_source || (player->IsFriendlyTo(i_source)))
return;
if (!player->HaveAtClient(i_source))
return;
if (WorldSession* session = player->GetSession())
session->SendPacket(i_message);
if (i_message->GetOpcode() == SMSG_CLEAR_TARGET)
{
for (uint32 i = CURRENT_MELEE_SPELL; i < CURRENT_AUTOREPEAT_SPELL; ++i)
{
Spell * spell = player->GetCurrentSpell(i);
if (spell && spell->GetUnitTarget() == ((Unit*)i_source) && spell->getState() == SPELL_STATE_CASTING)
spell->cancel();
}
}
}
};
struct ObjectUpdater
{
uint32 i_timeDiff;
explicit ObjectUpdater(const uint32 diff) : i_timeDiff(diff) {}
template<class T> void Visit(GridRefManager<T> &m);
void Visit(PlayerMapType &) {}
void Visit(CorpseMapType &) {}
void Visit(CreatureMapType &);
};
// SEARCHERS & LIST SEARCHERS & WORKERS
// WorldObject searchers & workers
template<class Check>
struct WorldObjectSearcher
{
uint32 i_mapTypeMask;
uint32 i_phaseMask;
WorldObject* &i_object;
Check &i_check;
WorldObjectSearcher(WorldObject const* searcher, WorldObject* & result, Check& check, uint32 mapTypeMask = GRID_MAP_TYPE_MASK_ALL)
: i_mapTypeMask(mapTypeMask), i_phaseMask(searcher->GetPhaseMask()), i_object(result), i_check(check) {}
void Visit(GameObjectMapType &m);
void Visit(PlayerMapType &m);
void Visit(CreatureMapType &m);
void Visit(CorpseMapType &m);
void Visit(DynamicObjectMapType &m);
void Visit(AreaTriggerMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
template<class Check>
struct WorldObjectLastSearcher
{
uint32 i_mapTypeMask;
uint32 i_phaseMask;
WorldObject* &i_object;
Check &i_check;
WorldObjectLastSearcher(WorldObject const* searcher, WorldObject* & result, Check& check, uint32 mapTypeMask = GRID_MAP_TYPE_MASK_ALL)
: i_mapTypeMask(mapTypeMask), i_phaseMask(searcher->GetPhaseMask()), i_object(result), i_check(check) {}
void Visit(GameObjectMapType &m);
void Visit(PlayerMapType &m);
void Visit(CreatureMapType &m);
void Visit(CorpseMapType &m);
void Visit(DynamicObjectMapType &m);
void Visit(AreaTriggerMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
template<class Check>
struct WorldObjectListSearcher
{
uint32 i_mapTypeMask;
uint32 i_phaseMask;
std::list<WorldObject*> &i_objects;
Check& i_check;
WorldObjectListSearcher(WorldObject const* searcher, std::list<WorldObject*> &objects, Check & check, uint32 mapTypeMask = GRID_MAP_TYPE_MASK_ALL)
: i_mapTypeMask(mapTypeMask), i_phaseMask(searcher->GetPhaseMask()), i_objects(objects), i_check(check) {}
void Visit(PlayerMapType &m);
void Visit(CreatureMapType &m);
void Visit(CorpseMapType &m);
void Visit(GameObjectMapType &m);
void Visit(DynamicObjectMapType &m);
void Visit(AreaTriggerMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
template<class Do>
struct WorldObjectWorker
{
uint32 i_mapTypeMask;
uint32 i_phaseMask;
Do const& i_do;
WorldObjectWorker(WorldObject const* searcher, Do const& _do, uint32 mapTypeMask = GRID_MAP_TYPE_MASK_ALL)
: i_mapTypeMask(mapTypeMask), i_phaseMask(searcher->GetPhaseMask()), i_do(_do) {}
void Visit(GameObjectMapType &m)
{
if (!(i_mapTypeMask & GRID_MAP_TYPE_MASK_GAMEOBJECT))
return;
for (GameObjectMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
if (itr->getSource()->InSamePhase(i_phaseMask))
i_do(itr->getSource());
}
void Visit(PlayerMapType &m)
{
if (!(i_mapTypeMask & GRID_MAP_TYPE_MASK_PLAYER))
return;
for (PlayerMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
if (itr->getSource()->InSamePhase(i_phaseMask))
i_do(itr->getSource());
}
void Visit(CreatureMapType &m)
{
if (!(i_mapTypeMask & GRID_MAP_TYPE_MASK_CREATURE))
return;
for (CreatureMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
if (itr->getSource()->InSamePhase(i_phaseMask))
i_do(itr->getSource());
}
void Visit(CorpseMapType &m)
{
if (!(i_mapTypeMask & GRID_MAP_TYPE_MASK_CORPSE))
return;
for (CorpseMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
if (itr->getSource()->InSamePhase(i_phaseMask))
i_do(itr->getSource());
}
void Visit(DynamicObjectMapType &m)
{
if (!(i_mapTypeMask & GRID_MAP_TYPE_MASK_DYNAMICOBJECT))
return;
for (DynamicObjectMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
if (itr->getSource()->InSamePhase(i_phaseMask))
i_do(itr->getSource());
}
void Visit(AreaTriggerMapType &m)
{
if (!(i_mapTypeMask & GRID_MAP_TYPE_MASK_AREATRIGGER))
return;
for (AreaTriggerMapType::iterator itr = m.begin(); itr != m.end(); ++itr)
if (itr->getSource()->InSamePhase(i_phaseMask))
i_do(itr->getSource());
}
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
/// AreaTriggers searchers
template<class Check>
struct AreaTriggerListSearcher
{
uint32 m_PhaseMask;
std::list<AreaTrigger*> &m_AreaTriggers;
Check& m_Check;
AreaTriggerListSearcher(WorldObject const* p_Searcher, std::list<AreaTrigger*>& p_AreaTriggers, Check& p_Check)
: m_PhaseMask(p_Searcher->GetPhaseMask()), m_AreaTriggers(p_AreaTriggers), m_Check(p_Check) {}
void Visit(AreaTriggerMapType& p_AreaTriggerMap);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
template<class Check>
struct AreaTriggerSearcher
{
uint32 i_phaseMask;
AreaTrigger* &i_object;
Check & i_check;
AreaTriggerSearcher(WorldObject const* searcher, AreaTrigger* & result, Check & check)
: i_phaseMask(searcher->GetPhaseMask()), i_object(result), i_check(check) {}
void Visit(AreaTriggerMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
// Gameobject searchers
template<class Check>
struct GameObjectSearcher
{
uint32 i_phaseMask;
GameObject* &i_object;
Check &i_check;
GameObjectSearcher(WorldObject const* searcher, GameObject* & result, Check& check)
: i_phaseMask(searcher->GetPhaseMask()), i_object(result), i_check(check) {}
void Visit(GameObjectMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
// Last accepted by Check GO if any (Check can change requirements at each call)
template<class Check>
struct GameObjectLastSearcher
{
uint32 i_phaseMask;
GameObject* &i_object;
Check& i_check;
GameObjectLastSearcher(WorldObject const* searcher, GameObject* & result, Check& check)
: i_phaseMask(searcher->GetPhaseMask()), i_object(result), i_check(check) {}
void Visit(GameObjectMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
template<class Check>
struct GameObjectListSearcher
{
uint32 i_phaseMask;
std::list<GameObject*> &i_objects;
Check& i_check;
GameObjectListSearcher(WorldObject const* searcher, std::list<GameObject*> &objects, Check & check)
: i_phaseMask(searcher->GetPhaseMask()), i_objects(objects), i_check(check) {}
void Visit(GameObjectMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
template<class Functor>
struct GameObjectWorker
{
GameObjectWorker(WorldObject const* searcher, Functor& func)
: _func(func), _phaseMask(searcher->GetPhaseMask()) {}
void Visit(GameObjectMapType& m)
{
for (GameObjectMapType::iterator itr = m.begin(); itr != m.end(); ++itr)
if (itr->getSource()->InSamePhase(_phaseMask))
_func(itr->getSource());
}
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
private:
Functor& _func;
uint32 _phaseMask;
};
// Unit searchers
// First accepted by Check Unit if any
template<class Check>
struct UnitSearcher
{
uint32 i_phaseMask;
Unit* &i_object;
Check & i_check;
UnitSearcher(WorldObject const* searcher, Unit* & result, Check & check)
: i_phaseMask(searcher->GetPhaseMask()), i_object(result), i_check(check) {}
void Visit(CreatureMapType &m);
void Visit(PlayerMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
// Last accepted by Check Unit if any (Check can change requirements at each call)
template<class Check>
struct UnitLastSearcher
{
uint32 i_phaseMask;
Unit* &i_object;
Check & i_check;
UnitLastSearcher(WorldObject const* searcher, Unit* & result, Check & check)
: i_phaseMask(searcher->GetPhaseMask()), i_object(result), i_check(check) {}
void Visit(CreatureMapType &m);
void Visit(PlayerMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
// All accepted by Check units if any
template<class Check>
struct UnitListSearcher
{
uint32 i_phaseMask;
std::list<Unit*> &i_objects;
Check& i_check;
UnitListSearcher(WorldObject const* searcher, std::list<Unit*> &objects, Check & check)
: i_phaseMask(searcher->GetPhaseMask()), i_objects(objects), i_check(check) {}
void Visit(PlayerMapType &m);
void Visit(CreatureMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
// Creature searchers
template<class Check>
struct CreatureSearcher
{
uint32 i_phaseMask;
Creature* &i_object;
Check & i_check;
CreatureSearcher(WorldObject const* searcher, Creature* & result, Check & check)
: i_phaseMask(searcher->GetPhaseMask()), i_object(result), i_check(check) {}
void Visit(CreatureMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
// Last accepted by Check Creature if any (Check can change requirements at each call)
template<class Check>
struct CreatureLastSearcher
{
uint32 i_phaseMask;
Creature* &i_object;
Check & i_check;
CreatureLastSearcher(WorldObject const* searcher, Creature* & result, Check & check)
: i_phaseMask(searcher->GetPhaseMask()), i_object(result), i_check(check) {}
void Visit(CreatureMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
template<class Check>
struct CreatureListSearcher
{
uint32 i_phaseMask;
std::list<Creature*> &i_objects;
Check& i_check;
CreatureListSearcher(WorldObject const* searcher, std::list<Creature*> &objects, Check & check)
: i_phaseMask(searcher->GetPhaseMask()), i_objects(objects), i_check(check) {}
void Visit(CreatureMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
template<class Do>
struct CreatureWorker
{
uint32 i_phaseMask;
Do& i_do;
CreatureWorker(WorldObject const* searcher, Do& _do)
: i_phaseMask(searcher->GetPhaseMask()), i_do(_do) {}
void Visit(CreatureMapType &m)
{
for (CreatureMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
if (itr->getSource()->InSamePhase(i_phaseMask))
i_do(itr->getSource());
}
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
// Player searchers
template<class Check>
struct PlayerSearcher
{
uint32 i_phaseMask;
Player* &i_object;
Check & i_check;
PlayerSearcher(WorldObject const* searcher, Player* & result, Check & check)
: i_phaseMask(searcher->GetPhaseMask()), i_object(result), i_check(check) {}
void Visit(PlayerMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
template<class Check>
struct PlayerListSearcher
{
uint32 i_phaseMask;
std::list<Player*> &i_objects;
Check& i_check;
PlayerListSearcher(WorldObject const* searcher, std::list<Player*> &objects, Check & check)
: i_phaseMask(searcher->GetPhaseMask()), i_objects(objects), i_check(check) {}
void Visit(PlayerMapType &m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
template<class Check>
struct PlayerLastSearcher
{
uint32 i_phaseMask;
Player* &i_object;
Check& i_check;
PlayerLastSearcher(WorldObject const* searcher, Player*& result, Check& check) : i_phaseMask(searcher->GetPhaseMask()), i_object(result), i_check(check)
{
}
void Visit(PlayerMapType& m);
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
template<class Do>
struct PlayerWorker
{
uint32 i_phaseMask;
Do& i_do;
PlayerWorker(WorldObject const* searcher, Do& _do)
: i_phaseMask(searcher->GetPhaseMask()), i_do(_do) {}
void Visit(PlayerMapType &m)
{
for (PlayerMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
if (itr->getSource()->InSamePhase(i_phaseMask))
i_do(itr->getSource());
}
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
template<class Do>
struct PlayerDistWorker
{
WorldObject const* i_searcher;
float i_dist;
Do& i_do;
PlayerDistWorker(WorldObject const* searcher, float _dist, Do& _do)
: i_searcher(searcher), i_dist(_dist), i_do(_do) {}
void Visit(PlayerMapType &m)
{
for (PlayerMapType::iterator itr=m.begin(); itr != m.end(); ++itr)
if (itr->getSource()->InSamePhase(i_searcher) && itr->getSource()->IsWithinDist(i_searcher, i_dist))
i_do(itr->getSource());
}
template<class NOT_INTERESTED> void Visit(GridRefManager<NOT_INTERESTED> &) {}
};
// CHECKS && DO classes
// WorldObject check classes
class AnyDeadUnitObjectInRangeCheck
{
public:
AnyDeadUnitObjectInRangeCheck(Unit* searchObj, float range) : i_searchObj(searchObj), i_range(range) {}
bool operator()(Player* u);
bool operator()(Corpse* u);
bool operator()(Creature* u);
template<class NOT_INTERESTED> bool operator()(NOT_INTERESTED*) { return false; }
protected:
Unit const* const i_searchObj;
float i_range;
};
class AnyDeadUnitSpellTargetInRangeCheck : public AnyDeadUnitObjectInRangeCheck
{
public:
AnyDeadUnitSpellTargetInRangeCheck(Unit* searchObj, float range, SpellInfo const* spellInfo, SpellTargetCheckTypes check)
: AnyDeadUnitObjectInRangeCheck(searchObj, range), i_spellInfo(spellInfo), i_check(searchObj, searchObj, spellInfo, check, NULL)
{}
bool operator()(Player* u);
bool operator()(Corpse* u);
bool operator()(Creature* u);
template<class NOT_INTERESTED> bool operator()(NOT_INTERESTED*) { return false; }
protected:
SpellInfo const* i_spellInfo;
WorldObjectSpellTargetCheck i_check;
};
// WorldObject do classes
class RespawnDo
{
public:
RespawnDo() {}
void operator()(Creature* u) const { u->Respawn(); }
void operator()(GameObject* u) const { u->Respawn(); }
void operator()(WorldObject*) const {}
void operator()(Corpse*) const {}
};
// GameObject checks
class GameObjectFocusCheck
{
public:
GameObjectFocusCheck(Unit const* unit, uint32 focusId) : i_unit(unit), i_focusId(focusId) {}
bool operator()(GameObject* go) const
{
if (go->GetGOInfo()->type != GAMEOBJECT_TYPE_SPELL_FOCUS)
return false;
if (go->GetGOInfo()->spellFocus.focusId != i_focusId)
return false;
float dist = (float)((go->GetGOInfo()->spellFocus.dist)/2);
return go->IsWithinDistInMap(i_unit, dist);
}
private:
Unit const* i_unit;
uint32 i_focusId;
};
// Find the nearest Fishing hole and return true only if source object is in range of hole
class NearestGameObjectFishingHole
{
public:
NearestGameObjectFishingHole(WorldObject const& obj, float range) : i_obj(obj), i_range(range) {}
bool operator()(GameObject* go)
{
if (go->GetGOInfo()->type == GAMEOBJECT_TYPE_FISHINGHOLE && go->isSpawned() && i_obj.IsWithinDistInMap(go, i_range) && i_obj.IsWithinDistInMap(go, (float)go->GetGOInfo()->fishinghole.radius))
{
i_range = i_obj.GetDistance(go);
return true;
}
return false;
}
float GetLastRange() const { return i_range; }
private:
WorldObject const& i_obj;
float i_range;
// prevent clone
NearestGameObjectFishingHole(NearestGameObjectFishingHole const&);
};
class NearestGameObjectCheck
{
public:
NearestGameObjectCheck(WorldObject const& obj) : i_obj(obj), i_range(999) {}
bool operator()(GameObject* go)
{
if (i_obj.IsWithinDistInMap(go, i_range))
{
i_range = i_obj.GetDistance(go); // use found GO range as new range limit for next check
return true;
}
return false;
}
float GetLastRange() const { return i_range; }
private:
WorldObject const& i_obj;
float i_range;
// prevent clone this object
NearestGameObjectCheck(NearestGameObjectCheck const&);
};
// Success at unit in range, range update for next check (this can be use with GameobjectLastSearcher to find nearest GO)
class NearestGameObjectEntryInObjectRangeCheck
{
public:
NearestGameObjectEntryInObjectRangeCheck(WorldObject const& obj, uint32 entry, float range) : i_obj(obj), i_entry(entry), i_range(range) {}
bool operator()(GameObject* go)
{
if (go->GetEntry() == i_entry && i_obj.IsWithinDistInMap(go, i_range))
{
i_range = i_obj.GetDistance(go); // use found GO range as new range limit for next check
return true;
}
return false;
}
float GetLastRange() const { return i_range; }
private:
WorldObject const& i_obj;
uint32 i_entry;
float i_range;
// prevent clone this object
NearestGameObjectEntryInObjectRangeCheck(NearestGameObjectEntryInObjectRangeCheck const&);
};
// Success at unit in range, range update for next check (this can be use with GameobjectLastSearcher to find nearest GO with a certain type)
class NearestGameObjectTypeInObjectRangeCheck
{
public:
NearestGameObjectTypeInObjectRangeCheck(WorldObject const& obj, GameobjectTypes type, float range) : i_obj(obj), i_type(type), i_range(range) {}
bool operator()(GameObject* go)
{
if (go->GetGoType() == i_type && i_obj.IsWithinDistInMap(go, i_range))
{
i_range = i_obj.GetDistance(go); // use found GO range as new range limit for next check
return true;
}
return false;
}
float GetLastRange() const { return i_range; }
private:
WorldObject const& i_obj;
GameobjectTypes i_type;
float i_range;
// prevent clone this object
NearestGameObjectTypeInObjectRangeCheck(NearestGameObjectTypeInObjectRangeCheck const&);
};
class GameObjectWithDbGUIDCheck
{
public:
GameObjectWithDbGUIDCheck(WorldObject const& obj, uint32 db_guid) : i_obj(obj), i_db_guid(db_guid) {}
bool operator()(GameObject const* go) const
{
return go->GetDBTableGUIDLow() == i_db_guid;
}
private:
WorldObject const& i_obj;
uint32 i_db_guid;
};
// Unit checks
class MostHPMissingInRange
{
public:
MostHPMissingInRange(Unit const* obj, float range, uint32 hp) : i_obj(obj), i_range(range), i_hp(hp) {}
bool operator()(Unit* u)
{
if (u->isAlive() && u->isInCombat() && !i_obj->IsHostileTo(u) && i_obj->IsWithinDistInMap(u, i_range) && u->GetMaxHealth() - u->GetHealth() > i_hp)
{
i_hp = u->GetMaxHealth() - u->GetHealth();
return true;
}
return false;
}
private:
Unit const* i_obj;
float i_range;
uint32 i_hp;
};
class FriendlyCCedInRange
{
public:
FriendlyCCedInRange(Unit const* obj, float range) : i_obj(obj), i_range(range) {}
bool operator()(Unit* u)
{
if (u->isAlive() && u->isInCombat() && !i_obj->IsHostileTo(u) && i_obj->IsWithinDistInMap(u, i_range) &&
(u->isFeared() || u->isCharmed() || u->isFrozen() || u->HasUnitState(UNIT_STATE_STUNNED) || u->HasUnitState(UNIT_STATE_CONFUSED)))
{
return true;
}
return false;
}
private:
Unit const* i_obj;
float i_range;
};
class FriendlyMissingBuffInRange
{
public:
FriendlyMissingBuffInRange(Unit const* obj, float range, uint32 spellid) : i_obj(obj), i_range(range), i_spell(spellid) {}
bool operator()(Unit* u)
{
if (u->isAlive() && u->isInCombat() && !i_obj->IsHostileTo(u) && i_obj->IsWithinDistInMap(u, i_range) &&
!(u->HasAura(i_spell)))
{
return true;
}
return false;
}
private:
Unit const* i_obj;
float i_range;
uint32 i_spell;
};
class AnyUnfriendlyUnitInObjectRangeCheck
{
public:
AnyUnfriendlyUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range) : i_obj(obj), i_funit(funit), i_range(range) {}
bool operator()(Unit* u)
{
if (u->isAlive() && i_obj->IsWithinDistInMap(u, i_range) && !i_funit->IsFriendlyTo(u))
return true;
else
return false;
}
private:
WorldObject const* i_obj;
Unit const* i_funit;
float i_range;
};
class AnyUnfriendlyNoTotemUnitInObjectRangeCheck
{
public:
AnyUnfriendlyNoTotemUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range) : i_obj(obj), i_funit(funit), i_range(range) {}
bool operator()(Unit* u)
{
if (!u->isAlive())
return false;
if (u->GetCreatureType() == CREATURE_TYPE_NON_COMBAT_PET)
return false;
if (u->GetTypeId() == TYPEID_UNIT && ((Creature*)u)->isTotem())
return false;
if (!u->isTargetableForAttack(false))
return false;
return i_obj->IsWithinDistInMap(u, i_range) && i_funit->IsValidAttackTarget(u);
}
private:
WorldObject const* i_obj;
Unit const* i_funit;
float i_range;
};
class AnyUnfriendlyAttackableVisibleUnitInObjectRangeCheck
{
public:
AnyUnfriendlyAttackableVisibleUnitInObjectRangeCheck(Unit const* funit, float range)
: i_funit(funit), i_range(range) {}
bool operator()(const Unit* u)
{
return u->isAlive()
&& i_funit->IsWithinDistInMap(u, i_range)
&& !i_funit->IsFriendlyTo(u)
&& i_funit->IsValidAttackTarget(u)
&& u->GetCreatureType() != CREATURE_TYPE_CRITTER
&& i_funit->canSeeOrDetect(u);
}
private:
Unit const* i_funit;
float i_range;
};
class CreatureWithDbGUIDCheck
{
public:
CreatureWithDbGUIDCheck(WorldObject const* obj, uint32 lowguid) : i_obj(obj), i_lowguid(lowguid) {}
bool operator()(Creature* u)
{
return u->GetDBTableGUIDLow() == i_lowguid;
}
private:
WorldObject const* i_obj;
uint32 i_lowguid;
};
class AnyFriendlyUnitInObjectRangeCheck
{
public:
AnyFriendlyUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range) : i_obj(obj), i_funit(funit), i_range(range) {}
bool operator()(Unit* u)
{
if (u->isAlive() && i_obj->IsWithinDistInMap(u, i_range) && i_funit->IsFriendlyTo(u))
return true;
else
return false;
}
private:
WorldObject const* i_obj;
Unit const* i_funit;
float i_range;
};
class AnyUnitHavingBuffInObjectRangeCheck
{
public:
AnyUnitHavingBuffInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range, uint32 spellid, bool isfriendly)
: i_obj(obj), i_funit(funit), i_range(range), i_spellid(spellid), i_friendly(isfriendly) {}
bool operator()(Unit* u)
{
if (u->isAlive() && i_obj->IsWithinDistInMap(u, i_range) && i_funit->IsFriendlyTo(u) == i_friendly && u->HasAura(i_spellid, i_obj->GetGUID()))
return true;
else
return false;
}
private:
WorldObject const* i_obj;
Unit const* i_funit;
float i_range;
bool i_friendly;
uint32 i_spellid;
};
class AnyGroupedUnitInObjectRangeCheck
{
public:
AnyGroupedUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range, bool raid) : _source(obj), _refUnit(funit), _range(range), _raid(raid) {}
bool operator()(Unit* u)
{
if (G3D::fuzzyEq(_range, 0))
return false;
if (_raid)
{
if (!_refUnit->IsInRaidWith(u))
return false;
}
else if (!_refUnit->IsInPartyWith(u))
return false;
return !_refUnit->IsHostileTo(u) && u->isAlive() && _source->IsWithinDistInMap(u, _range);
}
private:
WorldObject const* _source;
Unit const* _refUnit;
float _range;
bool _raid;
};
class AnyUnitInObjectRangeCheck
{
public:
AnyUnitInObjectRangeCheck(WorldObject const* obj, float range) : i_obj(obj), i_range(range) {}
bool operator()(Unit* u)
{
if (u->isAlive() && i_obj->IsWithinDistInMap(u, i_range))
return true;
return false;
}
private:
WorldObject const* i_obj;
float i_range;
};
// Success at unit in range, range update for next check (this can be use with UnitLastSearcher to find nearest unit)
class NearestAttackableUnitInObjectRangeCheck
{
public:
NearestAttackableUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range) : i_obj(obj), i_funit(funit), i_range(range) {}
bool operator()(Unit* u)
{
if (u->isTargetableForAttack() && i_obj->IsWithinDistInMap(u, i_range) &&
!i_funit->IsFriendlyTo(u))
{
i_range = i_obj->GetDistance(u); // use found unit range as new range limit for next check
return true;
}
return false;
}
private:
WorldObject const* i_obj;
Unit const* i_funit;
float i_range;
// prevent clone this object
NearestAttackableUnitInObjectRangeCheck(NearestAttackableUnitInObjectRangeCheck const&);
};
// Success at unit in range, range update for next check (this can be use with UnitLastSearcher to find nearest unit)
class NearestAttackableNoCCUnitInObjectRangeCheck
{
public:
NearestAttackableNoCCUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range) : i_obj(obj), i_funit(funit), i_range(range) {}
bool operator()(Unit* u)
{
if (u->isTargetableForAttack() && i_obj->IsWithinDistInMap(u, i_range) &&
!i_funit->IsFriendlyTo(u) && !u->HasCrowdControlAura() && !u->HasAuraType(SPELL_AURA_MOD_CONFUSE))
{
i_range = i_obj->GetDistance(u); // use found unit range as new range limit for next check
return true;
}
return false;
}
private:
WorldObject const* i_obj;
Unit const* i_funit;
float i_range;
// prevent clone this object
NearestAttackableNoCCUnitInObjectRangeCheck(NearestAttackableNoCCUnitInObjectRangeCheck const&);
};
class AnyAoETargetUnitInObjectRangeCheck
{
public:
AnyAoETargetUnitInObjectRangeCheck(WorldObject const* obj, Unit const* funit, float range)
: i_obj(obj), i_funit(funit), _spellInfo(NULL), i_range(range)
{
Unit const* check = i_funit;
Unit const* owner = i_funit->GetOwner();
if (owner)
check = owner;
i_targetForPlayer = (check->GetTypeId() == TYPEID_PLAYER);
if (i_obj->GetTypeId() == TYPEID_DYNAMICOBJECT)
_spellInfo = sSpellMgr->GetSpellInfo(((DynamicObject*)i_obj)->GetSpellId());
}
bool operator()(Unit* u)
{
// Check contains checks for: live, non-selectable, non-attackable flags, flight check and GM check, ignore totems
if (u->GetTypeId() == TYPEID_UNIT && ((Creature*)u)->isTotem())
return false;
if (i_funit->_IsValidAttackTarget(u, _spellInfo,i_obj->GetTypeId() == TYPEID_DYNAMICOBJECT ? i_obj : NULL) && i_obj->IsWithinDistInMap(u, i_range))
return true;
return false;
}
private:
bool i_targetForPlayer;
WorldObject const* i_obj;
Unit const* i_funit;
SpellInfo const* _spellInfo;
float i_range;
};
// do attack at call of help to friendly crearture
class CallOfHelpCreatureInRangeDo
{
public:
CallOfHelpCreatureInRangeDo(Unit* funit, Unit* enemy, float range)
: i_funit(funit), i_enemy(enemy), i_range(range)
{}
void operator()(Creature* u)
{
if (u == i_funit)
return;
if (!u->CanAssistTo(i_funit, i_enemy, false))
return;
// too far
if (!u->IsWithinDistInMap(i_funit, i_range))
return;
// only if see assisted creature's enemy
if (!u->IsWithinLOSInMap(i_enemy))
return;
if (u->AI())
u->AI()->AttackStart(i_enemy);
}
private:
Unit* const i_funit;
Unit* const i_enemy;
float i_range;
};
struct AnyDeadUnitCheck
{
bool operator()(Unit* u) { return !u->isAlive(); }
};
class AnyCreatureInObjectRangeCheck
{
public:
AnyCreatureInObjectRangeCheck(WorldObject const* obj, float range) : i_obj(obj), i_range(range) {}
bool operator()(Unit* c)
{
if (c->isAlive() && i_obj->IsWithinDistInMap(c, i_range) && c->GetTypeId() != TYPEID_PLAYER)
return true;
return false;
}
private:
WorldObject const* i_obj;
float i_range;
};
/*
struct AnyStealthedCheck
{
bool operator()(Unit* u) { return u->GetVisibility() == VISIBILITY_GROUP_STEALTH; }
};
*/
// Creature checks
class NearestHostileUnitCheck
{
public:
explicit NearestHostileUnitCheck(Creature const* creature, float dist = 0) : me(creature)
{
m_range = (dist == 0 ? 9999 : dist);
}
bool operator()(Unit* u)
{
if (!me->IsWithinDistInMap(u, m_range))
return false;
if (!me->IsValidAttackTarget(u))
return false;
m_range = me->GetDistance(u); // use found unit range as new range limit for next check
return true;
}
private:
Creature const* me;
float m_range;
NearestHostileUnitCheck(NearestHostileUnitCheck const&);
};
class NearestHostileNoCCUnitCheck
{
public:
explicit NearestHostileNoCCUnitCheck(Creature const* creature, float dist = 0) : me(creature)
{
m_range = (dist == 0 ? 9999 : dist);
}
bool operator()(Unit* u)
{
if (!me->IsWithinDistInMap(u, m_range))
return false;
if (!me->IsValidAttackTarget(u))
return false;
if (u->HasCrowdControlAura())
return false;
if (u->HasAuraType(SPELL_AURA_MOD_CONFUSE))
return false;
m_range = me->GetDistance(u); // use found unit range as new range limit for next check
return true;
}
private:
Creature const *me;
float m_range;
NearestHostileNoCCUnitCheck(NearestHostileNoCCUnitCheck const&);
};
class NearestHostileUnitInAttackDistanceCheck
{
public:
explicit NearestHostileUnitInAttackDistanceCheck(Creature const* creature, float dist = 0) : me(creature)
{
m_range = (dist == 0 ? 9999 : dist);
m_force = (dist == 0 ? false : true);
}
bool operator()(Unit* u)
{
if (!me->IsWithinDistInMap(u, m_range))
return false;
if (!me->canSeeOrDetect(u))
return false;
if (m_force)
{
if (!me->IsValidAttackTarget(u))
return false;
}
else if (!me->canStartAttack(u, false))
return false;
m_range = me->GetDistance(u); // use found unit range as new range limit for next check
return true;
}
float GetLastRange() const { return m_range; }
private:
Creature const* me;
float m_range;
bool m_force;
NearestHostileUnitInAttackDistanceCheck(NearestHostileUnitInAttackDistanceCheck const&);
};
class NearestHostileUnitInAggroRangeCheck
{
public:
explicit NearestHostileUnitInAggroRangeCheck(Creature const* creature, bool useLOS = false) : _me(creature), _useLOS(useLOS)
{
}
bool operator()(Unit* u)
{
if (!u->IsHostileTo(_me))
return false;
if (!u->IsWithinDistInMap(_me, _me->GetAggroRange(u)))
return false;
if (!_me->IsValidAttackTarget(u))
return false;
if (_useLOS && !u->IsWithinLOSInMap(_me))
return false;
return true;
}
private:
Creature const* _me;
bool _useLOS;
NearestHostileUnitInAggroRangeCheck(NearestHostileUnitInAggroRangeCheck const&);
};
class AnyAssistCreatureInRangeCheck
{
public:
AnyAssistCreatureInRangeCheck(Unit* funit, Unit* enemy, float range)
: i_funit(funit), i_enemy(enemy), i_range(range)
{
}
bool operator()(Creature* u)
{
if (u == i_funit)
return false;
if (!u->CanAssistTo(i_funit, i_enemy))
return false;
// too far
if (!i_funit->IsWithinDistInMap(u, i_range))
return false;
// only if see assisted creature
if (!i_funit->IsWithinLOSInMap(u))
return false;
return true;
}
private:
Unit* const i_funit;
Unit* const i_enemy;
float i_range;
};
class NearestAssistCreatureInCreatureRangeCheck
{
public:
NearestAssistCreatureInCreatureRangeCheck(Creature* obj, Unit* enemy, float range)
: i_obj(obj), i_enemy(enemy), i_range(range) {}
bool operator()(Creature* u)
{
if (u == i_obj)
return false;
if (!u->CanAssistTo(i_obj, i_enemy))
return false;
if (!i_obj->IsWithinDistInMap(u, i_range))
return false;
if (!i_obj->IsWithinLOSInMap(u))
return false;
i_range = i_obj->GetDistance(u); // use found unit range as new range limit for next check
return true;
}
float GetLastRange() const { return i_range; }
private:
Creature* const i_obj;
Unit* const i_enemy;
float i_range;
// prevent clone this object
NearestAssistCreatureInCreatureRangeCheck(NearestAssistCreatureInCreatureRangeCheck const&);
};
// Success at unit in range, range update for next check (this can be use with CreatureLastSearcher to find nearest creature)
class NearestCreatureEntryWithLiveStateInObjectRangeCheck
{
public:
NearestCreatureEntryWithLiveStateInObjectRangeCheck(WorldObject const& obj, uint32 entry, bool alive, float range)
: i_obj(obj), i_entry(entry), i_alive(alive), i_range(range) {}
bool operator()(Creature* u)
{
if (u->GetEntry() == i_entry && u->isAlive() == i_alive && i_obj.IsWithinDistInMap(u, i_range))
{
i_range = i_obj.GetDistance(u); // use found unit range as new range limit for next check
return true;
}
return false;
}
float GetLastRange() const { return i_range; }
private:
WorldObject const& i_obj;
uint32 i_entry;
bool i_alive;
float i_range;
// prevent clone this object
NearestCreatureEntryWithLiveStateInObjectRangeCheck(NearestCreatureEntryWithLiveStateInObjectRangeCheck const&);
};
class AnyPlayerInObjectRangeCheck
{
public:
AnyPlayerInObjectRangeCheck(WorldObject const* obj, float range, bool reqAlive = true) : _obj(obj), _range(range), _reqAlive(reqAlive) {}
bool operator()(Player* u)
{
if (_reqAlive && !u->isAlive())
return false;
if (!_obj->IsWithinDistInMap(u, _range))
return false;
return true;
}
private:
WorldObject const* _obj;
float _range;
bool _reqAlive;
};
class NearestPlayerInObjectRangeCheck
{
public:
NearestPlayerInObjectRangeCheck(WorldObject const* obj, float range) : i_obj(obj), i_range(range)
{
}
bool operator()(Player* u)
{
if (u->isAlive() && i_obj->IsWithinDistInMap(u, i_range))
{
i_range = i_obj->GetDistance(u);
return true;
}
return false;
}
private:
WorldObject const* i_obj;
float i_range;
NearestPlayerInObjectRangeCheck(NearestPlayerInObjectRangeCheck const&);
};
class NearestPlayerNotGMInObjectRangeCheck
{
public:
NearestPlayerNotGMInObjectRangeCheck(WorldObject const* obj, float range) : i_obj(obj), i_range(range)
{
}
bool operator()(Player* u)
{
if (!u->isGameMaster() && u->isAlive() && i_obj->IsWithinDistInMap(u, i_range))
{
i_range = i_obj->GetDistance(u);
return true;
}
return false;
}
private:
WorldObject const* i_obj;
float i_range;
NearestPlayerNotGMInObjectRangeCheck(NearestPlayerNotGMInObjectRangeCheck const&);
};
class AllFriendlyCreaturesInGrid
{
public:
AllFriendlyCreaturesInGrid(Unit const* obj) : unit(obj) {}
bool operator() (Unit* u)
{
if (u->isAlive() && u->IsVisible() && u->IsFriendlyTo(unit))
return true;
return false;
}
private:
Unit const* unit;
};
class AllGameObjectsWithEntryInRange
{
public:
AllGameObjectsWithEntryInRange(const WorldObject* object, uint32 entry, float maxRange) : m_pObject(object), m_uiEntry(entry), m_fRange(maxRange) {}
bool operator() (GameObject* go)
{
if (go->GetEntry() == m_uiEntry && m_pObject->IsWithinDist(go, m_fRange, false))
return true;
return false;
}
private:
const WorldObject* m_pObject;
uint32 m_uiEntry;
float m_fRange;
};
class AllCreaturesOfEntryInRange
{
public:
AllCreaturesOfEntryInRange(const WorldObject* object, uint32 entry, float maxRange) : m_pObject(object), m_uiEntry(entry), m_fRange(maxRange) {}
bool operator() (Unit* unit)
{
if (unit->GetEntry() == m_uiEntry && m_pObject->IsWithinDist(unit, m_fRange, false))
return true;
return false;
}
private:
const WorldObject* m_pObject;
uint32 m_uiEntry;
float m_fRange;
};
class AllDeadCreaturesInRange
{
public:
AllDeadCreaturesInRange(const WorldObject* object, float maxRange, uint64 excludeGUID) : m_pObject(object), m_fRange(maxRange), m_excludeGUID(excludeGUID) {}
bool operator() (Unit* unit)
{
if (unit->GetTypeId() == TYPEID_UNIT && unit->GetGUID() != m_excludeGUID && !unit->isAlive() && m_pObject->IsWithinDist(unit, m_fRange, false))
return true;
return false;
}
private:
const WorldObject* m_pObject;
uint64 m_excludeGUID;
float m_fRange;
};
class PlayerAtMinimumRangeAway
{
public:
PlayerAtMinimumRangeAway(Unit const* unit, float fMinRange) : unit(unit), fRange(fMinRange) {}
bool operator() (Player* player)
{
//No threat list check, must be done explicit if expected to be in combat with creature
if (!player->isGameMaster() && player->isAlive() && !unit->IsWithinDist(player, fRange, false))
return true;
return false;
}
private:
Unit const* unit;
float fRange;
};
class GameObjectInRangeCheck
{
public:
GameObjectInRangeCheck(float _x, float _y, float _z, float _range, uint32 _entry = 0) :
x(_x), y(_y), z(_z), range(_range), entry(_entry) {}
bool operator() (GameObject* go)
{
if (!entry || (go->GetGOInfo() && go->GetGOInfo()->entry == entry))
return go->IsInRange(x, y, z, range);
else return false;
}
private:
float x, y, z, range;
uint32 entry;
};
class AllAreaTriggersInRangeCheck
{
public:
AllAreaTriggersInRangeCheck(const WorldObject* object, float maxRange) : m_pObject(object), m_fRange(maxRange) {}
bool operator() (AreaTrigger* p_AreaTrigger)
{
return m_pObject->IsWithinDist(p_AreaTrigger, m_fRange, false) && m_pObject->InSamePhase(p_AreaTrigger);
}
private:
const WorldObject* m_pObject;
float m_fRange;
};
class AllWorldObjectsInRange
{
public:
AllWorldObjectsInRange(const WorldObject* object, float maxRange) : m_pObject(object), m_fRange(maxRange) {}
bool operator() (WorldObject* go)
{
return m_pObject->IsWithinDist(go, m_fRange, false) && m_pObject->InSamePhase(go);
}
private:
const WorldObject* m_pObject;
float m_fRange;
};
class ObjectTypeIdCheck
{
public:
ObjectTypeIdCheck(TypeID typeId, bool equals) : _typeId(typeId), _equals(equals) {}
bool operator()(WorldObject* object)
{
return (object->GetTypeId() == _typeId) == _equals;
}
private:
TypeID _typeId;
bool _equals;
};
class ObjectGUIDCheck
{
public:
ObjectGUIDCheck(uint64 GUID) : _GUID(GUID) {}
bool operator()(WorldObject* object)
{
return object->GetGUID() == _GUID;
}
private:
uint64 _GUID;
};
class UnitAuraCheck
{
public:
UnitAuraCheck(bool present, uint32 spellId, uint64 casterGUID = 0) : _present(present), _spellId(spellId), _casterGUID(casterGUID) {}
bool operator()(Unit* unit) const
{
return unit->HasAura(_spellId, _casterGUID) == _present;
}
bool operator()(WorldObject* object) const
{
return object->ToUnit() && object->ToUnit()->HasAura(_spellId, _casterGUID) == _present;
}
private:
bool _present;
uint32 _spellId;
uint64 _casterGUID;
};
class UnitAuraTypeCheck
{
public:
UnitAuraTypeCheck(bool present, AuraType type) : _present(present), _type(type) {}
bool operator()(Unit* unit) const
{
return unit->HasAuraType(_type) == _present;
}
bool operator()(WorldObject* object) const
{
return object->ToUnit() && object->ToUnit()->HasAuraType(_type) == _present;
}
private:
bool _present;
AuraType _type;
};
// Player checks and do
// Prepare using Builder localized packets with caching and send to player
template<class Builder>
class LocalizedPacketDo
{
public:
explicit LocalizedPacketDo(Builder& builder) : i_builder(builder) {}
~LocalizedPacketDo()
{
for (size_t i = 0; i < i_data_cache.size(); ++i)
delete i_data_cache[i];
}
void operator()(Player* p);
private:
Builder& i_builder;
std::vector<WorldPacket*> i_data_cache; // 0 = default, i => i-1 locale index
};
// Prepare using Builder localized packets with caching and send to player
template<class Builder>
class LocalizedPacketListDo
{
public:
typedef std::vector<WorldPacket*> WorldPacketList;
explicit LocalizedPacketListDo(Builder& builder) : i_builder(builder) {}
~LocalizedPacketListDo()
{
for (size_t i = 0; i < i_data_cache.size(); ++i)
for (size_t j = 0; j < i_data_cache[i].size(); ++j)
delete i_data_cache[i][j];
}
void operator()(Player* p);
private:
Builder& i_builder;
std::vector<WorldPacketList> i_data_cache;
// 0 = default, i => i-1 locale index
};
class SummonTimerOrderPred
{
public:
SummonTimerOrderPred(bool ascending = true) : m_ascending(ascending) {}
bool operator() (const Unit* a, const Unit* b) const
{
if (!a->isSummon() || !b->isSummon())
return (urand(0, 1) ? false : true);
uint32 rA = ((TempSummon*)a)->GetTimer();
uint32 rB = ((TempSummon*)b)->GetTimer();
return m_ascending ? rA < rB : rA > rB;
}
private:
const bool m_ascending;
};
}
#endif
| [
"[email protected]"
] | |
3359fc6786de2a3a1a4a19d603424ec8fa042bf3 | a2cd609a52eb5be16a248c054fb014394f12d344 | /build/jsk_visualization/jsk_rviz_plugins/src/moc_overlay_menu_display.cpp | bf4dedea55dc61aead7c4223d8933f599237ff54 | [] | no_license | rfzeg/simon_thesis_ws | c5e6d6b20ee63010ffede91d17ba144527e5f6c5 | dc79635f628dade14cab1a631cc4eb24aee1762c | refs/heads/master | 2021-09-16T12:43:41.270235 | 2018-06-20T12:40:57 | 2018-06-20T12:40:57 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,831 | cpp | /****************************************************************************
** Meta object code from reading C++ file 'overlay_menu_display.h'
**
** Created by: The Qt Meta Object Compiler version 67 (Qt 5.5.1)
**
** WARNING! All changes made in this file will be lost!
*****************************************************************************/
#include "../../../../src/jsk_visualization/jsk_rviz_plugins/src/overlay_menu_display.h"
#include <QtCore/qbytearray.h>
#include <QtCore/qmetatype.h>
#if !defined(Q_MOC_OUTPUT_REVISION)
#error "The header file 'overlay_menu_display.h' doesn't include <QObject>."
#elif Q_MOC_OUTPUT_REVISION != 67
#error "This file was generated using the moc from 5.5.1. It"
#error "cannot be used with the include files from this version of Qt."
#error "(The moc has changed too much.)"
#endif
QT_BEGIN_MOC_NAMESPACE
struct qt_meta_stringdata_jsk_rviz_plugins__OverlayMenuDisplay_t {
QByteArrayData data[3];
char stringdata0[50];
};
#define QT_MOC_LITERAL(idx, ofs, len) \
Q_STATIC_BYTE_ARRAY_DATA_HEADER_INITIALIZER_WITH_OFFSET(len, \
qptrdiff(offsetof(qt_meta_stringdata_jsk_rviz_plugins__OverlayMenuDisplay_t, stringdata0) + ofs \
- idx * sizeof(QByteArrayData)) \
)
static const qt_meta_stringdata_jsk_rviz_plugins__OverlayMenuDisplay_t qt_meta_stringdata_jsk_rviz_plugins__OverlayMenuDisplay = {
{
QT_MOC_LITERAL(0, 0, 36), // "jsk_rviz_plugins::OverlayMenu..."
QT_MOC_LITERAL(1, 37, 11), // "updateTopic"
QT_MOC_LITERAL(2, 49, 0) // ""
},
"jsk_rviz_plugins::OverlayMenuDisplay\0"
"updateTopic\0"
};
#undef QT_MOC_LITERAL
static const uint qt_meta_data_jsk_rviz_plugins__OverlayMenuDisplay[] = {
// content:
7, // revision
0, // classname
0, 0, // classinfo
1, 14, // methods
0, 0, // properties
0, 0, // enums/sets
0, 0, // constructors
0, // flags
0, // signalCount
// slots: name, argc, parameters, tag, flags
1, 0, 19, 2, 0x09 /* Protected */,
// slots: parameters
QMetaType::Void,
0 // eod
};
void jsk_rviz_plugins::OverlayMenuDisplay::qt_static_metacall(QObject *_o, QMetaObject::Call _c, int _id, void **_a)
{
if (_c == QMetaObject::InvokeMetaMethod) {
OverlayMenuDisplay *_t = static_cast<OverlayMenuDisplay *>(_o);
Q_UNUSED(_t)
switch (_id) {
case 0: _t->updateTopic(); break;
default: ;
}
}
Q_UNUSED(_a);
}
const QMetaObject jsk_rviz_plugins::OverlayMenuDisplay::staticMetaObject = {
{ &rviz::Display::staticMetaObject, qt_meta_stringdata_jsk_rviz_plugins__OverlayMenuDisplay.data,
qt_meta_data_jsk_rviz_plugins__OverlayMenuDisplay, qt_static_metacall, Q_NULLPTR, Q_NULLPTR}
};
const QMetaObject *jsk_rviz_plugins::OverlayMenuDisplay::metaObject() const
{
return QObject::d_ptr->metaObject ? QObject::d_ptr->dynamicMetaObject() : &staticMetaObject;
}
void *jsk_rviz_plugins::OverlayMenuDisplay::qt_metacast(const char *_clname)
{
if (!_clname) return Q_NULLPTR;
if (!strcmp(_clname, qt_meta_stringdata_jsk_rviz_plugins__OverlayMenuDisplay.stringdata0))
return static_cast<void*>(const_cast< OverlayMenuDisplay*>(this));
return rviz::Display::qt_metacast(_clname);
}
int jsk_rviz_plugins::OverlayMenuDisplay::qt_metacall(QMetaObject::Call _c, int _id, void **_a)
{
_id = rviz::Display::qt_metacall(_c, _id, _a);
if (_id < 0)
return _id;
if (_c == QMetaObject::InvokeMetaMethod) {
if (_id < 1)
qt_static_metacall(this, _c, _id, _a);
_id -= 1;
} else if (_c == QMetaObject::RegisterMethodArgumentMetaType) {
if (_id < 1)
*reinterpret_cast<int*>(_a[0]) = -1;
_id -= 1;
}
return _id;
}
QT_END_MOC_NAMESPACE
| [
"[email protected]"
] | |
875471063da2957bd1459123a1e02ce88f6e8bd4 | 6a408c6754e8cad8376ff030570129963a0f7b2c | /lesson23/l23-6/l23-6/main.cpp | 4e710beb29bfb678ace77998eea6dc5368c20312 | [] | no_license | dimmkan/MSHP | e4ed8cb6528747f10900c6fe5bcf650238d3f9f6 | 956629ee2b83df28caacc2554bf7a00e1aad848c | refs/heads/master | 2020-09-07T00:56:01.756864 | 2020-05-30T08:54:08 | 2020-05-30T08:54:08 | 220,607,366 | 1 | 0 | null | 2020-01-31T15:52:26 | 2019-11-09T07:29:26 | C++ | UTF-8 | C++ | false | false | 683 | cpp | #include <iostream>
using namespace std;
int* read_array(int *n){
cin >> *n;
int *x = new int[*n];
for(int i = 0; i < *n; i++){
cin >> x[i];
}
return x;
}
void print_array(int *a, int *b, int n){
for(int i = 0; i < n; i++){
cout << a[i] << " " << b[i] << endl;
}
}
int* rearrange(int *a, int n){
int *arr = new int[n];
for(int i = 0; i < n; i += 2){
arr[i] = a[i+1];
arr[i+1] = a[i];
}
return arr;
}
int main()
{
int n;
int *arr = read_array(&n);
int *arr2 = rearrange(arr, n);
print_array(arr, arr2, n);
delete[] arr;
delete[] arr2;
return 0;
}
| [
"[email protected]"
] | |
c927bb9ee2102e4853c6c6f48c60a9c418d9698f | a904c42a45b99c6de6c95cf52ba88001740765e4 | /Sources/Lights/Light.hpp | 0788c0fa46ed772d001f31f5d60fc3042f247b9e | [
"MIT"
] | permissive | lineCode/Acid | 0cc31acf1060f0d55631b3cbe31e540e89a44a31 | 573ca8ea9191f62eaab8ef89c34bf15e70e0c1e4 | refs/heads/master | 2020-03-28T14:29:58.922933 | 2018-09-12T06:35:25 | 2018-09-12T06:35:25 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,581 | hpp | #pragma once
#include "Maths/Colour.hpp"
#include "Maths/Vector3.hpp"
#include "Objects/IComponent.hpp"
namespace acid
{
/// <summary>
/// Represents a point light, contains a colour, position and attenuation.
/// </summary>
class ACID_EXPORT Light :
public IComponent
{
private:
Colour m_colour;
Vector3 m_position;
float m_radius;
Vector3 m_localOffset;
public:
/// <summary>
/// Creates a new point light.
/// </summary>
/// <param name="colour"> The colour of the light. </param>
/// <param name="radius"> How far the light will have influence (-1 sets this to a directional light). </param>
/// <param name="localOffset"> The parent offset of the light. </param>
Light(const Colour &colour = Colour::WHITE, const float &radius = -1.0f, const Vector3 &localOffset = Vector3::ZERO);
/// <summary>
/// Creates a new point light from a source object.
/// </summary>
/// <param name="source"> The source light object. </param>
Light(const Light &source);
void Start() override;
void Update() override;
void Decode(const Metadata &metadata) override;
void Encode(Metadata &metadata) const override;
Colour GetColour() const { return m_colour; }
void SetColour(const Colour &colour) { m_colour = colour; }
float GetRadius() const { return m_radius; }
void SetRadius(const float &radius) { m_radius = radius; }
Vector3 GetLocalOffset() const { return m_localOffset; }
void SetLocalOffset(const Vector3 &localOffset) { m_localOffset = localOffset; }
Vector3 GetPosition() const { return m_position; }
};
}
| [
"[email protected]"
] | |
395bc3687466682a6542e2077e4c19f33ec8e5e9 | ee13201112727c0e4a390cb8383df1f043e6843a | /contrib/epee/include/net/abstract_tcp_server2.inl | f29bf3d6f70fd616d81bfa2c48d07dee4053ce31 | [
"BSD-3-Clause",
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | Sparksfire/LibertyChain | 5fc345a873f7c622c526fbd2c916c744783ad1b9 | 60b407977040de3a01710691e3e66efdc6b64a8d | refs/heads/master | 2023-05-30T17:30:43.465716 | 2021-07-02T05:48:59 | 2021-07-02T05:48:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 68,625 | inl | /**
@file
@author from CrypoNote (see copyright below; Andrey N. Sabelnikov)
@LibertyChain rfree
@brief the connection templated-class for one peer connection
*/
// Copyright (c) 2006-2013, Andrey N. Sabelnikov, www.sabelnikov.net
// All rights reserved.
//
// Redistribution and use in source and binary forms, with or without
// modification, are permitted provided that the following conditions are met:
// * Redistributions of source code must retain the above copyright
// notice, this list of conditions and the following disclaimer.
// * Redistributions in binary form must reproduce the above copyright
// notice, this list of conditions and the following disclaimer in the
// documentation and/or other materials provided with the distribution.
// * Neither the name of the Andrey N. Sabelnikov nor the
// names of its contributors may be used to endorse or promote products
// derived from this software without specific prior written permission.
//
// THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
// ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
// WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
// DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER BE LIABLE FOR ANY
// DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
// (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
// LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
// ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
// (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
// SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
//
#include <boost/foreach.hpp>
#include <boost/uuid/random_generator.hpp>
#include <boost/chrono.hpp>
#include <boost/utility/value_init.hpp>
#include <boost/asio/deadline_timer.hpp>
#include <boost/date_time/posix_time/posix_time.hpp> // TODO
#include <boost/thread/condition_variable.hpp> // TODO
#include <boost/make_shared.hpp>
#include <boost/thread.hpp>
#include "warnings.h"
#include "string_tools_lexical.h"
#include "misc_language.h"
#include "net/local_ip.h"
#include "pragma_comp_defs.h"
#include <sstream>
#include <iomanip>
#include <algorithm>
#include <functional>
#include <random>
#undef LibertyChain_DEFAULT_LOG_CATEGORY
#define LibertyChain_DEFAULT_LOG_CATEGORY "net"
#define AGGRESSIVE_TIMEOUT_THRESHOLD 120 // sockets
#define NEW_CONNECTION_TIMEOUT_LOCAL 1200000 // 2 minutes
#define NEW_CONNECTION_TIMEOUT_REMOTE 10000 // 10 seconds
#define DEFAULT_TIMEOUT_MS_LOCAL 1800000 // 30 minutes
#define DEFAULT_TIMEOUT_MS_REMOTE 300000 // 5 minutes
#define TIMEOUT_EXTRA_MS_PER_BYTE 0.2
PRAGMA_WARNING_PUSH
namespace epee
{
namespace net_utils
{
template<typename T>
T& check_and_get(std::shared_ptr<T>& ptr)
{
CHECK_AND_ASSERT_THROW_MES(bool(ptr), "shared_state cannot be null");
return *ptr;
}
/************************************************************************/
/* */
/************************************************************************/
PRAGMA_WARNING_DISABLE_VS(4355)
template<class t_protocol_handler>
connection<t_protocol_handler>::connection( boost::asio::io_service& io_service,
std::shared_ptr<shared_state> state,
t_connection_type connection_type,
ssl_support_t ssl_support
)
: connection(boost::asio::ip::tcp::socket{io_service}, std::move(state), connection_type, ssl_support)
{
}
template<class t_protocol_handler>
connection<t_protocol_handler>::connection( boost::asio::ip::tcp::socket&& sock,
std::shared_ptr<shared_state> state,
t_connection_type connection_type,
ssl_support_t ssl_support
)
:
connection_basic(std::move(sock), state, ssl_support),
m_protocol_handler(this, check_and_get(state), context),
buffer_ssl_init_fill(0),
m_connection_type( connection_type ),
m_throttle_speed_in("speed_in", "throttle_speed_in"),
m_throttle_speed_out("speed_out", "throttle_speed_out"),
m_timer(GET_IO_SERVICE(socket_)),
m_local(false),
m_ready_to_close(false)
{
MDEBUG("test, connection constructor set m_connection_type="<<m_connection_type);
}
PRAGMA_WARNING_DISABLE_VS(4355)
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
connection<t_protocol_handler>::~connection() noexcept(false)
{
if(!m_was_shutdown)
{
_dbg3("[sock " << socket().native_handle() << "] Socket destroyed without shutdown.");
shutdown();
}
_dbg3("[sock " << socket().native_handle() << "] Socket destroyed");
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
boost::shared_ptr<connection<t_protocol_handler> > connection<t_protocol_handler>::safe_shared_from_this()
{
try
{
return connection<t_protocol_handler>::shared_from_this();
}
catch (const boost::bad_weak_ptr&)
{
// It happens when the connection is being deleted
return boost::shared_ptr<connection<t_protocol_handler> >();
}
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool connection<t_protocol_handler>::start(bool is_income, bool is_multithreaded)
{
TRY_ENTRY();
boost::system::error_code ec;
auto remote_ep = socket().remote_endpoint(ec);
CHECK_AND_NO_ASSERT_MES(!ec, false, "Failed to get remote endpoint: " << ec.message() << ':' << ec.value());
CHECK_AND_NO_ASSERT_MES(remote_ep.address().is_v4() || remote_ep.address().is_v6(), false, "only IPv4 and IPv6 supported here");
if (remote_ep.address().is_v4())
{
const unsigned long ip_ = boost::asio::detail::socket_ops::host_to_network_long(remote_ep.address().to_v4().to_ulong());
return start(is_income, is_multithreaded, ipv4_network_address{uint32_t(ip_), remote_ep.port()});
}
else
{
const auto ip_ = remote_ep.address().to_v6();
return start(is_income, is_multithreaded, ipv6_network_address{ip_, remote_ep.port()});
}
CATCH_ENTRY_L0("connection<t_protocol_handler>::start()", false);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool connection<t_protocol_handler>::start(bool is_income, bool is_multithreaded, network_address real_remote)
{
TRY_ENTRY();
// Use safe_shared_from_this, because of this is public method and it can be called on the object being deleted
auto self = safe_shared_from_this();
if(!self)
return false;
m_is_multithreaded = is_multithreaded;
m_local = real_remote.is_loopback() || real_remote.is_local();
// create a random uuid, we don't need crypto strength here
const boost::uuids::uuid random_uuid = boost::uuids::random_generator()();
context = t_connection_context{};
bool ssl = m_ssl_support == epee::net_utils::ssl_support_t::e_ssl_support_enabled;
context.set_details(random_uuid, std::move(real_remote), is_income, ssl);
boost::system::error_code ec;
auto local_ep = socket().local_endpoint(ec);
CHECK_AND_NO_ASSERT_MES(!ec, false, "Failed to get local endpoint: " << ec.message() << ':' << ec.value());
_dbg3("[sock " << socket_.native_handle() << "] new connection from " << print_connection_context_short(context) <<
" to " << local_ep.address().to_string() << ':' << local_ep.port() <<
", total sockets objects " << get_state().sock_count);
if(static_cast<shared_state&>(get_state()).pfilter && !static_cast<shared_state&>(get_state()).pfilter->is_remote_host_allowed(context.m_remote_address))
{
_dbg2("[sock " << socket().native_handle() << "] host denied " << context.m_remote_address.host_str() << ", shutdowning connection");
close();
return false;
}
m_host = context.m_remote_address.host_str();
try { host_count(m_host, 1); } catch(...) { /* ignore */ }
m_protocol_handler.after_init_connection();
reset_timer(boost::posix_time::milliseconds(m_local ? NEW_CONNECTION_TIMEOUT_LOCAL : NEW_CONNECTION_TIMEOUT_REMOTE), false);
// first read on the raw socket to detect SSL for the server
buffer_ssl_init_fill = 0;
if (is_income && m_ssl_support != epee::net_utils::ssl_support_t::e_ssl_support_disabled)
socket().async_receive(boost::asio::buffer(buffer_),
strand_.wrap(
std::bind(&connection<t_protocol_handler>::handle_receive, self,
std::placeholders::_1,
std::placeholders::_2)));
else
async_read_some(boost::asio::buffer(buffer_),
strand_.wrap(
std::bind(&connection<t_protocol_handler>::handle_read, self,
std::placeholders::_1,
std::placeholders::_2)));
#if !defined(_WIN32) || !defined(__i686)
// not supported before Windows7, too lazy for runtime check
// Just exclude for 32bit windows builds
//set ToS flag
int tos = get_tos_flag();
boost::asio::detail::socket_option::integer< IPPROTO_IP, IP_TOS >
optionTos( tos );
socket().set_option( optionTos );
//_dbg1("Set ToS flag to " << tos);
#endif
boost::asio::ip::tcp::no_delay noDelayOption(false);
socket().set_option(noDelayOption);
return true;
CATCH_ENTRY_L0("connection<t_protocol_handler>::start()", false);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool connection<t_protocol_handler>::request_callback()
{
TRY_ENTRY();
_dbg2("[" << print_connection_context_short(context) << "] request_callback");
// Use safe_shared_from_this, because of this is public method and it can be called on the object being deleted
auto self = safe_shared_from_this();
if(!self)
return false;
strand_.post(boost::bind(&connection<t_protocol_handler>::call_back_starter, self));
CATCH_ENTRY_L0("connection<t_protocol_handler>::request_callback()", false);
return true;
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
boost::asio::io_service& connection<t_protocol_handler>::get_io_service()
{
return GET_IO_SERVICE(socket());
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool connection<t_protocol_handler>::add_ref()
{
TRY_ENTRY();
// Use safe_shared_from_this, because of this is public method and it can be called on the object being deleted
auto self = safe_shared_from_this();
if(!self)
return false;
//_dbg3("[sock " << socket().native_handle() << "] add_ref, m_peer_number=" << mI->m_peer_number);
CRITICAL_REGION_LOCAL(self->m_self_refs_lock);
//_dbg3("[sock " << socket().native_handle() << "] add_ref 2, m_peer_number=" << mI->m_peer_number);
++m_reference_count;
m_self_ref = std::move(self);
return true;
CATCH_ENTRY_L0("connection<t_protocol_handler>::add_ref()", false);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool connection<t_protocol_handler>::release()
{
TRY_ENTRY();
boost::shared_ptr<connection<t_protocol_handler> > back_connection_copy;
LOG_TRACE_CC(context, "[sock " << socket().native_handle() << "] release");
CRITICAL_REGION_BEGIN(m_self_refs_lock);
CHECK_AND_ASSERT_MES(m_reference_count, false, "[sock " << socket().native_handle() << "] m_reference_count already at 0 at connection<t_protocol_handler>::release() call");
// is this the last reference?
if (--m_reference_count == 0) {
// move the held reference to a local variable, keeping the object alive until the function terminates
std::swap(back_connection_copy, m_self_ref);
}
CRITICAL_REGION_END();
return true;
CATCH_ENTRY_L0("connection<t_protocol_handler>::release()", false);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
void connection<t_protocol_handler>::call_back_starter()
{
TRY_ENTRY();
_dbg2("[" << print_connection_context_short(context) << "] fired_callback");
m_protocol_handler.handle_qued_callback();
CATCH_ENTRY_L0("connection<t_protocol_handler>::call_back_starter()", void());
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
void connection<t_protocol_handler>::save_dbg_log()
{
std::string address, port;
boost::system::error_code e;
boost::asio::ip::tcp::endpoint endpoint = socket().remote_endpoint(e);
if (e)
{
address = "<not connected>";
port = "<not connected>";
}
else
{
address = endpoint.address().to_string();
port = boost::lexical_cast<std::string>(endpoint.port());
}
MDEBUG(" connection type " << to_string( m_connection_type ) << " "
<< socket().local_endpoint().address().to_string() << ":" << socket().local_endpoint().port()
<< " <--> " << context.m_remote_address.str() << " (via " << address << ":" << port << ")");
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
void connection<t_protocol_handler>::handle_read(const boost::system::error_code& e,
std::size_t bytes_transferred)
{
TRY_ENTRY();
//_info("[sock " << socket().native_handle() << "] Async read calledback.");
if (m_was_shutdown)
return;
if (!e)
{
double current_speed_down;
{
CRITICAL_REGION_LOCAL(m_throttle_speed_in_mutex);
m_throttle_speed_in.handle_trafic_exact(bytes_transferred);
current_speed_down = m_throttle_speed_in.get_current_speed();
}
context.m_current_speed_down = current_speed_down;
context.m_max_speed_down = std::max(context.m_max_speed_down, current_speed_down);
{
CRITICAL_REGION_LOCAL( epee::net_utils::network_throttle_manager::network_throttle_manager::m_lock_get_global_throttle_in );
epee::net_utils::network_throttle_manager::network_throttle_manager::get_global_throttle_in().handle_trafic_exact(bytes_transferred);
}
double delay=0; // will be calculated - how much we should sleep to obey speed limit etc
if (speed_limit_is_enabled()) {
do // keep sleeping if we should sleep
{
{ //_scope_dbg1("CRITICAL_REGION_LOCAL");
CRITICAL_REGION_LOCAL( epee::net_utils::network_throttle_manager::m_lock_get_global_throttle_in );
delay = epee::net_utils::network_throttle_manager::get_global_throttle_in().get_sleep_time_after_tick( bytes_transferred );
}
if (m_was_shutdown)
return;
delay *= 0.5;
long int ms = (long int)(delay * 100);
if (ms > 0) {
reset_timer(boost::posix_time::milliseconds(ms + 1), true);
boost::this_thread::sleep_for(boost::chrono::milliseconds(ms));
}
} while(delay > 0);
} // any form of sleeping
//_info("[sock " << socket().native_handle() << "] RECV " << bytes_transferred);
logger_handle_net_read(bytes_transferred);
context.m_last_recv = time(NULL);
context.m_recv_cnt += bytes_transferred;
m_ready_to_close = false;
bool recv_res = m_protocol_handler.handle_recv(buffer_.data(), bytes_transferred);
if(!recv_res)
{
//_info("[sock " << socket().native_handle() << "] protocol_want_close");
//some error in protocol, protocol handler ask to close connection
boost::interprocess::ipcdetail::atomic_write32(&m_want_close_connection, 1);
bool do_shutdown = false;
CRITICAL_REGION_BEGIN(m_send_que_lock);
if(!m_send_que.size())
do_shutdown = true;
CRITICAL_REGION_END();
if(do_shutdown)
shutdown();
}else
{
reset_timer(get_timeout_from_bytes_read(bytes_transferred), false);
async_read_some(boost::asio::buffer(buffer_),
strand_.wrap(
boost::bind(&connection<t_protocol_handler>::handle_read, connection<t_protocol_handler>::shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred)));
//_info("[sock " << socket().native_handle() << "]Async read requested.");
}
}else
{
_dbg3("[sock " << socket().native_handle() << "] Some not success at read: " << e.message() << ':' << e.value());
if(e.value() != 2)
{
_dbg3("[sock " << socket().native_handle() << "] Some problems at read: " << e.message() << ':' << e.value());
shutdown();
}
else
{
_dbg3("[sock " << socket().native_handle() << "] peer closed connection");
bool do_shutdown = false;
CRITICAL_REGION_BEGIN(m_send_que_lock);
if(!m_send_que.size())
do_shutdown = true;
CRITICAL_REGION_END();
if (m_ready_to_close || do_shutdown)
shutdown();
}
m_ready_to_close = true;
}
// If an error occurs then no new asynchronous operations are started. This
// means that all shared_ptr references to the connection object will
// disappear and the object will be destroyed automatically after this
// handler returns. The connection class's destructor closes the socket.
CATCH_ENTRY_L0("connection<t_protocol_handler>::handle_read", void());
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
void connection<t_protocol_handler>::handle_receive(const boost::system::error_code& e,
std::size_t bytes_transferred)
{
TRY_ENTRY();
if (m_was_shutdown) return;
if (e)
{
// offload the error case
handle_read(e, bytes_transferred);
return;
}
buffer_ssl_init_fill += bytes_transferred;
MTRACE("we now have " << buffer_ssl_init_fill << "/" << get_ssl_magic_size() << " bytes needed to detect SSL");
if (buffer_ssl_init_fill < get_ssl_magic_size())
{
socket().async_receive(boost::asio::buffer(buffer_.data() + buffer_ssl_init_fill, buffer_.size() - buffer_ssl_init_fill),
strand_.wrap(
boost::bind(&connection<t_protocol_handler>::handle_receive, connection<t_protocol_handler>::shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred)));
return;
}
// detect SSL
if (m_ssl_support == epee::net_utils::ssl_support_t::e_ssl_support_autodetect)
{
if (is_ssl((const unsigned char*)buffer_.data(), buffer_ssl_init_fill))
{
MDEBUG("That looks like SSL");
m_ssl_support = epee::net_utils::ssl_support_t::e_ssl_support_enabled; // read/write to the SSL socket
}
else
{
MDEBUG("That does not look like SSL");
m_ssl_support = epee::net_utils::ssl_support_t::e_ssl_support_disabled; // read/write to the raw socket
}
}
if (m_ssl_support == epee::net_utils::ssl_support_t::e_ssl_support_enabled)
{
// Handshake
if (!handshake(boost::asio::ssl::stream_base::server, boost::asio::const_buffer(buffer_.data(), buffer_ssl_init_fill)))
{
MERROR("SSL handshake failed");
boost::interprocess::ipcdetail::atomic_write32(&m_want_close_connection, 1);
m_ready_to_close = true;
bool do_shutdown = false;
CRITICAL_REGION_BEGIN(m_send_que_lock);
if(!m_send_que.size())
do_shutdown = true;
CRITICAL_REGION_END();
if(do_shutdown)
shutdown();
return;
}
}
else
{
handle_read(e, buffer_ssl_init_fill);
return;
}
async_read_some(boost::asio::buffer(buffer_),
strand_.wrap(
boost::bind(&connection<t_protocol_handler>::handle_read, connection<t_protocol_handler>::shared_from_this(),
boost::asio::placeholders::error,
boost::asio::placeholders::bytes_transferred)));
// If an error occurs then no new asynchronous operations are started. This
// means that all shared_ptr references to the connection object will
// disappear and the object will be destroyed automatically after this
// handler returns. The connection class's destructor closes the socket.
CATCH_ENTRY_L0("connection<t_protocol_handler>::handle_receive", void());
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool connection<t_protocol_handler>::call_run_once_service_io()
{
TRY_ENTRY();
if(!m_is_multithreaded)
{
//single thread model, we can wait in blocked call
size_t cnt = GET_IO_SERVICE(socket()).run_one();
if(!cnt)//service is going to quit
return false;
}else
{
//multi thread model, we can't(!) wait in blocked call
//so we make non blocking call and releasing CPU by calling sleep(0);
//if no handlers were called
//TODO: Maybe we need to have have critical section + event + callback to upper protocol to
//ask it inside(!) critical region if we still able to go in event wait...
size_t cnt = GET_IO_SERVICE(socket()).poll_one();
if(!cnt)
misc_utils::sleep_no_w(1);
}
return true;
CATCH_ENTRY_L0("connection<t_protocol_handler>::call_run_once_service_io", false);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool connection<t_protocol_handler>::do_send(byte_slice message) {
TRY_ENTRY();
// Use safe_shared_from_this, because of this is public method and it can be called on the object being deleted
auto self = safe_shared_from_this();
if (!self) return false;
if (m_was_shutdown) return false;
// TODO avoid copy
std::uint8_t const* const message_data = message.data();
const std::size_t message_size = message.size();
const double factor = 32; // TODO config
typedef long long signed int t_safe; // my t_size to avoid any overunderflow in arithmetic
const t_safe chunksize_good = (t_safe)( 1024 * std::max(1.0,factor) );
const t_safe chunksize_max = chunksize_good * 2 ;
const bool allow_split = (m_connection_type == e_connection_type_RPC) ? false : true; // do not split RPC data
CHECK_AND_ASSERT_MES(! (chunksize_max<0), false, "Negative chunksize_max" ); // make sure it is unsigned before removin sign with cast:
long long unsigned int chunksize_max_unsigned = static_cast<long long unsigned int>( chunksize_max ) ;
if (allow_split && (message_size > chunksize_max_unsigned)) {
{ // LOCK: chunking
epee::critical_region_t<decltype(m_chunking_lock)> send_guard(m_chunking_lock); // *** critical ***
MDEBUG("do_send() will SPLIT into small chunks, from packet="<<message_size<<" B for ptr="<<(const void*)message_data);
// 01234567890
// ^^^^ (pos=0, len=4) ; pos:=pos+len, pos=4
// ^^^^ (pos=4, len=4) ; pos:=pos+len, pos=8
// ^^^ (pos=8, len=4) ;
// const size_t bufsize = chunksize_good; // TODO safecast
// char* buf = new char[ bufsize ];
bool all_ok = true;
while (!message.empty()) {
byte_slice chunk = message.take_slice(chunksize_good);
MDEBUG("chunk_start="<<(void*)chunk.data()<<" ptr="<<(const void*)message_data<<" pos="<<(chunk.data() - message_data));
MDEBUG("part of " << message.size() << ": pos="<<(chunk.data() - message_data) << " len="<<chunk.size());
bool ok = do_send_chunk(std::move(chunk)); // <====== ***
all_ok = all_ok && ok;
if (!all_ok) {
MDEBUG("do_send() DONE ***FAILED*** from packet="<<message_size<<" B for ptr="<<(const void*)message_data);
MDEBUG("do_send() SEND was aborted in middle of big package - this is mostly harmless "
<< " (e.g. peer closed connection) but if it causes trouble tell us at #LibertyChain-dev. " << message_size);
return false; // partial failure in sending
}
// (in catch block, or uniq pointer) delete buf;
} // each chunk
MDEBUG("do_send() DONE SPLIT from packet="<<message_size<<" B for ptr="<<(const void*)message_data);
MDEBUG("do_send() m_connection_type = " << m_connection_type);
return all_ok; // done - e.g. queued - all the chunks of current do_send call
} // LOCK: chunking
} // a big block (to be chunked) - all chunks
else { // small block
return do_send_chunk(std::move(message)); // just send as 1 big chunk
}
CATCH_ENTRY_L0("connection<t_protocol_handler>::do_send", false);
} // do_send()
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool connection<t_protocol_handler>::do_send_chunk(byte_slice chunk)
{
TRY_ENTRY();
// Use safe_shared_from_this, because of this is public method and it can be called on the object being deleted
auto self = safe_shared_from_this();
if(!self)
return false;
if(m_was_shutdown)
return false;
double current_speed_up;
{
CRITICAL_REGION_LOCAL(m_throttle_speed_out_mutex);
m_throttle_speed_out.handle_trafic_exact(chunk.size());
current_speed_up = m_throttle_speed_out.get_current_speed();
}
context.m_current_speed_up = current_speed_up;
context.m_max_speed_up = std::max(context.m_max_speed_up, current_speed_up);
//_info("[sock " << socket().native_handle() << "] SEND " << cb);
context.m_last_send = time(NULL);
context.m_send_cnt += chunk.size();
//some data should be wrote to stream
//request complete
// No sleeping here; sleeping is done once and for all in "handle_write"
m_send_que_lock.lock(); // *** critical ***
epee::misc_utils::auto_scope_leave_caller scope_exit_handler = epee::misc_utils::create_scope_leave_handler([&](){m_send_que_lock.unlock();});
long int retry=0;
const long int retry_limit = 5*4;
while (m_send_que.size() > ABSTRACT_SERVER_SEND_QUE_MAX_COUNT)
{
retry++;
/* if ( ::cryptonote::core::get_is_stopping() ) { // TODO re-add fast stop
_fact("ABORT queue wait due to stopping");
return false; // aborted
}*/
using engine = std::mt19937;
engine rng;
std::random_device dev;
std::seed_seq::result_type rand[engine::state_size]{}; // Use complete bit space
std::generate_n(rand, engine::state_size, std::ref(dev));
std::seed_seq seed(rand, rand + engine::state_size);
rng.seed(seed);
long int ms = 250 + (rng() % 50);
MDEBUG("Sleeping because QUEUE is FULL, in " << __FUNCTION__ << " for " << ms << " ms before packet_size="<<chunk.size()); // XXX debug sleep
m_send_que_lock.unlock();
boost::this_thread::sleep(boost::posix_time::milliseconds( ms ) );
m_send_que_lock.lock();
_dbg1("sleep for queue: " << ms);
if (m_was_shutdown)
return false;
if (retry > retry_limit) {
MWARNING("send que size is more than ABSTRACT_SERVER_SEND_QUE_MAX_COUNT(" << ABSTRACT_SERVER_SEND_QUE_MAX_COUNT << "), shutting down connection");
shutdown();
return false;
}
}
m_send_que.push_back(std::move(chunk));
if(m_send_que.size() > 1)
{ // active operation should be in progress, nothing to do, just wait last operation callback
auto size_now = m_send_que.back().size();
MDEBUG("do_send_chunk() NOW just queues: packet="<<size_now<<" B, is added to queue-size="<<m_send_que.size());
//do_send_handler_delayed( ptr , size_now ); // (((H))) // empty function
LOG_TRACE_CC(context, "[sock " << socket().native_handle() << "] Async send requested " << m_send_que.front().size());
}
else
{ // no active operation
if(m_send_que.size()!=1)
{
_erro("Looks like no active operations, but send que size != 1!!");
return false;
}
auto size_now = m_send_que.front().size();
MDEBUG("do_send_chunk() NOW SENSD: packet="<<size_now<<" B");
if (speed_limit_is_enabled())
do_send_handler_write( m_send_que.back().data(), m_send_que.back().size() ); // (((H)))
CHECK_AND_ASSERT_MES( size_now == m_send_que.front().size(), false, "Unexpected queue size");
reset_timer(get_default_timeout(), false);
async_write(boost::asio::buffer(m_send_que.front().data(), size_now ) ,
strand_.wrap(
std::bind(&connection<t_protocol_handler>::handle_write, self, std::placeholders::_1, std::placeholders::_2)
)
);
//_dbg3("(chunk): " << size_now);
//logger_handle_net_write(size_now);
//_info("[sock " << socket().native_handle() << "] Async send requested " << m_send_que.front().size());
}
//do_send_handler_stop( ptr , cb ); // empty function
return true;
CATCH_ENTRY_L0("connection<t_protocol_handler>::do_send_chunk", false);
} // do_send_chunk
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
boost::posix_time::milliseconds connection<t_protocol_handler>::get_default_timeout()
{
unsigned count;
try { count = host_count(m_host); } catch (...) { count = 0; }
const unsigned shift = get_state().sock_count > AGGRESSIVE_TIMEOUT_THRESHOLD ? std::min(std::max(count, 1u) - 1, 8u) : 0;
boost::posix_time::milliseconds timeout(0);
if (m_local)
timeout = boost::posix_time::milliseconds(DEFAULT_TIMEOUT_MS_LOCAL >> shift);
else
timeout = boost::posix_time::milliseconds(DEFAULT_TIMEOUT_MS_REMOTE >> shift);
return timeout;
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
boost::posix_time::milliseconds connection<t_protocol_handler>::get_timeout_from_bytes_read(size_t bytes)
{
boost::posix_time::milliseconds ms = (boost::posix_time::milliseconds)(unsigned)(bytes * TIMEOUT_EXTRA_MS_PER_BYTE);
const auto cur = m_timer.expires_from_now().total_milliseconds();
if (cur > 0)
ms += (boost::posix_time::milliseconds)cur;
if (ms > get_default_timeout())
ms = get_default_timeout();
return ms;
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
unsigned int connection<t_protocol_handler>::host_count(const std::string &host, int delta)
{
static boost::mutex hosts_mutex;
CRITICAL_REGION_LOCAL(hosts_mutex);
static std::map<std::string, unsigned int> hosts;
unsigned int &val = hosts[host];
if (delta > 0)
MTRACE("New connection from host " << host << ": " << val);
else if (delta < 0)
MTRACE("Closed connection from host " << host << ": " << val);
CHECK_AND_ASSERT_THROW_MES(delta >= 0 || val >= (unsigned)-delta, "Count would go negative");
CHECK_AND_ASSERT_THROW_MES(delta <= 0 || val <= std::numeric_limits<unsigned int>::max() - (unsigned)delta, "Count would wrap");
val += delta;
return val;
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
void connection<t_protocol_handler>::reset_timer(boost::posix_time::milliseconds ms, bool add)
{
const auto tms = ms.total_milliseconds();
if (tms < 0 || (add && tms == 0))
{
MWARNING("Ignoring negative timeout " << ms);
return;
}
MTRACE((add ? "Adding" : "Setting") << " " << ms << " expiry");
auto self = safe_shared_from_this();
if(!self)
{
MERROR("Resetting timer on a dead object");
return;
}
if (m_was_shutdown)
{
MERROR("Setting timer on a shut down object");
return;
}
if (add)
{
const auto cur = m_timer.expires_from_now().total_milliseconds();
if (cur > 0)
ms += (boost::posix_time::milliseconds)cur;
}
m_timer.expires_from_now(ms);
m_timer.async_wait([=](const boost::system::error_code& ec)
{
if(ec == boost::asio::error::operation_aborted)
return;
MDEBUG(context << "connection timeout, closing");
self->close();
});
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool connection<t_protocol_handler>::shutdown()
{
CRITICAL_REGION_BEGIN(m_shutdown_lock);
if (m_was_shutdown)
return true;
m_was_shutdown = true;
// Initiate graceful connection closure.
m_timer.cancel();
boost::system::error_code ignored_ec;
if (m_ssl_support == epee::net_utils::ssl_support_t::e_ssl_support_enabled)
{
const shared_state &state = static_cast<const shared_state&>(get_state());
if (!state.stop_signal_sent)
socket_.shutdown(ignored_ec);
}
socket().shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored_ec);
if (!m_host.empty())
{
try { host_count(m_host, -1); } catch (...) { /* ignore */ }
m_host = "";
}
CRITICAL_REGION_END();
m_protocol_handler.release_protocol();
return true;
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool connection<t_protocol_handler>::close()
{
TRY_ENTRY();
auto self = safe_shared_from_this();
if(!self)
return false;
//_info("[sock " << socket().native_handle() << "] Que Shutdown called.");
m_timer.cancel();
size_t send_que_size = 0;
CRITICAL_REGION_BEGIN(m_send_que_lock);
send_que_size = m_send_que.size();
CRITICAL_REGION_END();
boost::interprocess::ipcdetail::atomic_write32(&m_want_close_connection, 1);
if(!send_que_size)
{
shutdown();
}
return true;
CATCH_ENTRY_L0("connection<t_protocol_handler>::close", false);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool connection<t_protocol_handler>::send_done()
{
if (m_ready_to_close)
return close();
m_ready_to_close = true;
return true;
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool connection<t_protocol_handler>::cancel()
{
return close();
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
void connection<t_protocol_handler>::handle_write(const boost::system::error_code& e, size_t cb)
{
TRY_ENTRY();
LOG_TRACE_CC(context, "[sock " << socket().native_handle() << "] Async send calledback " << cb);
if (e)
{
_dbg1("[sock " << socket().native_handle() << "] Some problems at write: " << e.message() << ':' << e.value());
shutdown();
return;
}
logger_handle_net_write(cb);
// The single sleeping that is needed for correctly handling "out" speed throttling
if (speed_limit_is_enabled()) {
sleep_before_packet(cb, 1, 1);
}
bool do_shutdown = false;
CRITICAL_REGION_BEGIN(m_send_que_lock);
if(m_send_que.empty())
{
_erro("[sock " << socket().native_handle() << "] m_send_que.size() == 0 at handle_write!");
return;
}
m_send_que.pop_front();
if(m_send_que.empty())
{
if(boost::interprocess::ipcdetail::atomic_read32(&m_want_close_connection))
{
do_shutdown = true;
}
}else
{
//have more data to send
reset_timer(get_default_timeout(), false);
auto size_now = m_send_que.front().size();
MDEBUG("handle_write() NOW SENDS: packet="<<size_now<<" B" <<", from queue size="<<m_send_que.size());
if (speed_limit_is_enabled())
do_send_handler_write_from_queue(e, m_send_que.front().size() , m_send_que.size()); // (((H)))
CHECK_AND_ASSERT_MES( size_now == m_send_que.front().size(), void(), "Unexpected queue size");
async_write(boost::asio::buffer(m_send_que.front().data(), size_now) ,
strand_.wrap(
std::bind(&connection<t_protocol_handler>::handle_write, connection<t_protocol_handler>::shared_from_this(), std::placeholders::_1, std::placeholders::_2)
)
);
//_dbg3("(normal)" << size_now);
}
CRITICAL_REGION_END();
if(do_shutdown)
{
shutdown();
}
CATCH_ENTRY_L0("connection<t_protocol_handler>::handle_write", void());
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
void connection<t_protocol_handler>::setRpcStation()
{
m_connection_type = e_connection_type_RPC;
MDEBUG("set m_connection_type = RPC ");
}
template<class t_protocol_handler>
bool connection<t_protocol_handler>::speed_limit_is_enabled() const {
return m_connection_type != e_connection_type_RPC ;
}
/************************************************************************/
/* */
/************************************************************************/
template<class t_protocol_handler>
boosted_tcp_server<t_protocol_handler>::boosted_tcp_server( t_connection_type connection_type ) :
m_state(std::make_shared<typename connection<t_protocol_handler>::shared_state>()),
m_io_service_local_instance(new worker()),
io_service_(m_io_service_local_instance->io_service),
acceptor_(io_service_),
acceptor_ipv6(io_service_),
default_remote(),
m_stop_signal_sent(false), m_port(0),
m_threads_count(0),
m_thread_index(0),
m_connection_type( connection_type ),
new_connection_(),
new_connection_ipv6()
{
create_server_type_map();
m_thread_name_prefix = "NET";
}
template<class t_protocol_handler>
boosted_tcp_server<t_protocol_handler>::boosted_tcp_server(boost::asio::io_service& extarnal_io_service, t_connection_type connection_type) :
m_state(std::make_shared<typename connection<t_protocol_handler>::shared_state>()),
io_service_(extarnal_io_service),
acceptor_(io_service_),
acceptor_ipv6(io_service_),
default_remote(),
m_stop_signal_sent(false), m_port(0),
m_threads_count(0),
m_thread_index(0),
m_connection_type(connection_type),
new_connection_(),
new_connection_ipv6()
{
create_server_type_map();
m_thread_name_prefix = "NET";
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
boosted_tcp_server<t_protocol_handler>::~boosted_tcp_server()
{
this->send_stop_signal();
timed_wait_server_stop(10000);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
void boosted_tcp_server<t_protocol_handler>::create_server_type_map()
{
server_type_map["NET"] = e_connection_type_NET;
server_type_map["RPC"] = e_connection_type_RPC;
server_type_map["P2P"] = e_connection_type_P2P;
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool boosted_tcp_server<t_protocol_handler>::init_server(uint32_t port, const std::string& address,
uint32_t port_ipv6, const std::string& address_ipv6, bool use_ipv6, bool require_ipv4,
ssl_options_t ssl_options)
{
TRY_ENTRY();
m_stop_signal_sent = false;
m_port = port;
m_port_ipv6 = port_ipv6;
m_address = address;
m_address_ipv6 = address_ipv6;
m_use_ipv6 = use_ipv6;
m_require_ipv4 = require_ipv4;
if (ssl_options)
m_state->configure_ssl(std::move(ssl_options));
std::string ipv4_failed = "";
std::string ipv6_failed = "";
try
{
boost::asio::ip::tcp::resolver resolver(io_service_);
boost::asio::ip::tcp::resolver::query query(address, boost::lexical_cast<std::string>(port), boost::asio::ip::tcp::resolver::query::canonical_name);
boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query);
acceptor_.open(endpoint.protocol());
#if !defined(_WIN32)
acceptor_.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
#endif
acceptor_.bind(endpoint);
acceptor_.listen();
boost::asio::ip::tcp::endpoint binded_endpoint = acceptor_.local_endpoint();
m_port = binded_endpoint.port();
MDEBUG("start accept (IPv4)");
new_connection_.reset(new connection<t_protocol_handler>(io_service_, m_state, m_connection_type, m_state->ssl_options().support));
acceptor_.async_accept(new_connection_->socket(),
boost::bind(&boosted_tcp_server<t_protocol_handler>::handle_accept_ipv4, this,
boost::asio::placeholders::error));
}
catch (const std::exception &e)
{
ipv4_failed = e.what();
}
if (ipv4_failed != "")
{
MERROR("Failed to bind IPv4: " << ipv4_failed);
if (require_ipv4)
{
throw std::runtime_error("Failed to bind IPv4 (set to required)");
}
}
if (use_ipv6)
{
try
{
if (port_ipv6 == 0) port_ipv6 = port; // default arg means bind to same port as ipv4
boost::asio::ip::tcp::resolver resolver(io_service_);
boost::asio::ip::tcp::resolver::query query(address_ipv6, boost::lexical_cast<std::string>(port_ipv6), boost::asio::ip::tcp::resolver::query::canonical_name);
boost::asio::ip::tcp::endpoint endpoint = *resolver.resolve(query);
acceptor_ipv6.open(endpoint.protocol());
#if !defined(_WIN32)
acceptor_ipv6.set_option(boost::asio::ip::tcp::acceptor::reuse_address(true));
#endif
acceptor_ipv6.set_option(boost::asio::ip::v6_only(true));
acceptor_ipv6.bind(endpoint);
acceptor_ipv6.listen();
boost::asio::ip::tcp::endpoint binded_endpoint = acceptor_ipv6.local_endpoint();
m_port_ipv6 = binded_endpoint.port();
MDEBUG("start accept (IPv6)");
new_connection_ipv6.reset(new connection<t_protocol_handler>(io_service_, m_state, m_connection_type, m_state->ssl_options().support));
acceptor_ipv6.async_accept(new_connection_ipv6->socket(),
boost::bind(&boosted_tcp_server<t_protocol_handler>::handle_accept_ipv6, this,
boost::asio::placeholders::error));
}
catch (const std::exception &e)
{
ipv6_failed = e.what();
}
}
if (use_ipv6 && ipv6_failed != "")
{
MERROR("Failed to bind IPv6: " << ipv6_failed);
if (ipv4_failed != "")
{
throw std::runtime_error("Failed to bind IPv4 and IPv6");
}
}
return true;
}
catch (const std::exception &e)
{
MFATAL("Error starting server: " << e.what());
return false;
}
catch (...)
{
MFATAL("Error starting server");
return false;
}
}
//-----------------------------------------------------------------------------
PUSH_WARNINGS
DISABLE_GCC_WARNING(maybe-uninitialized)
template<class t_protocol_handler>
bool boosted_tcp_server<t_protocol_handler>::init_server(const std::string port, const std::string& address,
const std::string port_ipv6, const std::string address_ipv6, bool use_ipv6, bool require_ipv4,
ssl_options_t ssl_options)
{
uint32_t p = 0;
uint32_t p_ipv6 = 0;
if (port.size() && !string_tools::get_xtype_from_string(p, port)) {
MERROR("Failed to convert port no = " << port);
return false;
}
if (port_ipv6.size() && !string_tools::get_xtype_from_string(p_ipv6, port_ipv6)) {
MERROR("Failed to convert port no = " << port_ipv6);
return false;
}
return this->init_server(p, address, p_ipv6, address_ipv6, use_ipv6, require_ipv4, std::move(ssl_options));
}
POP_WARNINGS
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool boosted_tcp_server<t_protocol_handler>::worker_thread()
{
TRY_ENTRY();
uint32_t local_thr_index = boost::interprocess::ipcdetail::atomic_inc32(&m_thread_index);
std::string thread_name = std::string("[") + m_thread_name_prefix;
thread_name += boost::to_string(local_thr_index) + "]";
MLOG_SET_THREAD_NAME(thread_name);
// _fact("Thread name: " << m_thread_name_prefix);
while(!m_stop_signal_sent)
{
try
{
io_service_.run();
return true;
}
catch(const std::exception& ex)
{
_erro("Exception at server worker thread, what=" << ex.what());
}
catch(...)
{
_erro("Exception at server worker thread, unknown execption");
}
}
//_info("Worker thread finished");
return true;
CATCH_ENTRY_L0("boosted_tcp_server<t_protocol_handler>::worker_thread", false);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
void boosted_tcp_server<t_protocol_handler>::set_threads_prefix(const std::string& prefix_name)
{
m_thread_name_prefix = prefix_name;
auto it = server_type_map.find(m_thread_name_prefix);
if (it==server_type_map.end()) throw std::runtime_error("Unknown prefix/server type:" + std::string(prefix_name));
auto connection_type = it->second; // the value of type
MINFO("Set server type to: " << connection_type << " from name: " << m_thread_name_prefix << ", prefix_name = " << prefix_name);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
void boosted_tcp_server<t_protocol_handler>::set_connection_filter(i_connection_filter* pfilter)
{
assert(m_state != nullptr); // always set in constructor
m_state->pfilter = pfilter;
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool boosted_tcp_server<t_protocol_handler>::run_server(size_t threads_count, bool wait, const boost::thread::attributes& attrs)
{
TRY_ENTRY();
m_threads_count = threads_count;
m_main_thread_id = boost::this_thread::get_id();
MLOG_SET_THREAD_NAME("[SRV_MAIN]");
while(!m_stop_signal_sent)
{
// Create a pool of threads to run all of the io_services.
CRITICAL_REGION_BEGIN(m_threads_lock);
for (std::size_t i = 0; i < threads_count; ++i)
{
boost::shared_ptr<boost::thread> thread(new boost::thread(
attrs, boost::bind(&boosted_tcp_server<t_protocol_handler>::worker_thread, this)));
_note("Run server thread name: " << m_thread_name_prefix);
m_threads.push_back(thread);
}
CRITICAL_REGION_END();
// Wait for all threads in the pool to exit.
if (wait)
{
_fact("JOINING all threads");
for (std::size_t i = 0; i < m_threads.size(); ++i) {
m_threads[i]->join();
}
_fact("JOINING all threads - almost");
m_threads.clear();
_fact("JOINING all threads - DONE");
}
else {
_dbg1("Reiniting OK.");
return true;
}
if(wait && !m_stop_signal_sent)
{
//some problems with the listening socket ?..
_dbg1("Net service stopped without stop request, restarting...");
if(!this->init_server(m_port, m_address, m_port_ipv6, m_address_ipv6, m_use_ipv6, m_require_ipv4))
{
_dbg1("Reiniting service failed, exit.");
return false;
}else
{
_dbg1("Reiniting OK.");
}
}
}
return true;
CATCH_ENTRY_L0("boosted_tcp_server<t_protocol_handler>::run_server", false);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool boosted_tcp_server<t_protocol_handler>::is_thread_worker()
{
TRY_ENTRY();
CRITICAL_REGION_LOCAL(m_threads_lock);
BOOST_FOREACH(boost::shared_ptr<boost::thread>& thp, m_threads)
{
if(thp->get_id() == boost::this_thread::get_id())
return true;
}
if(m_threads_count == 1 && boost::this_thread::get_id() == m_main_thread_id)
return true;
return false;
CATCH_ENTRY_L0("boosted_tcp_server<t_protocol_handler>::is_thread_worker", false);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool boosted_tcp_server<t_protocol_handler>::timed_wait_server_stop(uint64_t wait_mseconds)
{
TRY_ENTRY();
boost::chrono::milliseconds ms(wait_mseconds);
for (std::size_t i = 0; i < m_threads.size(); ++i)
{
if(m_threads[i]->joinable() && !m_threads[i]->try_join_for(ms))
{
_dbg1("Interrupting thread " << m_threads[i]->native_handle());
m_threads[i]->interrupt();
}
}
return true;
CATCH_ENTRY_L0("boosted_tcp_server<t_protocol_handler>::timed_wait_server_stop", false);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
void boosted_tcp_server<t_protocol_handler>::send_stop_signal()
{
m_stop_signal_sent = true;
typename connection<t_protocol_handler>::shared_state *state = static_cast<typename connection<t_protocol_handler>::shared_state*>(m_state.get());
state->stop_signal_sent = true;
TRY_ENTRY();
connections_mutex.lock();
for (auto &c: connections_)
{
c->cancel();
}
connections_.clear();
connections_mutex.unlock();
io_service_.stop();
CATCH_ENTRY_L0("boosted_tcp_server<t_protocol_handler>::send_stop_signal()", void());
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
void boosted_tcp_server<t_protocol_handler>::handle_accept_ipv4(const boost::system::error_code& e)
{
this->handle_accept(e, false);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
void boosted_tcp_server<t_protocol_handler>::handle_accept_ipv6(const boost::system::error_code& e)
{
this->handle_accept(e, true);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
void boosted_tcp_server<t_protocol_handler>::handle_accept(const boost::system::error_code& e, bool ipv6)
{
MDEBUG("handle_accept");
boost::asio::ip::tcp::acceptor* current_acceptor = &acceptor_;
connection_ptr* current_new_connection = &new_connection_;
auto accept_function_pointer = &boosted_tcp_server<t_protocol_handler>::handle_accept_ipv4;
if (ipv6)
{
current_acceptor = &acceptor_ipv6;
current_new_connection = &new_connection_ipv6;
accept_function_pointer = &boosted_tcp_server<t_protocol_handler>::handle_accept_ipv6;
}
try
{
if (!e)
{
if (m_connection_type == e_connection_type_RPC) {
const char *ssl_message = "unknown";
switch ((*current_new_connection)->get_ssl_support())
{
case epee::net_utils::ssl_support_t::e_ssl_support_disabled: ssl_message = "disabled"; break;
case epee::net_utils::ssl_support_t::e_ssl_support_enabled: ssl_message = "enabled"; break;
case epee::net_utils::ssl_support_t::e_ssl_support_autodetect: ssl_message = "autodetection"; break;
}
MDEBUG("New server for RPC connections, SSL " << ssl_message);
(*current_new_connection)->setRpcStation(); // hopefully this is not needed actually
}
connection_ptr conn(std::move((*current_new_connection)));
(*current_new_connection).reset(new connection<t_protocol_handler>(io_service_, m_state, m_connection_type, conn->get_ssl_support()));
current_acceptor->async_accept((*current_new_connection)->socket(),
boost::bind(accept_function_pointer, this,
boost::asio::placeholders::error));
boost::asio::socket_base::keep_alive opt(true);
conn->socket().set_option(opt);
bool res;
if (default_remote.get_type_id() == net_utils::address_type::invalid)
res = conn->start(true, 1 < m_threads_count);
else
res = conn->start(true, 1 < m_threads_count, default_remote);
if (!res)
{
conn->cancel();
return;
}
conn->save_dbg_log();
return;
}
else
{
MERROR("Error in boosted_tcp_server<t_protocol_handler>::handle_accept: " << e);
}
}
catch (const std::exception &e)
{
MERROR("Exception in boosted_tcp_server<t_protocol_handler>::handle_accept: " << e.what());
}
// error path, if e or exception
assert(m_state != nullptr); // always set in constructor
_erro("Some problems at accept: " << e.message() << ", connections_count = " << m_state->sock_count);
misc_utils::sleep_no_w(100);
(*current_new_connection).reset(new connection<t_protocol_handler>(io_service_, m_state, m_connection_type, (*current_new_connection)->get_ssl_support()));
current_acceptor->async_accept((*current_new_connection)->socket(),
boost::bind(accept_function_pointer, this,
boost::asio::placeholders::error));
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool boosted_tcp_server<t_protocol_handler>::add_connection(t_connection_context& out, boost::asio::ip::tcp::socket&& sock, network_address real_remote, epee::net_utils::ssl_support_t ssl_support)
{
if(std::addressof(get_io_service()) == std::addressof(GET_IO_SERVICE(sock)))
{
connection_ptr conn(new connection<t_protocol_handler>(std::move(sock), m_state, m_connection_type, ssl_support));
if(conn->start(false, 1 < m_threads_count, std::move(real_remote)))
{
conn->get_context(out);
conn->save_dbg_log();
return true;
}
}
else
{
MWARNING(out << " was not added, socket/io_service mismatch");
}
return false;
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
typename boosted_tcp_server<t_protocol_handler>::try_connect_result_t boosted_tcp_server<t_protocol_handler>::try_connect(connection_ptr new_connection_l, const std::string& adr, const std::string& port, boost::asio::ip::tcp::socket &sock_, const boost::asio::ip::tcp::endpoint &remote_endpoint, const std::string &bind_ip, uint32_t conn_timeout, epee::net_utils::ssl_support_t ssl_support)
{
TRY_ENTRY();
sock_.open(remote_endpoint.protocol());
if(bind_ip != "0.0.0.0" && bind_ip != "0" && bind_ip != "" )
{
boost::asio::ip::tcp::endpoint local_endpoint(boost::asio::ip::address::from_string(bind_ip.c_str()), 0);
boost::system::error_code ec;
sock_.bind(local_endpoint, ec);
if (ec)
{
MERROR("Error binding to " << bind_ip << ": " << ec.message());
if (sock_.is_open())
sock_.close();
return CONNECT_FAILURE;
}
}
/*
NOTICE: be careful to make sync connection from event handler: in case if all threads suddenly do sync connect, there will be no thread to dispatch events from io service.
*/
boost::system::error_code ec = boost::asio::error::would_block;
//have another free thread(s), work in wait mode, without event handling
struct local_async_context
{
boost::system::error_code ec;
boost::mutex connect_mut;
boost::condition_variable cond;
};
boost::shared_ptr<local_async_context> local_shared_context(new local_async_context());
local_shared_context->ec = boost::asio::error::would_block;
boost::unique_lock<boost::mutex> lock(local_shared_context->connect_mut);
auto connect_callback = [](boost::system::error_code ec_, boost::shared_ptr<local_async_context> shared_context)
{
shared_context->connect_mut.lock(); shared_context->ec = ec_; shared_context->cond.notify_one(); shared_context->connect_mut.unlock();
};
sock_.async_connect(remote_endpoint, std::bind<void>(connect_callback, std::placeholders::_1, local_shared_context));
while(local_shared_context->ec == boost::asio::error::would_block)
{
bool r = local_shared_context->cond.timed_wait(lock, boost::get_system_time() + boost::posix_time::milliseconds(conn_timeout));
if (m_stop_signal_sent)
{
if (sock_.is_open())
sock_.close();
return CONNECT_FAILURE;
}
if(local_shared_context->ec == boost::asio::error::would_block && !r)
{
//timeout
sock_.close();
_dbg3("Failed to connect to " << adr << ":" << port << ", because of timeout (" << conn_timeout << ")");
return CONNECT_FAILURE;
}
}
ec = local_shared_context->ec;
if (ec || !sock_.is_open())
{
_dbg3("Some problems at connect, message: " << ec.message());
if (sock_.is_open())
sock_.close();
return CONNECT_FAILURE;
}
_dbg3("Connected success to " << adr << ':' << port);
const ssl_support_t ssl_support = new_connection_l->get_ssl_support();
if (ssl_support == epee::net_utils::ssl_support_t::e_ssl_support_enabled || ssl_support == epee::net_utils::ssl_support_t::e_ssl_support_autodetect)
{
// Handshake
MDEBUG("Handshaking SSL...");
if (!new_connection_l->handshake(boost::asio::ssl::stream_base::client))
{
if (ssl_support == epee::net_utils::ssl_support_t::e_ssl_support_autodetect)
{
boost::system::error_code ignored_ec;
sock_.shutdown(boost::asio::ip::tcp::socket::shutdown_both, ignored_ec);
sock_.close();
return CONNECT_NO_SSL;
}
MERROR("SSL handshake failed");
if (sock_.is_open())
sock_.close();
return CONNECT_FAILURE;
}
}
return CONNECT_SUCCESS;
CATCH_ENTRY_L0("boosted_tcp_server<t_protocol_handler>::try_connect", CONNECT_FAILURE);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler>
bool boosted_tcp_server<t_protocol_handler>::connect(const std::string& adr, const std::string& port, uint32_t conn_timeout, t_connection_context& conn_context, const std::string& bind_ip, epee::net_utils::ssl_support_t ssl_support)
{
TRY_ENTRY();
connection_ptr new_connection_l(new connection<t_protocol_handler>(io_service_, m_state, m_connection_type, ssl_support) );
connections_mutex.lock();
connections_.insert(new_connection_l);
MDEBUG("connections_ size now " << connections_.size());
connections_mutex.unlock();
epee::misc_utils::auto_scope_leave_caller scope_exit_handler = epee::misc_utils::create_scope_leave_handler([&](){ CRITICAL_REGION_LOCAL(connections_mutex); connections_.erase(new_connection_l); });
boost::asio::ip::tcp::socket& sock_ = new_connection_l->socket();
bool try_ipv6 = false;
boost::asio::ip::tcp::resolver resolver(io_service_);
boost::asio::ip::tcp::resolver::query query(boost::asio::ip::tcp::v4(), adr, port, boost::asio::ip::tcp::resolver::query::canonical_name);
boost::system::error_code resolve_error;
boost::asio::ip::tcp::resolver::iterator iterator;
try
{
//resolving ipv4 address as ipv6 throws, catch here and move on
iterator = resolver.resolve(query, resolve_error);
}
catch (const boost::system::system_error& e)
{
if (!m_use_ipv6 || (resolve_error != boost::asio::error::host_not_found &&
resolve_error != boost::asio::error::host_not_found_try_again))
{
throw;
}
try_ipv6 = true;
}
catch (...)
{
throw;
}
std::string bind_ip_to_use;
boost::asio::ip::tcp::resolver::iterator end;
if(iterator == end)
{
if (!m_use_ipv6)
{
_erro("Failed to resolve " << adr);
return false;
}
else
{
try_ipv6 = true;
MINFO("Resolving address as IPv4 failed, trying IPv6");
}
}
else
{
bind_ip_to_use = bind_ip;
}
if (try_ipv6)
{
boost::asio::ip::tcp::resolver::query query6(boost::asio::ip::tcp::v6(), adr, port, boost::asio::ip::tcp::resolver::query::canonical_name);
iterator = resolver.resolve(query6, resolve_error);
if(iterator == end)
{
_erro("Failed to resolve " << adr);
return false;
}
else
{
if (bind_ip == "0.0.0.0")
{
bind_ip_to_use = "::";
}
else
{
bind_ip_to_use = "";
}
}
}
MDEBUG("Trying to connect to " << adr << ":" << port << ", bind_ip = " << bind_ip_to_use);
//boost::asio::ip::tcp::endpoint remote_endpoint(boost::asio::ip::address::from_string(addr.c_str()), port);
boost::asio::ip::tcp::endpoint remote_endpoint(*iterator);
auto try_connect_result = try_connect(new_connection_l, adr, port, sock_, remote_endpoint, bind_ip_to_use, conn_timeout, ssl_support);
if (try_connect_result == CONNECT_FAILURE)
return false;
if (ssl_support == epee::net_utils::ssl_support_t::e_ssl_support_autodetect && try_connect_result == CONNECT_NO_SSL)
{
// we connected, but could not connect with SSL, try without
MERROR("SSL handshake failed on an autodetect connection, reconnecting without SSL");
new_connection_l->disable_ssl();
try_connect_result = try_connect(new_connection_l, adr, port, sock_, remote_endpoint, bind_ip_to_use, conn_timeout, epee::net_utils::ssl_support_t::e_ssl_support_disabled);
if (try_connect_result != CONNECT_SUCCESS)
return false;
}
// start adds the connection to the config object's list, so we don't need to have it locally anymore
connections_mutex.lock();
connections_.erase(new_connection_l);
connections_mutex.unlock();
bool r = new_connection_l->start(false, 1 < m_threads_count);
if (r)
{
new_connection_l->get_context(conn_context);
//new_connection_l.reset(new connection<t_protocol_handler>(io_service_, m_config, m_sock_count, m_pfilter));
}
else
{
assert(m_state != nullptr); // always set in constructor
_erro("[sock " << new_connection_l->socket().native_handle() << "] Failed to start connection, connections_count = " << m_state->sock_count);
}
new_connection_l->save_dbg_log();
return r;
CATCH_ENTRY_L0("boosted_tcp_server<t_protocol_handler>::connect", false);
}
//---------------------------------------------------------------------------------
template<class t_protocol_handler> template<class t_callback>
bool boosted_tcp_server<t_protocol_handler>::connect_async(const std::string& adr, const std::string& port, uint32_t conn_timeout, const t_callback &cb, const std::string& bind_ip, epee::net_utils::ssl_support_t ssl_support)
{
TRY_ENTRY();
connection_ptr new_connection_l(new connection<t_protocol_handler>(io_service_, m_state, m_connection_type, ssl_support) );
connections_mutex.lock();
connections_.insert(new_connection_l);
MDEBUG("connections_ size now " << connections_.size());
connections_mutex.unlock();
epee::misc_utils::auto_scope_leave_caller scope_exit_handler = epee::misc_utils::create_scope_leave_handler([&](){ CRITICAL_REGION_LOCAL(connections_mutex); connections_.erase(new_connection_l); });
boost::asio::ip::tcp::socket& sock_ = new_connection_l->socket();
bool try_ipv6 = false;
boost::asio::ip::tcp::resolver resolver(io_service_);
boost::asio::ip::tcp::resolver::query query(boost::asio::ip::tcp::v4(), adr, port, boost::asio::ip::tcp::resolver::query::canonical_name);
boost::system::error_code resolve_error;
boost::asio::ip::tcp::resolver::iterator iterator;
try
{
//resolving ipv4 address as ipv6 throws, catch here and move on
iterator = resolver.resolve(query, resolve_error);
}
catch (const boost::system::system_error& e)
{
if (!m_use_ipv6 || (resolve_error != boost::asio::error::host_not_found &&
resolve_error != boost::asio::error::host_not_found_try_again))
{
throw;
}
try_ipv6 = true;
}
catch (...)
{
throw;
}
boost::asio::ip::tcp::resolver::iterator end;
if(iterator == end)
{
if (!try_ipv6)
{
_erro("Failed to resolve " << adr);
return false;
}
else
{
MINFO("Resolving address as IPv4 failed, trying IPv6");
}
}
if (try_ipv6)
{
boost::asio::ip::tcp::resolver::query query6(boost::asio::ip::tcp::v6(), adr, port, boost::asio::ip::tcp::resolver::query::canonical_name);
iterator = resolver.resolve(query6, resolve_error);
if(iterator == end)
{
_erro("Failed to resolve " << adr);
return false;
}
}
boost::asio::ip::tcp::endpoint remote_endpoint(*iterator);
sock_.open(remote_endpoint.protocol());
if(bind_ip != "0.0.0.0" && bind_ip != "0" && bind_ip != "" )
{
boost::asio::ip::tcp::endpoint local_endpoint(boost::asio::ip::address::from_string(bind_ip.c_str()), 0);
boost::system::error_code ec;
sock_.bind(local_endpoint, ec);
if (ec)
{
MERROR("Error binding to " << bind_ip << ": " << ec.message());
if (sock_.is_open())
sock_.close();
return false;
}
}
boost::shared_ptr<boost::asio::deadline_timer> sh_deadline(new boost::asio::deadline_timer(io_service_));
//start deadline
sh_deadline->expires_from_now(boost::posix_time::milliseconds(conn_timeout));
sh_deadline->async_wait([=](const boost::system::error_code& error)
{
if(error != boost::asio::error::operation_aborted)
{
_dbg3("Failed to connect to " << adr << ':' << port << ", because of timeout (" << conn_timeout << ")");
new_connection_l->socket().close();
}
});
//start async connect
sock_.async_connect(remote_endpoint, [=](const boost::system::error_code& ec_)
{
t_connection_context conn_context = AUTO_VAL_INIT(conn_context);
boost::system::error_code ignored_ec;
boost::asio::ip::tcp::socket::endpoint_type lep = new_connection_l->socket().local_endpoint(ignored_ec);
if(!ec_)
{//success
if(!sh_deadline->cancel())
{
cb(conn_context, boost::asio::error::operation_aborted);//this mean that deadline timer already queued callback with cancel operation, rare situation
}else
{
_dbg3("[sock " << new_connection_l->socket().native_handle() << "] Connected success to " << adr << ':' << port <<
" from " << lep.address().to_string() << ':' << lep.port());
// start adds the connection to the config object's list, so we don't need to have it locally anymore
connections_mutex.lock();
connections_.erase(new_connection_l);
connections_mutex.unlock();
bool r = new_connection_l->start(false, 1 < m_threads_count);
if (r)
{
new_connection_l->get_context(conn_context);
cb(conn_context, ec_);
}
else
{
_dbg3("[sock " << new_connection_l->socket().native_handle() << "] Failed to start connection to " << adr << ':' << port);
cb(conn_context, boost::asio::error::fault);
}
}
}else
{
_dbg3("[sock " << new_connection_l->socket().native_handle() << "] Failed to connect to " << adr << ':' << port <<
" from " << lep.address().to_string() << ':' << lep.port() << ": " << ec_.message() << ':' << ec_.value());
cb(conn_context, ec_);
}
});
return true;
CATCH_ENTRY_L0("boosted_tcp_server<t_protocol_handler>::connect_async", false);
}
} // namespace
} // namespace
PRAGMA_WARNING_POP
| [
"[email protected]"
] | |
2f29c538e2d4b7728d9ba5f3427ffebd7bf4222b | e60f65100488a37b2a46156041f07cb36842c897 | /Listas-Pilas-Colas/Queue.hpp | 7268d678125dc62f343d93e470926d3e307d5192 | [] | no_license | ngantonio/Estructuras | f30d180dafdd310a1dcd07b4486da18fa582f8ff | 1460eb2020e3e048684f010fa49723ea30d7bd63 | refs/heads/master | 2021-07-13T01:10:59.431994 | 2017-10-16T17:27:48 | 2017-10-16T17:27:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,774 | hpp | /****ESTRUCTURA DINAMICA COLA. © GABRIEL A. OLIVEIRA N.*****/
#ifndef QUEUE_H_
#define QUEUE_H_
#include <iostream>
#include "Node.hpp"
#include "List.hpp"
#include <iomanip>
using namespace std;
template <class type>
class Queue: public List<type>{
template <typename T>
friend ostream& operator<<(ostream&, const Queue<T> &);
public:
Queue(); /*Constructor*/
Queue(const Queue<type> &); /*Costructor Copia*/
int getLength(); /*devuelve la longitud de la cola*/
bool empty(); /*Esta vacia la cola?*/
type front(); /*Devuelve el frente de la cola*/
type dequeue(); /*Desencolar un elemento*/
void enqueue(type); /*Encolar un elemento*/
};
template <typename type>
Queue<type>::Queue():List<type>::List() { }
template <typename type>
Queue<type>::Queue(const Queue<type> &right) :List<type>::List(right) { }
template <typename type>
int Queue<type>::getLength(){return List<type>::getLength();}
template <typename type>
bool Queue<type>::empty(){return List<type>::empty(); }
template <typename type>
void Queue<type>::enqueue(type element){List<type>::push_back(element); }
template <typename type>
type Queue<type>::dequeue(){return List<type>::removeForPosition(1);}
template <typename type>
type Queue<type>::front(){return List<type>::search(1);}
template <class type>
ostream& operator<<(ostream &output, const Queue<type> &Right){
Node<type> *aux;
aux = Right.first;
cout << endl;
while(aux != NULL){
cout << " | " << aux->getData();
aux = aux->getNext();
}
if(aux == NULL)
cout << " | NULL"<< endl << endl;
return output;
}
#endif | [
"[email protected]"
] | |
dc561f61c092dd5b76009e37531d016664e7ca94 | f1f9f3482a750ea1ab217292cef2b07754be1af2 | /maniii/maniii/maniii.cpp | 54423d07a6497e8425813a45aa508cd35ed65d25 | [] | no_license | ashishbindra2/cpp | 877263c14e11d1daf828c9aaffa5ec8538c1ce52 | 2d556e910426f0ea9fc229069ed105498f5650f4 | refs/heads/master | 2020-08-03T14:13:26.467732 | 2020-05-28T16:11:39 | 2020-05-28T16:11:39 | 211,778,548 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 148 | cpp | // maniii.cpp : Defines the entry point for the console application.
//
#include "stdafx.h"
int _tmain(int argc, _TCHAR* argv[])
{
return 0;
}
| [
"[email protected]"
] | |
0b0a27e48e5a70ff5cdf97726a93556d917b5366 | aafbe40c5809e9d7d4f2b3e13da42548b153bda2 | /ouzel/graphics/Texture.cpp | 4907c30857fadb09562ae876283b61cda2b1c8e6 | [
"BSD-3-Clause",
"BSD-2-Clause"
] | permissive | uudens/ouzel | 7eac25080b9da6745fc565041e604b9c9382bf7e | f7fc20f4512b489e519c93a4cd8c81b579a63f47 | refs/heads/master | 2020-12-24T09:56:22.261205 | 2016-06-14T16:25:16 | 2016-06-14T16:25:16 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,141 | cpp | // Copyright (C) 2016 Elviss Strazdins
// This file is part of the Ouzel engine.
#include <cstring>
#include "core/CompileConfig.h"
#include "Texture.h"
#include "core/Engine.h"
#include "Renderer.h"
#include "Image.h"
#include "utils/Utils.h"
#include "math/MathUtils.h"
namespace ouzel
{
namespace graphics
{
Texture::Texture()
{
}
Texture::~Texture()
{
}
void Texture::free()
{
ready = false;
}
bool Texture::init(const Size2& newSize, bool newDynamic, bool newMipmaps, bool newRenderTarget)
{
size = newSize;
dynamic = newDynamic;
mipmaps = newMipmaps;
renderTarget = newRenderTarget;
ready = true;
return true;
}
bool Texture::initFromFile(const std::string& newFilename, bool newDynamic, bool newMipmaps)
{
filename = newFilename;
dynamic = newDynamic;
mipmaps = newMipmaps;
renderTarget = false;
Image image;
if (!image.initFromFile(filename))
{
ready = false;
return false;
}
return initFromData(image.getData(), image.getSize(), dynamic, mipmaps);
}
bool Texture::initFromData(const void* data, const Size2& newSize, bool newDynamic, bool newMipmaps)
{
OUZEL_UNUSED(data);
size = newSize;
dynamic = newDynamic;
mipmaps = newMipmaps;
ready = true;
return true;
}
bool Texture::upload(const void* data, const Size2& newSize)
{
OUZEL_UNUSED(data);
if (!dynamic)
{
return false;
}
if (newSize.width <= 0.0f || newSize.height <= 0.0f)
{
return false;
}
return uploadData(data, newSize);
}
static void imageRgba8Downsample2x2(uint32_t width, uint32_t height, uint32_t pitch, const uint8_t* src, uint8_t* dst)
{
const uint32_t dstwidth = width / 2;
const uint32_t dstheight = height / 2;
if (dstwidth == 0 || dstheight == 0)
{
return;
}
for (uint32_t y = 0, ystep = pitch * 2; y < dstheight; ++y, src += ystep)
{
const uint8_t* rgba = src;
for (uint32_t x = 0; x < dstwidth; ++x, rgba += 8, dst += 4)
{
float pixels = 0.0f;
float r = 0, g = 0, b = 0, a = 0;
if (rgba[3] > 0)
{
r += powf(rgba[0], 2.2f);
g += powf(rgba[1], 2.2f);
b += powf(rgba[2], 2.2f);
pixels += 1.0f;
}
a = rgba[3];
if (rgba[7] > 0)
{
r += powf(rgba[4], 2.2f);
g += powf(rgba[5], 2.2f);
b += powf(rgba[6], 2.2f);
pixels += 1.0f;
}
a += rgba[7];
if (rgba[pitch+3])
{
r += powf(rgba[pitch+0], 2.2f);
g += powf(rgba[pitch+1], 2.2f);
b += powf(rgba[pitch+2], 2.2f);
pixels += 1.0f;
}
a += rgba[pitch+3];
if (rgba[pitch+7] > 0)
{
r += powf(rgba[pitch+4], 2.2f);
g += powf(rgba[pitch+5], 2.2f);
b += powf(rgba[pitch+6], 2.2f);
pixels += 1.0f;
}
a += rgba[pitch+7];
if (pixels > 0.0f)
{
r /= pixels;
g /= pixels;
b /= pixels;
}
else
{
r = g = b = 0;
}
a *= 0.25f;
r = powf(r, 1.0f / 2.2f);
g = powf(g, 1.0f / 2.2f);
b = powf(b, 1.0f / 2.2f);
dst[0] = (uint8_t)r;
dst[1] = (uint8_t)g;
dst[2] = (uint8_t)b;
dst[3] = (uint8_t)a;
}
}
}
bool Texture::uploadData(const void* data, const Size2& newSize)
{
size = newSize;
mipmapSizes.clear();
mipmapSizes.push_back(newSize);
uint32_t mipLevel = 0;
uploadMipmap(mipLevel, data);
++mipLevel;
uint32_t newWidth = static_cast<uint32_t>(newSize.width);
uint32_t newHeight = static_cast<uint32_t>(newSize.height);
#if defined(OUZEL_SUPPORTS_OPENGLES)
if (mipmaps && (sharedEngine->getRenderer()->getDriver() != Renderer::Driver::OPENGL || (isPOT(newWidth) && isPOT(newHeight))))
#else
if (mipmaps)
#endif
{
uint32_t pitch = newWidth * 4;
uint32_t bufferSize = newWidth * newHeight * 4;
if (newWidth == 1)
{
bufferSize *= 2;
}
if (newHeight == 1)
{
bufferSize *= 2;
}
std::vector<uint8_t> newData(bufferSize);
memcpy(newData.data(), data, newWidth * newHeight * 4);
while (newWidth >= 2 && newHeight >= 2)
{
imageRgba8Downsample2x2(newWidth, newHeight, pitch, newData.data(), newData.data());
newWidth >>= 1;
newHeight >>= 1;
mipmapSizes.push_back(Size2(static_cast<float>(newWidth), static_cast<float>(newHeight)));
uploadMipmap(mipLevel, newData.data());
pitch = newWidth * 4;
++mipLevel;
}
if (newWidth > newHeight)
{
for (; newWidth >= 2;)
{
memcpy(&newData.data()[newWidth*4], newData.data(), newWidth * 4);
imageRgba8Downsample2x2(newWidth, 2, pitch, newData.data(), newData.data());
newWidth >>= 1;
mipmapSizes.push_back(Size2(static_cast<float>(newWidth), static_cast<float>(newHeight)));
uploadMipmap(mipLevel, newData.data());
pitch = newWidth * 4;
++mipLevel;
}
}
else
{
for (; newHeight >= 2;)
{
uint32_t* src = reinterpret_cast<uint32_t*>(newData.data());
for (int32_t i = static_cast<int32_t>(newHeight) - 1; i >= 0; --i)
{
src[i * 2] = src[i];
src[i * 2 + 1] = src[i];
}
imageRgba8Downsample2x2(2, newHeight, 8, newData.data(), newData.data());
newHeight >>= 1;
mipmapSizes.push_back(Size2(static_cast<float>(newWidth), static_cast<float>(newHeight)));
uploadMipmap(mipLevel, newData.data());
++mipLevel;
}
}
}
return true;
}
bool Texture::uploadMipmap(uint32_t level, const void* data)
{
OUZEL_UNUSED(data);
if (level >= mipmapSizes.size())
{
return false;
}
return true;
}
} // namespace graphics
} // namespace ouzel
| [
"[email protected]"
] | |
e255947f95c9906fcb1bb70ab4d3488dfe930ee6 | b4b332a793c68ea14a3963eaaa5f0a979e14e327 | /include/Experimental_Hall.hh | b98f0aeaf190717fa9a1e8952b91b33520294a39 | [] | no_license | hlcrawford/HRSimulation | df58cc50fdf615a7bc5e6c193a08382193751ba2 | 71ba16e8a5ac8629eeef1dae57900facf07e3ec5 | refs/heads/master | 2020-03-25T05:58:56.760814 | 2018-08-03T22:01:23 | 2018-08-03T22:01:23 | 143,476,804 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,089 | hh | #ifndef Experimental_Hall_H
#define Experimental_Hall_H 1
#include "G4Material.hh"
#include "Materials.hh"
#include "G4Box.hh"
#include "G4LogicalVolume.hh"
#include "G4VPhysicalVolume.hh"
#include "G4ThreeVector.hh"
#include "G4PVPlacement.hh"
#include "G4VisAttributes.hh"
#include "G4Colour.hh"
#include "G4RotationMatrix.hh"
#include "G4Transform3D.hh"
#include "G4UnitsTable.hh"
#include "G4SystemOfUnits.hh"
class Experimental_Hall
{
public:
Experimental_Hall(Materials*);
~Experimental_Hall();
G4VPhysicalVolume *Construct();
G4LogicalVolume* GetLogVolume(){return ExperimentalHall_log;};
void setX(G4double);
void setY(G4double);
void setZ(G4double);
void setMaterial(G4String);
void Report();
private:
// dimensions
G4double expHall_x;
G4double expHall_y;
G4double expHall_z;
//materials
Materials* materials;
G4Material* ExperimentalHallMaterial;
//the box
G4Box* ExperimentalHall;
//logical volume
G4LogicalVolume* ExperimentalHall_log;
//physical volume
G4VPhysicalVolume* ExperimentalHall_phys;
};
#endif
| [
"[email protected]"
] | |
46c257e36d3c918477124dac6443c77ecb0575c9 | 600df3590cce1fe49b9a96e9ca5b5242884a2a70 | /content/renderer/origin_trials/web_trial_token_validator_impl.cc | d3eafa8b1f64515b5e2f37f3165e7cd90e25f5ac | [
"BSD-3-Clause"
] | permissive | metux/chromium-suckless | efd087ba4f4070a6caac5bfbfb0f7a4e2f3c438a | 72a05af97787001756bae2511b7985e61498c965 | refs/heads/orig | 2022-12-04T23:53:58.681218 | 2017-04-30T10:59:06 | 2017-04-30T23:35:58 | 89,884,931 | 5 | 3 | BSD-3-Clause | 2022-11-23T20:52:53 | 2017-05-01T00:09:08 | null | UTF-8 | C++ | false | false | 1,018 | cc | // Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "content/renderer/origin_trials/web_trial_token_validator_impl.h"
#include "content/common/origin_trials/trial_token_validator.h"
#include "third_party/WebKit/public/platform/WebOriginTrialTokenStatus.h"
namespace content {
WebTrialTokenValidatorImpl::WebTrialTokenValidatorImpl() {}
WebTrialTokenValidatorImpl::~WebTrialTokenValidatorImpl() {}
blink::WebOriginTrialTokenStatus WebTrialTokenValidatorImpl::validateToken(
const blink::WebString& token,
const blink::WebSecurityOrigin& origin,
blink::WebString* feature_name) {
std::string feature;
blink::WebOriginTrialTokenStatus status =
TrialTokenValidator::ValidateToken(token.utf8(), origin, &feature);
if (status == blink::WebOriginTrialTokenStatus::Success)
*feature_name = blink::WebString::fromUTF8(feature);
return status;
}
} // namespace content
| [
"[email protected]"
] | |
d0f5f925e967a8cbdcc23960ab7396562d8392f6 | 5312bc6765744af45592a1e9270b2d68d1304bb0 | /src/B4aEventAction.cc | e970351d3306110cc4ed57d4e04740735220df25 | [] | no_license | jkiesele/miniCalo2 | 9ba59dc8f255d25990f1837463cf4d1b6eed497f | cca14f6fce2d002436ac035edabd699b833ec4ff | refs/heads/master | 2020-03-28T15:48:05.254425 | 2018-09-13T12:19:23 | 2018-09-13T12:19:23 | 148,627,390 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,780 | cc | //
// ********************************************************************
// * License and Disclaimer *
// * *
// * The Geant4 software is copyright of the Copyright Holders of *
// * the Geant4 Collaboration. It is provided under the terms and *
// * conditions of the Geant4 Software License, included in the file *
// * LICENSE and available at http://cern.ch/geant4/license . These *
// * include a list of copyright holders. *
// * *
// * Neither the authors of this software system, nor their employing *
// * institutes,nor the agencies providing financial support for this *
// * work make any representation or warranty, express or implied, *
// * regarding this software system or assume any liability for its *
// * use. Please see the license in the file LICENSE and URL above *
// * for the full disclaimer and the limitation of liability. *
// * *
// * This code implementation is the result of the scientific and *
// * technical work of the GEANT4 collaboration. *
// * By using, copying, modifying or distributing the software (or *
// * any work based on the software) you agree to acknowledge its *
// * use in resulting scientific publications, and indicate your *
// * acceptance of all terms of the Geant4 Software license. *
// ********************************************************************
//
// $Id: B4aEventAction.cc 100946 2016-11-03 11:28:08Z gcosmo $
//
/// \file B4aEventAction.cc
/// \brief Implementation of the B4aEventAction class
#include "B4aEventAction.hh"
#include "B4RunAction.hh"
#include "B4Analysis.hh"
#include "G4RunManager.hh"
#include "G4Event.hh"
#include "G4UnitsTable.hh"
#include "Randomize.hh"
#include <iomanip>
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
B4aEventAction::B4aEventAction()
: G4UserEventAction(),
fEnergyAbs(0.),
fEnergyGap(0.),
fTrackLAbs(0.),
fTrackLGap(0.),
generator_(0)
{
//create vector ntuple here
// auto analysisManager = G4AnalysisManager::Instance();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
B4aEventAction::~B4aEventAction()
{}
void B4aEventAction::accumulateVolumeInfo(G4VPhysicalVolume * volume,const G4Step* step){
const auto& activesensors=detector_->getActiveSensors();
bool issensor=true;
size_t idx=activesensors->size();
for(size_t i=0;i<activesensors->size();i++){
if(volume == activesensors->at(i).getVol()){
idx=i;
break;
}
if(volume == activesensors->at(i).getAbsorberVol()){
idx=i;
issensor=false;
break;
}
}
if(idx==activesensors->size())return;//not active volume
size_t currentindex=0;
size_t hitidx=allvolumes_.size();
hitidx = std::find(allvolumes_.begin(),allvolumes_.end(),activesensors->at(idx).getVol())-allvolumes_.begin();
if(hitidx != allvolumes_.size()){
currentindex=hitidx;
}
else{
currentindex=allvolumes_.size();
allvolumes_.push_back(activesensors->at(idx).getVol());
rechit_energy_.push_back(0);
rechit_absorber_energy_.push_back(0);
rechit_x_.push_back(0);
rechit_y_.push_back(0);
rechit_z_.push_back(0);
rechit_layer_.push_back(0);
rechit_varea_.push_back(0);
rechit_vz_.push_back(0);
rechit_vxy_.push_back(0);
}
auto energy=step->GetTotalEnergyDeposit();
if(issensor){
energy *= activesensors->at(idx).getEnergyscalefactor();
rechit_energy_.at(currentindex)+=energy;
}
else{
rechit_absorber_energy_.at(currentindex)+=energy;
}
rechit_x_.at (currentindex)=activesensors->at(idx).getPosx();
rechit_y_.at (currentindex)=activesensors->at(idx).getPosy();
rechit_z_.at (currentindex)=activesensors->at(idx).getPosz();
rechit_layer_.at (currentindex)=activesensors->at(idx).getLayer();
rechit_varea_.at (currentindex)=activesensors->at(idx).getArea();
rechit_vz_.at (currentindex)=activesensors->at(idx).getDimz();
rechit_vxy_.at (currentindex)=activesensors->at(idx).getDimxy();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void B4aEventAction::BeginOfEventAction(const G4Event* /*event*/)
{
// initialisation per event
fEnergyAbs = 0.;
fEnergyGap = 0.;
fTrackLAbs = 0.;
fTrackLGap = 0.;
clear();
//set generator stuff
//random particle
//random energy
/*
do this in the generator
*/
//
//
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
void B4aEventAction::EndOfEventAction(const G4Event* event)
{
// Accumulate statistics
//
// get analysis manager
auto analysisManager = G4AnalysisManager::Instance();
// fill ntuple
int i=0;
int ispart[B4PrimaryGeneratorAction::particles_size];
for( ;i<B4PrimaryGeneratorAction::particles_size;i++){
ispart[i]=B4PrimaryGeneratorAction::globalgen->isParticle(i);
analysisManager->FillNtupleIColumn(i,ispart[i]);
}
analysisManager->FillNtupleDColumn(i,B4PrimaryGeneratorAction::globalgen->getEnergy());
analysisManager->FillNtupleDColumn(i+1,B4PrimaryGeneratorAction::globalgen->getX());
analysisManager->FillNtupleDColumn(i+2,B4PrimaryGeneratorAction::globalgen->getY());
analysisManager->FillNtupleDColumn(i+3,B4PrimaryGeneratorAction::globalgen->getR());
//filling deposits and volume info for all volumes automatically..
for(auto& e:rechit_energy_){
if(e<0.01)e=0; //threshold
}
analysisManager->AddNtupleRow();
clear();
}
//....oooOO0OOooo........oooOO0OOooo........oooOO0OOooo........oooOO0OOooo......
| [
"[email protected]"
] | |
1ef804a85ea54900b4a22bc855007d349c14d499 | 05877a2afb31a5991f5863b6ce9ef50f5f4068d0 | /Week_09/first-unique-character-in-a-string.cpp | 99c28eb71cabccdb05f7caf0d74ea3b6e10db7c8 | [] | no_license | eagle444eagle/algorithm011-class02 | e1e81d3af6b83e3d052da608ce6d16f385192154 | f5c63e223c67119308a80ffb3c132b795f7dd26c | refs/heads/master | 2022-12-04T08:00:01.456698 | 2020-08-31T15:05:13 | 2020-08-31T15:05:13 | 277,316,461 | 0 | 0 | null | 2020-07-05T14:18:07 | 2020-07-05T14:18:06 | null | UTF-8 | C++ | false | false | 331 | cpp | class Solution {
public:
int firstUniqChar(string s) {
unordered_map<char,int> hashmap;
for(auto i : s){
if(hashmap.count(i)) hashmap[i] += 1;
else hashmap[i] = 1;
}
for(int j = 0; s[j] != '\0'; ++ j) if(hashmap[s[j]] == 1) return j;
return -1;
}
};
| [
"[email protected]"
] | |
5c411276ed18c8b61ee88dfca34adf146941ca7d | 6d7ed1ee17279819b9b393e554594771f79cada4 | /spec/build/graph/program/DictionarySort.h | 8011c702e0f6865cecbf9fbcbd512a254b08532a | [
"MIT"
] | permissive | ioquatix/build-graph | 1781628ee12cac97a3142005c85f05b4326140cb | 249ca549ea0aa15e7d3ef91216c91fcd66da40b2 | refs/heads/main | 2022-06-04T01:24:19.608677 | 2022-05-23T00:46:59 | 2022-05-23T00:46:59 | 17,480,469 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 7,188 | h | //
// DictionarySort.h
// DictionarySort
//
// Created by Samuel Williams on 2/11/11.
// Copyright, 2014, by Samuel G. D. Williams. <http://www.codeotaku.com>
//
#pragma once
#include <cmath>
#include <vector>
#include <map>
#include "ParallelMergeSort.h"
template <typename AnyT>
struct pointer_less_than
{
bool operator()(const AnyT a, const AnyT b) {
return *a < *b;
}
};
namespace DictionarySort
{
// Use std::sort
//const int SORT_MODE = -1;
// Use ParallelMergeSort with 2^n threads
const int SORT_MODE = 3; // = n
typedef std::uint64_t IndexT;
template <typename CharT, typename MapT>
class Dictionary {
public:
typedef std::vector<CharT> WordT;
typedef std::vector<WordT> WordsT;
typedef std::vector<IndexT> OrderT;
static const int ORDERED_LT = -1;
static const int ORDERED_EQ = 0;
static const int ORDERED_GT = 1;
// Compare two order vectors to determine the relative nature of lhs compared to rhs.
// We assume that lhs and rhs have at least one element each.
// ORDERED_LT => (lhs < rhs)
// ORDERED_EQ => (lhs == rhs)
// ORDERED_GT => (lhs > rhs)
static int compare(const OrderT & lhs, const OrderT & rhs)
{
std::size_t offset = 0;
while (offset < lhs.size() && offset < rhs.size()) {
if (lhs[offset] < rhs[offset])
return ORDERED_LT;
else if (lhs[offset] > rhs[offset])
return ORDERED_GT;
offset += 1;
}
if (lhs.size() == rhs.size())
return ORDERED_EQ;
// lhs was longer,
if (offset < lhs.size())
return ORDERED_GT;
return ORDERED_LT;
}
static int compare(Dictionary * dictionary, const WordT & lhs, const WordT & rhs) {
std::size_t offset = 0;
while (offset < lhs.size() && offset < rhs.size()) {
IndexT left_order = dictionary->_characterOrder[lhs[offset]];
IndexT right_order = dictionary->_characterOrder[rhs[offset]];
if (left_order < right_order)
return ORDERED_LT;
else if (left_order > right_order)
return ORDERED_GT;
offset += 1;
}
if (lhs.size() == rhs.size())
return ORDERED_EQ;
if (offset < lhs.size())
return ORDERED_GT;
return ORDERED_LT;
}
private:
WordT _alphabet;
MapT _characterOrder;
//int _characterOrder[256];
//std::map<CharT, IndexT> _characterOrder;
IndexT width;
IndexT characters_per_segment;
// This is a light weight wrapper over WordT which caches its OrderT, an integer representation of position based on the given dictionary.
struct OrderedWord {
WordT word;
// We can generate this as part of the sorting process. Because the sort is parallel, generation of word order (which is relatively expensive) is distributed across multiple processors.
mutable OrderT order;
// The first time this function is called, it must be guaranteed from a single thread.
// After that, it can be called from multiple threads at the same time.
// The parallel merge sort algorithm guarantees this.
const OrderT & fetch_order(Dictionary * dictionary) const {
if (order.size() == 0 && word.size() > 0)
order = dictionary->sum(word);
return order;
}
};
struct CompareWordsAscending {
Dictionary * dictionary;
CompareWordsAscending (Dictionary * _dictionary)
: dictionary(_dictionary)
{
}
bool operator()(const WordT * a, const WordT * b) const {
return compare(dictionary, a, b) == ORDERED_LT;
}
bool operator()(const OrderedWord * a, const OrderedWord * b) const {
return compare(a->fetch_order(dictionary), b->fetch_order(dictionary)) == ORDERED_LT;
}
};
struct UnorderedWord {
WordT word;
Dictionary * dictionary;
UnorderedWord(const WordT & _word, Dictionary * _dictionary)
: word(_word), dictionary(_dictionary) {
}
bool operator<(const UnorderedWord & other) const {
return compare(dictionary, *this, other) == ORDERED_LT;
}
};
public:
Dictionary(WordT alphabet)
: _alphabet(alphabet)
{
IndexT index = 1;
// Build up the character order map
for (typename WordT::iterator i = _alphabet.begin(); i != _alphabet.end(); ++i) {
_characterOrder[*i] = index;
index += 1;
}
width = std::ceil(std::log(alphabet.size()) / std::log(2));
// Naturally floor the result by integer division/truncation.
characters_per_segment = (sizeof(IndexT) * 8) / width;
}
OrderT sum(const WordT & word) {
OrderT order;
std::size_t index = 0;
while (index < word.size()) {
IndexT count = characters_per_segment;
IndexT sum = 0;
while (index < word.size()) {
count -= 1;
sum <<= width;
sum += _characterOrder[word[index]];
index += 1;
if (count == 0)
break;
}
// Shift along any remaining count, since we are ordering using the left most significant character.
sum <<= (count * width);
order.push_back(sum);
}
return order;
}
// The words will be sorted in-place.
template <typename ToSortT>
void sort (ToSortT & words, int mode = 2)
{
CompareWordsAscending comparator(this);
Benchmark::Timer sort_timer;
if (mode == -1) {
// Sort the words using built-in sorting algorithm, for comparison:
std::sort(words.begin(), words.end(), comparator);
} else {
ParallelMergeSort::sort(words, comparator, std::size_t(mode));
}
auto sample = sort_timer.sample();
std::cerr << "--- Completed Dictionary Sort ---" << std::endl;
std::cerr << " * Dictionary sort time: " << sample.wall_time_total << std::endl;
std::cerr << " * Processor sort time: " << sample.processor_time_total << std::endl;
std::cerr << " * Approximate processor usage: " << sample.approximate_processor_usage() << std::endl;
}
// This function can be slow due to the large amount of memory required for large datasets.
uint64_t sort(const WordsT & input, WordsT & output)
{
typedef std::vector<OrderedWord*> OrderedWordsT;
// Allocate all words in one go:
OrderedWord * allocation = new OrderedWord[input.size()];
// Copy pointers to intermediate list which will be used for sorting:
OrderedWordsT words(input.size());
// Calculate order vector for each word in preparation for sort.
for (std::size_t i = 0; i < input.size(); i += 1) {
words[i] = &allocation[i];
words[i]->word = input[i];
// We can force generation of the order cache, but performance may be reduced by about 10%.
//words[i]->fetch_order(this);
}
// Change the mode from -1 for std::sort, to 0..n for ParallelMergeSort where 2^n is the number of threads to use.
sort(words, SORT_MODE);
// Prepare container for sorted output:
output.reserve(input.size());
output.resize(0);
uint64_t checksum = 1, offset = 1;
// Copy sorted words to output vector.
for (typename OrderedWordsT::iterator i = words.begin(); i != words.end(); ++i) {
output.push_back((*i)->word);
// Compute a very simple checksum for verifying sorted order.
const OrderT & order = (*i)->fetch_order(this);
for (typename OrderT::const_iterator j = order.begin(); j != order.end(); ++j) {
checksum ^= *j + (offset++ % checksum);
}
}
delete[] allocation;
return checksum;
}
};
}
| [
"[email protected]"
] | |
b3da75f477fe932eeae81db1dd4d2c0c054dab33 | 037faae47a5b22d3e283555e6b5ac2a0197faf18 | /pcsx2v2/windows/libs/pthread.h | e206de0a8cb75d07e4d0d04c15363099822b8df0 | [] | no_license | isabella232/pcsx2-sourceforge | 6e5aac8d0b476601bfc8fa83ded66c1564b8c588 | dbb2c3a010081b105a8cba0c588f1e8f4e4505c6 | refs/heads/master | 2023-03-18T22:23:15.102593 | 2008-11-17T20:10:17 | 2008-11-17T20:10:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 43,167 | h | /* This is an implementation of the threads API of POSIX 1003.1-2001.
*
* --------------------------------------------------------------------------
*
* Pthreads-win32 - POSIX Threads Library for Win32
* Copyright(C) 1998 John E. Bossom
* Copyright(C) 1999,2005 Pthreads-win32 contributors
*
* Contact Email: [email protected]
*
* The current list of contributors is contained
* in the file CONTRIBUTORS included with the source
* code distribution. The list can also be seen at the
* following World Wide Web location:
* http://sources.redhat.com/pthreads-win32/contributors.html
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library in the file COPYING.LIB;
* if not, write to the Free Software Foundation, Inc.,
* 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA
*/
#if !defined( PTHREAD_H )
#define PTHREAD_H
/*
* See the README file for an explanation of the pthreads-win32 version
* numbering scheme and how the DLL is named etc.
*/
#define PTW32_VERSION 2,7,0,0
#define PTW32_VERSION_STRING "2, 7, 0, 0\0"
/* There are three implementations of cancel cleanup.
* Note that pthread.h is included in both application
* compilation units and also internally for the library.
* The code here and within the library aims to work
* for all reasonable combinations of environments.
*
* The three implementations are:
*
* WIN32 SEH
* C
* C++
*
* Please note that exiting a push/pop block via
* "return", "exit", "break", or "continue" will
* lead to different behaviour amongst applications
* depending upon whether the library was built
* using SEH, C++, or C. For example, a library built
* with SEH will call the cleanup routine, while both
* C++ and C built versions will not.
*/
/*
* Define defaults for cleanup code.
* Note: Unless the build explicitly defines one of the following, then
* we default to standard C style cleanup. This style uses setjmp/longjmp
* in the cancelation and thread exit implementations and therefore won't
* do stack unwinding if linked to applications that have it (e.g.
* C++ apps). This is currently consistent with most/all commercial Unix
* POSIX threads implementations.
*/
#if !defined( __CLEANUP_SEH ) && !defined( __CLEANUP_CXX ) && !defined( __CLEANUP_C )
# define __CLEANUP_C
#endif
#if defined( __CLEANUP_SEH ) && ( !defined( _MSC_VER ) && !defined(PTW32_RC_MSC))
#error ERROR [__FILE__, line __LINE__]: SEH is not supported for this compiler.
#endif
/*
* Stop here if we are being included by the resource compiler.
*/
#ifndef RC_INVOKED
#undef PTW32_LEVEL
#if defined(_POSIX_SOURCE)
#define PTW32_LEVEL 0
/* Early POSIX */
#endif
#if defined(_POSIX_C_SOURCE) && _POSIX_C_SOURCE >= 199309
#undef PTW32_LEVEL
#define PTW32_LEVEL 1
/* Include 1b, 1c and 1d */
#endif
#if defined(INCLUDE_NP)
#undef PTW32_LEVEL
#define PTW32_LEVEL 2
/* Include Non-Portable extensions */
#endif
#define PTW32_LEVEL_MAX 3
#if !defined(PTW32_LEVEL)
#define PTW32_LEVEL PTW32_LEVEL_MAX
/* Include everything */
#endif
#ifdef _UWIN
# define HAVE_STRUCT_TIMESPEC 1
# define HAVE_SIGNAL_H 1
# undef HAVE_CONFIG_H
# pragma comment(lib, "pthread")
#endif
/*
* -------------------------------------------------------------
*
*
* Module: pthread.h
*
* Purpose:
* Provides an implementation of PThreads based upon the
* standard:
*
* POSIX 1003.1-2001
* and
* The Single Unix Specification version 3
*
* (these two are equivalent)
*
* in order to enhance code portability between Windows,
* various commercial Unix implementations, and Linux.
*
* See the ANNOUNCE file for a full list of conforming
* routines and defined constants, and a list of missing
* routines and constants not defined in this implementation.
*
* Authors:
* There have been many contributors to this library.
* The initial implementation was contributed by
* John Bossom, and several others have provided major
* sections or revisions of parts of the implementation.
* Often significant effort has been contributed to
* find and fix important bugs and other problems to
* improve the reliability of the library, which sometimes
* is not reflected in the amount of code which changed as
* result.
* As much as possible, the contributors are acknowledged
* in the ChangeLog file in the source code distribution
* where their changes are noted in detail.
*
* Contributors are listed in the CONTRIBUTORS file.
*
* As usual, all bouquets go to the contributors, and all
* brickbats go to the project maintainer.
*
* Maintainer:
* The code base for this project is coordinated and
* eventually pre-tested, packaged, and made available by
*
* Ross Johnson <[email protected]>
*
* QA Testers:
* Ultimately, the library is tested in the real world by
* a host of competent and demanding scientists and
* engineers who report bugs and/or provide solutions
* which are then fixed or incorporated into subsequent
* versions of the library. Each time a bug is fixed, a
* test case is written to prove the fix and ensure
* that later changes to the code don't reintroduce the
* same error. The number of test cases is slowly growing
* and therefore so is the code reliability.
*
* Compliance:
* See the file ANNOUNCE for the list of implemented
* and not-implemented routines and defined options.
* Of course, these are all defined is this file as well.
*
* Web site:
* The source code and other information about this library
* are available from
*
* http://sources.redhat.com/pthreads-win32/
*
* -------------------------------------------------------------
*/
/* Try to avoid including windows.h */
#if defined(__MINGW32__) && defined(__cplusplus)
#define PTW32_INCLUDE_WINDOWS_H
#endif
#ifdef PTW32_INCLUDE_WINDOWS_H
#include <windows.h>
#endif
#if defined(_MSC_VER) && _MSC_VER < 1300 || defined(__DMC__)
/*
* VC++6.0 or early compiler's header has no DWORD_PTR type.
*/
typedef unsigned long DWORD_PTR;
#endif
/*
* -----------------
* autoconf switches
* -----------------
*/
#if HAVE_CONFIG_H
#include "config.h"
#endif /* HAVE_CONFIG_H */
#ifndef NEED_FTIME
#include <time.h>
#else /* NEED_FTIME */
/* use native WIN32 time API */
#endif /* NEED_FTIME */
#if HAVE_SIGNAL_H
#include <signal.h>
#endif /* HAVE_SIGNAL_H */
#include <setjmp.h>
#include <limits.h>
/*
* Boolean values to make us independent of system includes.
*/
enum {
PTW32_FALSE = 0,
PTW32_TRUE = (! PTW32_FALSE)
};
/*
* This is a duplicate of what is in the autoconf config.h,
* which is only used when building the pthread-win32 libraries.
*/
#ifndef PTW32_CONFIG_H
# if defined(WINCE)
# define NEED_ERRNO
# define NEED_SEM
# endif
# if defined(_UWIN) || defined(__MINGW32__)
# define HAVE_MODE_T
# endif
#endif
/*
*
*/
#if PTW32_LEVEL >= PTW32_LEVEL_MAX
#ifdef NEED_ERRNO
#include "need_errno.h"
#else
#include <errno.h>
#endif
#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
/*
* Several systems don't define some error numbers.
*/
#ifndef ENOTSUP
# define ENOTSUP 48 /* This is the value in Solaris. */
#endif
#ifndef ETIMEDOUT
# define ETIMEDOUT 10060 /* This is the value in winsock.h. */
#endif
#ifndef ENOSYS
# define ENOSYS 140 /* Semi-arbitrary value */
#endif
#ifndef EDEADLK
# ifdef EDEADLOCK
# define EDEADLK EDEADLOCK
# else
# define EDEADLK 36 /* This is the value in MSVC. */
# endif
#endif
#include <sched.h>
/*
* To avoid including windows.h we define only those things that we
* actually need from it.
*/
#ifndef PTW32_INCLUDE_WINDOWS_H
#ifndef HANDLE
# define PTW32__HANDLE_DEF
# define HANDLE void *
#endif
#ifndef DWORD
# define PTW32__DWORD_DEF
# define DWORD unsigned long
#endif
#endif
#ifndef HAVE_STRUCT_TIMESPEC
#define HAVE_STRUCT_TIMESPEC 1
struct timespec {
long tv_sec;
long tv_nsec;
};
#endif /* HAVE_STRUCT_TIMESPEC */
#ifndef SIG_BLOCK
#define SIG_BLOCK 0
#endif /* SIG_BLOCK */
#ifndef SIG_UNBLOCK
#define SIG_UNBLOCK 1
#endif /* SIG_UNBLOCK */
#ifndef SIG_SETMASK
#define SIG_SETMASK 2
#endif /* SIG_SETMASK */
#ifdef __cplusplus
extern "C"
{
#endif /* __cplusplus */
/*
* -------------------------------------------------------------
*
* POSIX 1003.1-2001 Options
* =========================
*
* Options are normally set in <unistd.h>, which is not provided
* with pthreads-win32.
*
* For conformance with the Single Unix Specification (version 3), all of the
* options below are defined, and have a value of either -1 (not supported)
* or 200112L (supported).
*
* These options can neither be left undefined nor have a value of 0, because
* either indicates that sysconf(), which is not implemented, may be used at
* runtime to check the status of the option.
*
* _POSIX_THREADS (== 200112L)
* If == 200112L, you can use threads
*
* _POSIX_THREAD_ATTR_STACKSIZE (== 200112L)
* If == 200112L, you can control the size of a thread's
* stack
* pthread_attr_getstacksize
* pthread_attr_setstacksize
*
* _POSIX_THREAD_ATTR_STACKADDR (== -1)
* If == 200112L, you can allocate and control a thread's
* stack. If not supported, the following functions
* will return ENOSYS, indicating they are not
* supported:
* pthread_attr_getstackaddr
* pthread_attr_setstackaddr
*
* _POSIX_THREAD_PRIORITY_SCHEDULING (== -1)
* If == 200112L, you can use realtime scheduling.
* This option indicates that the behaviour of some
* implemented functions conforms to the additional TPS
* requirements in the standard. E.g. rwlocks favour
* writers over readers when threads have equal priority.
*
* _POSIX_THREAD_PRIO_INHERIT (== -1)
* If == 200112L, you can create priority inheritance
* mutexes.
* pthread_mutexattr_getprotocol +
* pthread_mutexattr_setprotocol +
*
* _POSIX_THREAD_PRIO_PROTECT (== -1)
* If == 200112L, you can create priority ceiling mutexes
* Indicates the availability of:
* pthread_mutex_getprioceiling
* pthread_mutex_setprioceiling
* pthread_mutexattr_getprioceiling
* pthread_mutexattr_getprotocol +
* pthread_mutexattr_setprioceiling
* pthread_mutexattr_setprotocol +
*
* _POSIX_THREAD_PROCESS_SHARED (== -1)
* If set, you can create mutexes and condition
* variables that can be shared with another
* process.If set, indicates the availability
* of:
* pthread_mutexattr_getpshared
* pthread_mutexattr_setpshared
* pthread_condattr_getpshared
* pthread_condattr_setpshared
*
* _POSIX_THREAD_SAFE_FUNCTIONS (== 200112L)
* If == 200112L you can use the special *_r library
* functions that provide thread-safe behaviour
*
* _POSIX_READER_WRITER_LOCKS (== 200112L)
* If == 200112L, you can use read/write locks
*
* _POSIX_SPIN_LOCKS (== 200112L)
* If == 200112L, you can use spin locks
*
* _POSIX_BARRIERS (== 200112L)
* If == 200112L, you can use barriers
*
* + These functions provide both 'inherit' and/or
* 'protect' protocol, based upon these macro
* settings.
*
* -------------------------------------------------------------
*/
/*
* POSIX Options
*/
#undef _POSIX_THREADS
#define _POSIX_THREADS 200112L
#undef _POSIX_READER_WRITER_LOCKS
#define _POSIX_READER_WRITER_LOCKS 200112L
#undef _POSIX_SPIN_LOCKS
#define _POSIX_SPIN_LOCKS 200112L
#undef _POSIX_BARRIERS
#define _POSIX_BARRIERS 200112L
#undef _POSIX_THREAD_SAFE_FUNCTIONS
#define _POSIX_THREAD_SAFE_FUNCTIONS 200112L
#undef _POSIX_THREAD_ATTR_STACKSIZE
#define _POSIX_THREAD_ATTR_STACKSIZE 200112L
/*
* The following options are not supported
*/
#undef _POSIX_THREAD_ATTR_STACKADDR
#define _POSIX_THREAD_ATTR_STACKADDR -1
#undef _POSIX_THREAD_PRIO_INHERIT
#define _POSIX_THREAD_PRIO_INHERIT -1
#undef _POSIX_THREAD_PRIO_PROTECT
#define _POSIX_THREAD_PRIO_PROTECT -1
/* TPS is not fully supported. */
#undef _POSIX_THREAD_PRIORITY_SCHEDULING
#define _POSIX_THREAD_PRIORITY_SCHEDULING -1
#undef _POSIX_THREAD_PROCESS_SHARED
#define _POSIX_THREAD_PROCESS_SHARED -1
/*
* POSIX 1003.1-2001 Limits
* ===========================
*
* These limits are normally set in <limits.h>, which is not provided with
* pthreads-win32.
*
* PTHREAD_DESTRUCTOR_ITERATIONS
* Maximum number of attempts to destroy
* a thread's thread-specific data on
* termination (must be at least 4)
*
* PTHREAD_KEYS_MAX
* Maximum number of thread-specific data keys
* available per process (must be at least 128)
*
* PTHREAD_STACK_MIN
* Minimum supported stack size for a thread
*
* PTHREAD_THREADS_MAX
* Maximum number of threads supported per
* process (must be at least 64).
*
* SEM_NSEMS_MAX
* The maximum number of semaphores a process can have.
* (must be at least 256)
*
* SEM_VALUE_MAX
* The maximum value a semaphore can have.
* (must be at least 32767)
*
*/
#undef _POSIX_THREAD_DESTRUCTOR_ITERATIONS
#define _POSIX_THREAD_DESTRUCTOR_ITERATIONS 4
#undef PTHREAD_DESTRUCTOR_ITERATIONS
#define PTHREAD_DESTRUCTOR_ITERATIONS _POSIX_THREAD_DESTRUCTOR_ITERATIONS
#undef _POSIX_THREAD_KEYS_MAX
#define _POSIX_THREAD_KEYS_MAX 128
#undef PTHREAD_KEYS_MAX
#define PTHREAD_KEYS_MAX _POSIX_THREAD_KEYS_MAX
#undef PTHREAD_STACK_MIN
#define PTHREAD_STACK_MIN 0
#undef _POSIX_THREAD_THREADS_MAX
#define _POSIX_THREAD_THREADS_MAX 64
/* Arbitrary value */
#undef PTHREAD_THREADS_MAX
#define PTHREAD_THREADS_MAX 2019
#undef _POSIX_SEM_NSEMS_MAX
#define _POSIX_SEM_NSEMS_MAX 256
/* Arbitrary value */
#undef SEM_NSEMS_MAX
#define SEM_NSEMS_MAX 1024
#undef _POSIX_SEM_VALUE_MAX
#define _POSIX_SEM_VALUE_MAX 32767
#undef SEM_VALUE_MAX
#define SEM_VALUE_MAX INT_MAX
#if __GNUC__ && ! defined (__declspec)
# error Please upgrade your GNU compiler to one that supports __declspec.
#endif
/*
* When building the DLL code, you should define PTW32_BUILD so that
* the variables/functions are exported correctly. When using the DLL,
* do NOT define PTW32_BUILD, and then the variables/functions will
* be imported correctly.
*/
#ifndef PTW32_STATIC_LIB
# ifdef PTW32_BUILD
# define PTW32_DLLPORT __declspec (dllexport)
# else
# define PTW32_DLLPORT __declspec (dllimport)
# endif
#else
# define PTW32_DLLPORT
#endif
/*
* The Open Watcom C/C++ compiler uses a non-standard calling convention
* that passes function args in registers unless __cdecl is explicitly specified
* in exposed function prototypes.
*
* We force all calls to cdecl even though this could slow Watcom code down
* slightly. If you know that the Watcom compiler will be used to build both
* the DLL and application, then you can probably define this as a null string.
* Remember that pthread.h (this file) is used for both the DLL and application builds.
*/
#define PTW32_CDECL __cdecl
#if defined(_UWIN) && PTW32_LEVEL >= PTW32_LEVEL_MAX
# include <sys/types.h>
#else
/*
* Generic handle type - intended to extend uniqueness beyond
* that available with a simple pointer. It should scale for either
* IA-32 or IA-64.
*/
typedef struct {
void * p; /* Pointer to actual object */
unsigned int x; /* Extra information - reuse count etc */
} ptw32_handle_t;
typedef ptw32_handle_t pthread_t;
typedef struct pthread_attr_t_ * pthread_attr_t;
typedef struct pthread_once_t_ pthread_once_t;
typedef struct pthread_key_t_ * pthread_key_t;
typedef struct pthread_mutex_t_ * pthread_mutex_t;
typedef struct pthread_mutexattr_t_ * pthread_mutexattr_t;
typedef struct pthread_cond_t_ * pthread_cond_t;
typedef struct pthread_condattr_t_ * pthread_condattr_t;
#endif
typedef struct pthread_rwlock_t_ * pthread_rwlock_t;
typedef struct pthread_rwlockattr_t_ * pthread_rwlockattr_t;
typedef struct pthread_spinlock_t_ * pthread_spinlock_t;
typedef struct pthread_barrier_t_ * pthread_barrier_t;
typedef struct pthread_barrierattr_t_ * pthread_barrierattr_t;
/*
* ====================
* ====================
* POSIX Threads
* ====================
* ====================
*/
enum {
/*
* pthread_attr_{get,set}detachstate
*/
PTHREAD_CREATE_JOINABLE = 0, /* Default */
PTHREAD_CREATE_DETACHED = 1,
/*
* pthread_attr_{get,set}inheritsched
*/
PTHREAD_INHERIT_SCHED = 0,
PTHREAD_EXPLICIT_SCHED = 1, /* Default */
/*
* pthread_{get,set}scope
*/
PTHREAD_SCOPE_PROCESS = 0,
PTHREAD_SCOPE_SYSTEM = 1, /* Default */
/*
* pthread_setcancelstate paramters
*/
PTHREAD_CANCEL_ENABLE = 0, /* Default */
PTHREAD_CANCEL_DISABLE = 1,
/*
* pthread_setcanceltype parameters
*/
PTHREAD_CANCEL_ASYNCHRONOUS = 0,
PTHREAD_CANCEL_DEFERRED = 1, /* Default */
/*
* pthread_mutexattr_{get,set}pshared
* pthread_condattr_{get,set}pshared
*/
PTHREAD_PROCESS_PRIVATE = 0,
PTHREAD_PROCESS_SHARED = 1,
/*
* pthread_barrier_wait
*/
PTHREAD_BARRIER_SERIAL_THREAD = -1
};
/*
* ====================
* ====================
* Cancelation
* ====================
* ====================
*/
#define PTHREAD_CANCELED ((void *) -1)
/*
* ====================
* ====================
* Once Key
* ====================
* ====================
*/
#define PTHREAD_ONCE_INIT { PTW32_FALSE, 0, 0, 0}
struct pthread_once_t_
{
int done; /* indicates if user function has been executed */
void * lock;
int reserved1;
int reserved2;
};
/*
* ====================
* ====================
* Object initialisers
* ====================
* ====================
*/
#define PTHREAD_MUTEX_INITIALIZER ((pthread_mutex_t) -1)
#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER ((pthread_mutex_t) -2)
#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER ((pthread_mutex_t) -3)
/*
* Compatibility with LinuxThreads
*/
#define PTHREAD_RECURSIVE_MUTEX_INITIALIZER_NP PTHREAD_RECURSIVE_MUTEX_INITIALIZER
#define PTHREAD_ERRORCHECK_MUTEX_INITIALIZER_NP PTHREAD_ERRORCHECK_MUTEX_INITIALIZER
#define PTHREAD_COND_INITIALIZER ((pthread_cond_t) -1)
#define PTHREAD_RWLOCK_INITIALIZER ((pthread_rwlock_t) -1)
#define PTHREAD_SPINLOCK_INITIALIZER ((pthread_spinlock_t) -1)
/*
* Mutex types.
*/
enum
{
/* Compatibility with LinuxThreads */
PTHREAD_MUTEX_FAST_NP,
PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_TIMED_NP = PTHREAD_MUTEX_FAST_NP,
PTHREAD_MUTEX_ADAPTIVE_NP = PTHREAD_MUTEX_FAST_NP,
/* For compatibility with POSIX */
PTHREAD_MUTEX_NORMAL = PTHREAD_MUTEX_FAST_NP,
PTHREAD_MUTEX_RECURSIVE = PTHREAD_MUTEX_RECURSIVE_NP,
PTHREAD_MUTEX_ERRORCHECK = PTHREAD_MUTEX_ERRORCHECK_NP,
PTHREAD_MUTEX_DEFAULT = PTHREAD_MUTEX_NORMAL
};
typedef struct ptw32_cleanup_t ptw32_cleanup_t;
#if defined(_MSC_VER)
/* Disable MSVC 'anachronism used' warning */
#pragma warning( disable : 4229 )
#endif
typedef void (* PTW32_CDECL ptw32_cleanup_callback_t)(void *);
#if defined(_MSC_VER)
#pragma warning( default : 4229 )
#endif
struct ptw32_cleanup_t
{
ptw32_cleanup_callback_t routine;
void *arg;
struct ptw32_cleanup_t *prev;
};
#ifdef __CLEANUP_SEH
/*
* WIN32 SEH version of cancel cleanup.
*/
#define pthread_cleanup_push( _rout, _arg ) \
{ \
ptw32_cleanup_t _cleanup; \
\
_cleanup.routine = (ptw32_cleanup_callback_t)(_rout); \
_cleanup.arg = (_arg); \
__try \
{ \
#define pthread_cleanup_pop( _execute ) \
} \
__finally \
{ \
if( _execute || AbnormalTermination()) \
{ \
(*(_cleanup.routine))( _cleanup.arg ); \
} \
} \
}
#else /* __CLEANUP_SEH */
#ifdef __CLEANUP_C
/*
* C implementation of PThreads cancel cleanup
*/
#define pthread_cleanup_push( _rout, _arg ) \
{ \
ptw32_cleanup_t _cleanup; \
\
ptw32_push_cleanup( &_cleanup, (ptw32_cleanup_callback_t) (_rout), (_arg) ); \
#define pthread_cleanup_pop( _execute ) \
(void) ptw32_pop_cleanup( _execute ); \
}
#else /* __CLEANUP_C */
#ifdef __CLEANUP_CXX
/*
* C++ version of cancel cleanup.
* - John E. Bossom.
*/
class PThreadCleanup {
/*
* PThreadCleanup
*
* Purpose
* This class is a C++ helper class that is
* used to implement pthread_cleanup_push/
* pthread_cleanup_pop.
* The destructor of this class automatically
* pops the pushed cleanup routine regardless
* of how the code exits the scope
* (i.e. such as by an exception)
*/
ptw32_cleanup_callback_t cleanUpRout;
void * obj;
int executeIt;
public:
PThreadCleanup() :
cleanUpRout( 0 ),
obj( 0 ),
executeIt( 0 )
/*
* No cleanup performed
*/
{
}
PThreadCleanup(
ptw32_cleanup_callback_t routine,
void * arg ) :
cleanUpRout( routine ),
obj( arg ),
executeIt( 1 )
/*
* Registers a cleanup routine for 'arg'
*/
{
}
~PThreadCleanup()
{
if ( executeIt && ((void *) cleanUpRout != (void *) 0) )
{
(void) (*cleanUpRout)( obj );
}
}
void execute( int exec )
{
executeIt = exec;
}
};
/*
* C++ implementation of PThreads cancel cleanup;
* This implementation takes advantage of a helper
* class who's destructor automatically calls the
* cleanup routine if we exit our scope weirdly
*/
#define pthread_cleanup_push( _rout, _arg ) \
{ \
PThreadCleanup cleanup((ptw32_cleanup_callback_t)(_rout), \
(void *) (_arg) );
#define pthread_cleanup_pop( _execute ) \
cleanup.execute( _execute ); \
}
#else
#error ERROR [__FILE__, line __LINE__]: Cleanup type undefined.
#endif /* __CLEANUP_CXX */
#endif /* __CLEANUP_C */
#endif /* __CLEANUP_SEH */
/*
* ===============
* ===============
* Methods
* ===============
* ===============
*/
/*
* PThread Attribute Functions
*/
PTW32_DLLPORT int PTW32_CDECL pthread_attr_init (pthread_attr_t * attr);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_destroy (pthread_attr_t * attr);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_getdetachstate (const pthread_attr_t * attr,
int *detachstate);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_getstackaddr (const pthread_attr_t * attr,
void **stackaddr);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_getstacksize (const pthread_attr_t * attr,
size_t * stacksize);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_setdetachstate (pthread_attr_t * attr,
int detachstate);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_setstackaddr (pthread_attr_t * attr,
void *stackaddr);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_setstacksize (pthread_attr_t * attr,
size_t stacksize);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_getschedparam (const pthread_attr_t *attr,
struct sched_param *param);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_setschedparam (pthread_attr_t *attr,
const struct sched_param *param);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_setschedpolicy (pthread_attr_t *,
int);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_getschedpolicy (pthread_attr_t *,
int *);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_setinheritsched(pthread_attr_t * attr,
int inheritsched);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_getinheritsched(pthread_attr_t * attr,
int * inheritsched);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_setscope (pthread_attr_t *,
int);
PTW32_DLLPORT int PTW32_CDECL pthread_attr_getscope (const pthread_attr_t *,
int *);
/*
* PThread Functions
*/
PTW32_DLLPORT int PTW32_CDECL pthread_create (pthread_t * tid,
const pthread_attr_t * attr,
void *(*start) (void *),
void *arg);
PTW32_DLLPORT int PTW32_CDECL pthread_detach (pthread_t tid);
PTW32_DLLPORT int PTW32_CDECL pthread_equal (pthread_t t1,
pthread_t t2);
PTW32_DLLPORT void PTW32_CDECL pthread_exit (void *value_ptr);
PTW32_DLLPORT int PTW32_CDECL pthread_join (pthread_t thread,
void **value_ptr);
PTW32_DLLPORT pthread_t PTW32_CDECL pthread_self (void);
PTW32_DLLPORT int PTW32_CDECL pthread_cancel (pthread_t thread);
PTW32_DLLPORT int PTW32_CDECL pthread_setcancelstate (int state,
int *oldstate);
PTW32_DLLPORT int PTW32_CDECL pthread_setcanceltype (int type,
int *oldtype);
PTW32_DLLPORT void PTW32_CDECL pthread_testcancel (void);
PTW32_DLLPORT int PTW32_CDECL pthread_once (pthread_once_t * once_control,
void (*init_routine) (void));
#if PTW32_LEVEL >= PTW32_LEVEL_MAX
PTW32_DLLPORT ptw32_cleanup_t * PTW32_CDECL ptw32_pop_cleanup (int execute);
PTW32_DLLPORT void PTW32_CDECL ptw32_push_cleanup (ptw32_cleanup_t * cleanup,
void (*routine) (void *),
void *arg);
#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
/*
* Thread Specific Data Functions
*/
PTW32_DLLPORT int PTW32_CDECL pthread_key_create (pthread_key_t * key,
void (*destructor) (void *));
PTW32_DLLPORT int PTW32_CDECL pthread_key_delete (pthread_key_t key);
PTW32_DLLPORT int PTW32_CDECL pthread_setspecific (pthread_key_t key,
const void *value);
PTW32_DLLPORT void * PTW32_CDECL pthread_getspecific (pthread_key_t key);
/*
* Mutex Attribute Functions
*/
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_init (pthread_mutexattr_t * attr);
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_destroy (pthread_mutexattr_t * attr);
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getpshared (const pthread_mutexattr_t
* attr,
int *pshared);
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setpshared (pthread_mutexattr_t * attr,
int pshared);
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_settype (pthread_mutexattr_t * attr, int kind);
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_gettype (pthread_mutexattr_t * attr, int *kind);
/*
* Barrier Attribute Functions
*/
PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_init (pthread_barrierattr_t * attr);
PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_destroy (pthread_barrierattr_t * attr);
PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_getpshared (const pthread_barrierattr_t
* attr,
int *pshared);
PTW32_DLLPORT int PTW32_CDECL pthread_barrierattr_setpshared (pthread_barrierattr_t * attr,
int pshared);
/*
* Mutex Functions
*/
PTW32_DLLPORT int PTW32_CDECL pthread_mutex_init (pthread_mutex_t * mutex,
const pthread_mutexattr_t * attr);
PTW32_DLLPORT int PTW32_CDECL pthread_mutex_destroy (pthread_mutex_t * mutex);
PTW32_DLLPORT int PTW32_CDECL pthread_mutex_lock (pthread_mutex_t * mutex);
PTW32_DLLPORT int PTW32_CDECL pthread_mutex_timedlock(pthread_mutex_t *mutex,
const struct timespec *abstime);
PTW32_DLLPORT int PTW32_CDECL pthread_mutex_trylock (pthread_mutex_t * mutex);
PTW32_DLLPORT int PTW32_CDECL pthread_mutex_unlock (pthread_mutex_t * mutex);
/*
* Spinlock Functions
*/
PTW32_DLLPORT int PTW32_CDECL pthread_spin_init (pthread_spinlock_t * lock, int pshared);
PTW32_DLLPORT int PTW32_CDECL pthread_spin_destroy (pthread_spinlock_t * lock);
PTW32_DLLPORT int PTW32_CDECL pthread_spin_lock (pthread_spinlock_t * lock);
PTW32_DLLPORT int PTW32_CDECL pthread_spin_trylock (pthread_spinlock_t * lock);
PTW32_DLLPORT int PTW32_CDECL pthread_spin_unlock (pthread_spinlock_t * lock);
/*
* Barrier Functions
*/
PTW32_DLLPORT int PTW32_CDECL pthread_barrier_init (pthread_barrier_t * barrier,
const pthread_barrierattr_t * attr,
unsigned int count);
PTW32_DLLPORT int PTW32_CDECL pthread_barrier_destroy (pthread_barrier_t * barrier);
PTW32_DLLPORT int PTW32_CDECL pthread_barrier_wait (pthread_barrier_t * barrier);
/*
* Condition Variable Attribute Functions
*/
PTW32_DLLPORT int PTW32_CDECL pthread_condattr_init (pthread_condattr_t * attr);
PTW32_DLLPORT int PTW32_CDECL pthread_condattr_destroy (pthread_condattr_t * attr);
PTW32_DLLPORT int PTW32_CDECL pthread_condattr_getpshared (const pthread_condattr_t * attr,
int *pshared);
PTW32_DLLPORT int PTW32_CDECL pthread_condattr_setpshared (pthread_condattr_t * attr,
int pshared);
/*
* Condition Variable Functions
*/
PTW32_DLLPORT int PTW32_CDECL pthread_cond_init (pthread_cond_t * cond,
const pthread_condattr_t * attr);
PTW32_DLLPORT int PTW32_CDECL pthread_cond_destroy (pthread_cond_t * cond);
PTW32_DLLPORT int PTW32_CDECL pthread_cond_wait (pthread_cond_t * cond,
pthread_mutex_t * mutex);
PTW32_DLLPORT int PTW32_CDECL pthread_cond_timedwait (pthread_cond_t * cond,
pthread_mutex_t * mutex,
const struct timespec *abstime);
PTW32_DLLPORT int PTW32_CDECL pthread_cond_signal (pthread_cond_t * cond);
PTW32_DLLPORT int PTW32_CDECL pthread_cond_broadcast (pthread_cond_t * cond);
/*
* Scheduling
*/
PTW32_DLLPORT int PTW32_CDECL pthread_setschedparam (pthread_t thread,
int policy,
const struct sched_param *param);
PTW32_DLLPORT int PTW32_CDECL pthread_getschedparam (pthread_t thread,
int *policy,
struct sched_param *param);
PTW32_DLLPORT int PTW32_CDECL pthread_setconcurrency (int);
PTW32_DLLPORT int PTW32_CDECL pthread_getconcurrency (void);
/*
* Read-Write Lock Functions
*/
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_init(pthread_rwlock_t *lock,
const pthread_rwlockattr_t *attr);
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_destroy(pthread_rwlock_t *lock);
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_tryrdlock(pthread_rwlock_t *);
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_trywrlock(pthread_rwlock_t *);
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_rdlock(pthread_rwlock_t *lock);
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_timedrdlock(pthread_rwlock_t *lock,
const struct timespec *abstime);
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_wrlock(pthread_rwlock_t *lock);
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_timedwrlock(pthread_rwlock_t *lock,
const struct timespec *abstime);
PTW32_DLLPORT int PTW32_CDECL pthread_rwlock_unlock(pthread_rwlock_t *lock);
PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_init (pthread_rwlockattr_t * attr);
PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_destroy (pthread_rwlockattr_t * attr);
PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_getpshared (const pthread_rwlockattr_t * attr,
int *pshared);
PTW32_DLLPORT int PTW32_CDECL pthread_rwlockattr_setpshared (pthread_rwlockattr_t * attr,
int pshared);
#if PTW32_LEVEL >= PTW32_LEVEL_MAX - 1
/*
* Signal Functions. Should be defined in <signal.h> but MSVC and MinGW32
* already have signal.h that don't define these.
*/
PTW32_DLLPORT int PTW32_CDECL pthread_kill(pthread_t thread, int sig);
/*
* Non-portable functions
*/
/*
* Compatibility with Linux.
*/
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_setkind_np(pthread_mutexattr_t * attr,
int kind);
PTW32_DLLPORT int PTW32_CDECL pthread_mutexattr_getkind_np(pthread_mutexattr_t * attr,
int *kind);
/*
* Possibly supported by other POSIX threads implementations
*/
PTW32_DLLPORT int PTW32_CDECL pthread_delay_np (struct timespec * interval);
PTW32_DLLPORT int PTW32_CDECL pthread_num_processors_np(void);
/*
* Useful if an application wants to statically link
* the lib rather than load the DLL at run-time.
*/
PTW32_DLLPORT int PTW32_CDECL pthread_win32_process_attach_np(void);
PTW32_DLLPORT int PTW32_CDECL pthread_win32_process_detach_np(void);
PTW32_DLLPORT int PTW32_CDECL pthread_win32_thread_attach_np(void);
PTW32_DLLPORT int PTW32_CDECL pthread_win32_thread_detach_np(void);
/*
* Features that are auto-detected at load/run time.
*/
PTW32_DLLPORT int PTW32_CDECL pthread_win32_test_features_np(int);
enum ptw32_features {
PTW32_SYSTEM_INTERLOCKED_COMPARE_EXCHANGE = 0x0001, /* System provides it. */
PTW32_ALERTABLE_ASYNC_CANCEL = 0x0002 /* Can cancel blocked threads. */
};
/*
* Register a system time change with the library.
* Causes the library to perform various functions
* in response to the change. Should be called whenever
* the application's top level window receives a
* WM_TIMECHANGE message. It can be passed directly to
* pthread_create() as a new thread if desired.
*/
PTW32_DLLPORT void * PTW32_CDECL pthread_timechange_handler_np(void *);
#endif /*PTW32_LEVEL >= PTW32_LEVEL_MAX - 1 */
#if PTW32_LEVEL >= PTW32_LEVEL_MAX
/*
* Returns the Win32 HANDLE for the POSIX thread.
*/
PTW32_DLLPORT HANDLE PTW32_CDECL pthread_getw32threadhandle_np(pthread_t thread);
/*
* Protected Methods
*
* This function blocks until the given WIN32 handle
* is signaled or pthread_cancel had been called.
* This function allows the caller to hook into the
* PThreads cancel mechanism. It is implemented using
*
* WaitForMultipleObjects
*
* on 'waitHandle' and a manually reset WIN32 Event
* used to implement pthread_cancel. The 'timeout'
* argument to TimedWait is simply passed to
* WaitForMultipleObjects.
*/
PTW32_DLLPORT int PTW32_CDECL pthreadCancelableWait (HANDLE waitHandle);
PTW32_DLLPORT int PTW32_CDECL pthreadCancelableTimedWait (HANDLE waitHandle,
DWORD timeout);
#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
/*
* Thread-Safe C Runtime Library Mappings.
*/
#ifndef _UWIN
# if defined(NEED_ERRNO)
PTW32_DLLPORT int * PTW32_CDECL _errno( void );
# else
# ifndef errno
# if (defined(_MT) || defined(_DLL))
__declspec(dllimport) extern int * __cdecl _errno(void);
# define errno (*_errno())
# endif
# endif
# endif
#endif
/*
* WIN32 C runtime library had been made thread-safe
* without affecting the user interface. Provide
* mappings from the UNIX thread-safe versions to
* the standard C runtime library calls.
* Only provide function mappings for functions that
* actually exist on WIN32.
*/
#if !defined(__MINGW32__)
#define strtok_r( _s, _sep, _lasts ) \
( *(_lasts) = strtok( (_s), (_sep) ) )
#endif /* !__MINGW32__ */
#define asctime_r( _tm, _buf ) \
( strcpy( (_buf), asctime( (_tm) ) ), \
(_buf) )
#define ctime_r( _clock, _buf ) \
( strcpy( (_buf), ctime( (_clock) ) ), \
(_buf) )
#define gmtime_r( _clock, _result ) \
( *(_result) = *gmtime( (_clock) ), \
(_result) )
#define localtime_r( _clock, _result ) \
( *(_result) = *localtime( (_clock) ), \
(_result) )
#define rand_r( _seed ) \
( _seed == _seed? rand() : rand() )
/*
* Some compiler environments don't define some things.
*/
#if defined(__BORLANDC__)
# define _ftime ftime
# define _timeb timeb
#endif
#ifdef __cplusplus
/*
* Internal exceptions
*/
class ptw32_exception {};
class ptw32_exception_cancel : public ptw32_exception {};
class ptw32_exception_exit : public ptw32_exception {};
#endif
#if PTW32_LEVEL >= PTW32_LEVEL_MAX
/* FIXME: This is only required if the library was built using SEH */
/*
* Get internal SEH tag
*/
PTW32_DLLPORT DWORD PTW32_CDECL ptw32_get_exception_services_code(void);
#endif /* PTW32_LEVEL >= PTW32_LEVEL_MAX */
#ifndef PTW32_BUILD
#ifdef __CLEANUP_SEH
/*
* Redefine the SEH __except keyword to ensure that applications
* propagate our internal exceptions up to the library's internal handlers.
*/
#define __except( E ) \
__except( ( GetExceptionCode() == ptw32_get_exception_services_code() ) \
? EXCEPTION_CONTINUE_SEARCH : ( E ) )
#endif /* __CLEANUP_SEH */
#ifdef __CLEANUP_CXX
/*
* Redefine the C++ catch keyword to ensure that applications
* propagate our internal exceptions up to the library's internal handlers.
*/
#ifdef _MSC_VER
/*
* WARNING: Replace any 'catch( ... )' with 'PtW32CatchAll'
* if you want Pthread-Win32 cancelation and pthread_exit to work.
*/
#ifndef PtW32NoCatchWarn
#pragma message("Specify \"/DPtW32NoCatchWarn\" compiler flag to skip this message.")
#pragma message("------------------------------------------------------------------")
#pragma message("When compiling applications with MSVC++ and C++ exception handling:")
#pragma message(" Replace any 'catch( ... )' in routines called from POSIX threads")
#pragma message(" with 'PtW32CatchAll' or 'CATCHALL' if you want POSIX thread")
#pragma message(" cancelation and pthread_exit to work. For example:")
#pragma message("")
#pragma message(" #ifdef PtW32CatchAll")
#pragma message(" PtW32CatchAll")
#pragma message(" #else")
#pragma message(" catch(...)")
#pragma message(" #endif")
#pragma message(" {")
#pragma message(" /* Catchall block processing */")
#pragma message(" }")
#pragma message("------------------------------------------------------------------")
#endif
#define PtW32CatchAll \
catch( ptw32_exception & ) { throw; } \
catch( ... )
#else /* _MSC_VER */
#define catch( E ) \
catch( ptw32_exception & ) { throw; } \
catch( E )
#endif /* _MSC_VER */
#endif /* __CLEANUP_CXX */
#endif /* ! PTW32_BUILD */
#ifdef __cplusplus
} /* End of extern "C" */
#endif /* __cplusplus */
#ifdef PTW32__HANDLE_DEF
# undef HANDLE
#endif
#ifdef PTW32__DWORD_DEF
# undef DWORD
#endif
#undef PTW32_LEVEL
#undef PTW32_LEVEL_MAX
#endif /* ! RC_INVOKED */
#endif /* PTHREAD_H */
| [
"saqibakhtar@23c756db-88ba-2448-99d7-e6e4c676ec84"
] | saqibakhtar@23c756db-88ba-2448-99d7-e6e4c676ec84 |
6dbad17607c0b5dc3b9e390aa36e6fad9b77882b | 147758ad82e87dccb0afcd6249751813fe91521c | /inOrder_preOrder_postOrder.cpp | 636fc9aced86627ef772b3c96fbdb7f7cd3a255f | [] | no_license | zetarop/Binary-Tree | f1791c94ac231faceec5c01ab6b0496ea523af53 | ee02cce79e8cf616dedf3b17aa14ed5385248d46 | refs/heads/master | 2020-04-02T20:49:51.844920 | 2018-10-26T06:10:30 | 2018-10-26T06:10:30 | 154,780,491 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,149 | cpp | #include<bits/stdc++.h>
#define ve vector
#define pb push_back
#define ll long long
using namespace std;
class node
{
public:
int val;
node* l;
node* r;
};
node* newNode(int n)
{
node* temp = new node;
temp->val=n;
temp->l=NULL;
temp->r=NULL;
return temp;
}
node* insert(node* root, int n)
{
if(root == NULL)
return newNode(n);
if(n <= root->val)
root->l = insert(root->l, n);
else
root->r = insert(root->r, n);
}
void inOrder(node* root)
{
if(root->l != NULL)
inOrder(root->l);
cout<<root->val<<" ";
if(root->r != NULL)
inOrder(root->r);
}
void preOrder(node* root)
{
cout<<root->val<<" ";
if(root->l != NULL)
inOrder(root->l);
if(root->r != NULL)
inOrder(root->r);
}
void postOrder(node* root)
{
if(root->l != NULL)
inOrder(root->l);
if(root->r != NULL)
inOrder(root->r);
cout<<root->val<<" ";
}
int main()
{
node* root=NULL;
ve<int> v{50,40,60,30,45,55,70,20,35,48,65,80,10,25,33,38,75,90,71,85,100,78};
for(auto a:v)
root = insert(root,a);
cout<<"inOrder: "; inOrder(root); cout<<endl;
cout<<"preOrder: "; preOrder(root); cout<<endl;
cout<<"postOrder: "; postOrder(root); cout<<endl;
}
| [
"[email protected]"
] | |
e3a2f7948f30e30a0c4ad979ce25beebd6b29ad2 | 323788cf746237167c70f38117d3fbd26e92c041 | /sandbox/korbinian/src/nnet/nnet-loss-prior.h | e9e054f5b56109b7093c15dcb4515a17a5b6dbc0 | [
"Apache-2.0",
"LicenseRef-scancode-public-domain"
] | permissive | zweiein/kaldi | 3cfc5d1fc66c1ca32c74f71171d4af2e2512f15c | 708448c693272af0d68c8e178c7b4ff836125acf | refs/heads/master | 2020-12-26T00:45:36.907011 | 2015-10-23T21:17:02 | 2015-10-23T21:17:02 | 46,313,562 | 0 | 1 | null | 2015-11-17T00:57:57 | 2015-11-17T00:57:57 | null | UTF-8 | C++ | false | false | 2,429 | h | // nnet/nnet-loss-prior.h
// Copyright 2012 Karel Vesely
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// THIS CODE IS PROVIDED *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
// KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
// WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
// MERCHANTABLITY OR NON-INFRINGEMENT.
// See the Apache 2 License for the specific language governing permissions and
// limitations under the License.
#ifndef KALDI_NNET_NNET_LOSS_PRIOR_H_
#define KALDI_NNET_NNET_LOSS_PRIOR_H_
#include "base/kaldi-common.h"
#include "cudamatrix/cu-matrix.h"
#include "cudamatrix/cu-vector.h"
#include "cudamatrix/cu-stlvector.h"
namespace kaldi {
namespace nnet1 {
class XentPrior {
public:
XentPrior()
: loss_(0.0), frames_(0), correct_(0),
loss_nosil_(0.0), frames_nosil_(0), correct_nosil_(0),
loss_scaled_(0.0), frames_scaled_(0.0), correct_scaled_(0.0),
loss_scaled_nosil_(0.0), frames_scaled_nosil_(0.0), correct_scaled_nosil_(0.0),
sil_pdfs_(-1)
{ }
~XentPrior() { }
/// Evaluate cross entropy from soft labels
void EvalVec(const CuMatrix<BaseFloat> &net_out, const std::vector<int32> &target,
CuMatrix<BaseFloat> *diff);
/// Read the prior values
void ReadPriors(std::string prior_rxfile, BaseFloat U = 1.0, BaseFloat S = 1.0, int32 num_S = 5);
/// Generate string with error report
std::string Report();
private:
//raw loss
double loss_;
int32 frames_;
int32 correct_;
//raw loss with sil excluded
double loss_nosil_;
int32 frames_nosil_;
int32 correct_nosil_;
//inv-prior scaled loss
double loss_scaled_;
double frames_scaled_;
double correct_scaled_;
//inv-prior scaled loss with sil excluded
double loss_scaled_nosil_;
double frames_scaled_nosil_;
double correct_scaled_nosil_;
CuStlVector<int32> max_id_;
std::vector<int32> max_id_host_;
CuStlVector<int32> target_device_;
CuVector<BaseFloat> log_post_tgt_;
Vector<BaseFloat> log_post_tgt_host_;
/// Number of sil-model PDFs in the front
int32 sil_pdfs_;
/// Inv-priors to rescale the errors
Vector<BaseFloat> inv_priors_;
};
} // namespace nnet1
} // namespace kaldi
#endif
| [
"sikoried@5e6a8d80-dfce-4ca6-a32a-6e07a63d50c8"
] | sikoried@5e6a8d80-dfce-4ca6-a32a-6e07a63d50c8 |
d1b38bbb36dfebc650060d8d39a7bc451d699929 | b62643255e79ff9ea2893a8d9a2384cd3ee918fa | /吉田学園情報ビジネス専門学校_後藤慎之助/C++/チーム/5作目_3D_God League/01_開発環境/GodLeague/tcp_client.cpp | faabca7609938118218b3862887b43148804e4e4 | [] | no_license | ShinnosukeGoto/Shinnosuke_Game | ed8c0ad0e0466eabda683d702a81a9229d1170a9 | e45460185325fcf099abc848cb4a11358d1d6f38 | refs/heads/master | 2023-02-21T03:34:16.338821 | 2021-01-20T14:57:54 | 2021-01-20T14:57:54 | 305,346,425 | 0 | 1 | null | 2022-09-07T09:44:05 | 2020-10-19T10:27:56 | C++ | SHIFT_JIS | C++ | false | false | 3,788 | cpp | //------------------------------------------------------------
//TCP通信処理のクラス化
//Author : 伊藤 大輝
//------------------------------------------------------------
#define _CRT_SECURE_NO_WARNINGS //scanfの警告抑制用
#define _WINSOCK_DEPRECATED_NO_WARNINGS
#include "main.h"
#include <stdio.h>
#include "tcp_client.h"
//------------------------------------------------------------
// TCP通信処理クラスのインスタンス生成
// pHostName : IPアドレス
// nPortNum : ポート番号
//------------------------------------------------------------
CTcpClient * CTcpClient::Create(const char*pHostName, int nPortNum)
{
//インスタンス生成
CTcpClient * pTcpClient = new CTcpClient;
if (pTcpClient->Init(pHostName, nPortNum) == false)
{
delete pTcpClient;
pTcpClient = NULL;
}
return pTcpClient;
}
//------------------------------------------------------------
//TCP通信処理クラスのコンストラクタ
//------------------------------------------------------------
CTcpClient::CTcpClient()
{
m_sock = -1;
}
//------------------------------------------------------------
//TCP通信処理クラスのデストラクタ
//------------------------------------------------------------
CTcpClient::~CTcpClient()
{
}
//------------------------------------------------------------
//TCP通信処理クラスの初期化処理
//pHostName : 接続先のIPアドレス
//nPortNum : 接続先のポート番号
//------------------------------------------------------------
bool CTcpClient::Init(const char *pHostName, int nPortNum)
{
//ソケット生成
m_sock = socket(AF_INET, SOCK_STREAM, 0);
if (m_sock == INVALID_SOCKET)
{
return 1;
}
//接続情報の設定
struct sockaddr_in addr;
addr.sin_family = AF_INET; //IPv4 192.168.11.1
addr.sin_port = htons(nPortNum); //ポート番号 1024〜65535 80番 HTTP
addr.sin_addr.S_un.S_addr = inet_addr(pHostName);
//接続
if (connect(m_sock, (struct sockaddr*)&addr, sizeof(addr)) != 0)
{
//接続切断
return false;
}
return true;
}
//------------------------------------------------------------
//TCP通信処理クラスの送信処理
//pSendData : 送信したデータ
//nSendDataSize : 送信したデータサイズ
//------------------------------------------------------------
int CTcpClient::Send(char *pSendData, int nSendDataSize)
{
if (m_sock < 0)
{
//ソケットが開いていない場合の送信処理用
return 0;
}
int nSendSize = send(m_sock, pSendData, nSendDataSize, 0);
return nSendSize;
}
//------------------------------------------------------------
//TCP通信処理クラスの受信処理
//pRecvBuf : 受信するデータ
//pRecvBufSize : 受信するデータサイズ
//------------------------------------------------------------
int CTcpClient::Recv(char *pRecvBuf, int nRecvBufSize)
{
if (m_sock < 0)
{
//ソケットが開いていない場合の受信処理用
return 0;
}
int nRecvSize = recv(m_sock, pRecvBuf, nRecvBufSize, 0);
if (nRecvSize <= 0)
{
Close();
}
return nRecvSize;
}
//------------------------------------------------------------
//TCP通信処理クラスの切断処理
//------------------------------------------------------------
void CTcpClient::Close()
{
if (m_sock < 0)
{
//使われていないソケットをクローズしないために
return;
}
closesocket(m_sock);
m_sock = -1;
}
//------------------------------------------------------------
//TCP通信処理クラスの開放処理
//------------------------------------------------------------
void CTcpClient::Release()
{
Close();
delete this;
} | [
"[email protected]"
] | |
09fd3a20e0db5256957097a75bba283c169e3f51 | 83ff3d8d93a4f001bb659ce9e39e4bb990aa8986 | /INHERITANCE/q1.cpp | 8c2a1f4c4605f751ef9a07a36be2549e8a3cb197 | [] | no_license | SwapnilMadaan/Subject-Wise-Programs | ae9d81a9e36c9be4b609b60c4e33f1c31370ea8c | 8b37304514f02d1042678b7ec8f2ef6d3e9bcd47 | refs/heads/master | 2020-05-19T02:24:56.523486 | 2019-05-03T13:53:18 | 2019-05-03T13:53:18 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 492 | cpp | #include <iostream>
using namespace std;
// Base class
class Shape {
public:
void setWidth(int w) {
width = w;
}
void setHeight(int h) {
height = h;
}
protected:
int width;
int height;
};
// Derived class
class Rectangle: public Shape {
public:
int getArea() {
return (width * height);
}
};
int main(void) {
Rectangle Rect;
Rect.setWidth(5);
Rect.setHeight(7);
// Print the area of the object.
cout << "Total area: " << Rect.getArea() << endl;
return 0;
}
| [
"[email protected]"
] | |
9f121470b3e9f94f3c882f4af0508329587c005b | 602edda30715d8878b46c82743064fb453891b18 | /forcecrash/maindlg.cpp | 4b64c5985022393b8d6ae690d5ec16852e62b4c3 | [] | no_license | timepp/forcecrash | 4d4b30a610e882f343a5372736240fafd90838a6 | 53937ae6370278eb8ebb81c57857da612cf4b389 | refs/heads/master | 2021-01-01T18:07:23.698550 | 2013-02-11T05:03:03 | 2013-02-11T05:03:03 | 8,123,011 | 2 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 4,734 | cpp | #include "stdafx.h"
#include "maindlg.h"
#include "processinfo.h"
#include "crash.h"
static CStringW RCString(UINT id)
{
WCHAR buf[1024];
::LoadStringW(GetModuleHandle(NULL), id, buf, _countof(buf));
return buf;
}
LRESULT CMainDlg::OnOK(int /*code*/, int /*id*/, HWND /*wnd*/, BOOL& /*handled*/)
{
EndDialog(IDOK);
return 0;
}
LRESULT CMainDlg::OnInitDialog(UINT /*uMsg*/, WPARAM /*wParam*/, LPARAM /*lParam*/, BOOL& /*bHandled*/)
{
DlgResize_Init(true, true);
HICON hIcon = (HICON)::LoadImageW(
GetModuleHandleW(NULL), MAKEINTRESOURCEW(IDI_ICON1), IMAGE_ICON,
::GetSystemMetrics(SM_CXICON), ::GetSystemMetrics(SM_CYICON), 0
);
SetIcon(hIcon, TRUE);
hIcon = (HICON)::LoadImageW(
GetModuleHandleW(NULL), MAKEINTRESOURCEW(IDI_ICON1), IMAGE_ICON,
::GetSystemMetrics(SM_CXSMICON), ::GetSystemMetrics(SM_CYSMICON), 0
);
SetIcon(hIcon, FALSE);
CMenu mu = GetSystemMenu(FALSE);
mu.InsertMenu(0, MF_BYPOSITION, ID_APP_ABOUT, RCString(ID_APP_ABOUT));
mu.InsertMenu(1, MF_BYPOSITION|MF_SEPARATOR, 1, L"");
ConfigureList();
CenterWindow();
RefreshList();
AdjustList();
return TRUE;
}
void CMainDlg::ConfigureList()
{
m_list.SubclassWindow(GetDlgItem(IDC_LIST));
m_list.ModifyStyle(0, LVS_SHOWSELALWAYS);
m_list.SetExtendedListViewStyle(LVS_EX_FULLROWSELECT|LVS_EX_GRIDLINES|LVS_EX_DOUBLEBUFFER|LVS_EX_INFOTIP);
m_list.AddColumn(RCString(IDS_PROCESSNAME), 0);
m_list.AddColumn(RCString(IDS_PROCESSID), 1);
m_list.AddColumn(RCString(IDS_PARENTPROCESSID), 2);
m_list.AddColumn(RCString(IDS_COMMANDLINE), 3);
m_list.SetColumnSortType(1, LVCOLSORT_LONG);
m_list.SetColumnSortType(2, LVCOLSORT_LONG);
m_list.SetColumnWidth(0, 150);
m_list.SetColumnWidth(1, 50);
m_list.SetColumnWidth(2, 80);
m_list.SetColumnWidth(3, 800);
}
void CMainDlg::RefreshList()
{
// ¼Çס״̬
CStringW oldpid;
int index = m_list.GetSelectedIndex();
if (index >= 0)
{
m_list.GetItemText(index, 1, oldpid);
}
int sortcol = m_list.GetSortColumn();
bool desc = m_list.IsSortDescending();
m_list.DeleteAllItems();
process_list_t pl;
pinfo::get_process_list(pl);
index = 0;
for (process_list_t::const_iterator it = pl.begin(); it != pl.end(); ++it)
{
const process_info& pi = *it;
if (pi.command_line.empty()) continue;
m_list.AddItem(index, 0, pi.name.c_str());
m_list.SetItemText(index, 1, tp::cz(L"%u", pi.pid));
m_list.SetItemText(index, 2, tp::cz(L"%u", pi.ppid));
m_list.SetItemText(index, 3, pi.command_line.c_str());
index++;
}
if (sortcol >= 0) m_list.SortItems(sortcol, desc);
CStringW pid;
for (int i = 0; i < m_list.GetItemCount(); i++)
{
m_list.GetItemText(i, 1, pid);
if (pid == oldpid)
{
m_list.SelectItem(i);
break;
}
}
}
LRESULT CMainDlg::OnBnClickedRefresh(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
RefreshList();
return 0;
}
LRESULT CMainDlg::OnSize(UINT uMsg, WPARAM wParam, LPARAM lParam, BOOL& bHandled)
{
CDialogResize<CMainDlg>::OnSize(uMsg, wParam, lParam, bHandled);
AdjustList();
return 0;
}
void CMainDlg::AdjustList()
{
RECT rc;
m_list.GetClientRect(&rc);
m_list.SetColumnWidth(3, rc.right - rc.left - 255);
}
LRESULT CMainDlg::OnNMDblclkList(int /*idCtrl*/, LPNMHDR /*pNMHDR*/, BOOL& /*bHandled*/)
{
int index = m_list.GetSelectedIndex();
if (index >= 0)
{
CStringW name;
CStringW pidstr;
CStringW cmdline;
m_list.GetItemText(index, 0, name);
m_list.GetItemText(index, 1, pidstr);
m_list.GetItemText(index, 3, cmdline);
CStringW confirm_text = RCString(IDS_CRASH_CONFIRM);
confirm_text.Replace(L"%1", name);
confirm_text.Replace(L"%2", cmdline);
if (MessageBox(confirm_text, RCString(IDS_CONFIRM), MB_ICONQUESTION|MB_OKCANCEL) == IDOK)
{
DWORD pid = (DWORD)_wtoi(pidstr);
HRESULT hr = crash::CrashProcess(pid);
if (FAILED(hr))
{
WCHAR buffer[1024];
::FormatMessageW(FORMAT_MESSAGE_FROM_SYSTEM, NULL, (DWORD)hr, 0, buffer, _countof(buffer), NULL);
MessageBox(buffer, L"´íÎó", MB_ICONWARNING|MB_OK);
}
}
}
return 0;
}
LRESULT CMainDlg::OnBnClickedButtonElevate(WORD /*wNotifyCode*/, WORD /*wID*/, HWND /*hWndCtl*/, BOOL& /*bHandled*/)
{
WCHAR path[MAX_PATH];
::GetModuleFileNameW(NULL, path, _countof(path));
HINSTANCE inst = ::ShellExecuteW(NULL, L"runas", path, NULL, NULL, SW_SHOW);
if ((UINT)inst > 32)
{
EndDialog(IDOK);
}
return 0;
}
LRESULT CMainDlg::OnSysCommand(UINT /*uMsg*/, WPARAM wParam, LPARAM /*lParam*/, BOOL& bHandled)
{
if (wParam == ID_APP_ABOUT)
{
if (MessageBox(RCString(IDS_ABOUT_DETAIL), RCString(ID_APP_ABOUT), MB_OKCANCEL) == IDOK)
{
::ShellExecuteW(NULL, L"open", L"https://github.com/timepp/forcecrash", NULL, NULL, SW_SHOW);
}
}
else
{
bHandled = FALSE;
}
return 0;
}
| [
"[email protected]"
] | |
b7713e6bf6d1d28a62a0c51854abfd5d3837573a | 49b878b65e9eb00232490243ccb9aea9760a4a6d | /ash/system/unified/top_shortcut_button.cc | f86a844425a2a7624ec9ec77b4e5aa0dd3910a12 | [
"BSD-3-Clause"
] | permissive | romanzes/chromium | 5a46f234a233b3e113891a5d643a79667eaf2ffb | 12893215d9efc3b0b4d427fc60f5369c6bf6b938 | refs/heads/master | 2022-12-28T00:20:03.524839 | 2020-10-08T21:01:52 | 2020-10-08T21:01:52 | 302,470,347 | 0 | 0 | BSD-3-Clause | 2020-10-08T22:10:22 | 2020-10-08T21:54:38 | null | UTF-8 | C++ | false | false | 3,853 | cc | // Copyright 2018 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ash/system/unified/top_shortcut_button.h"
#include "ash/style/ash_color_provider.h"
#include "ash/system/tray/tray_popup_utils.h"
#include "ash/system/unified/unified_system_tray_view.h"
#include "ui/base/l10n/l10n_util.h"
#include "ui/gfx/canvas.h"
#include "ui/gfx/paint_vector_icon.h"
#include "ui/views/animation/flood_fill_ink_drop_ripple.h"
#include "ui/views/animation/ink_drop_highlight.h"
#include "ui/views/animation/ink_drop_impl.h"
#include "ui/views/animation/ink_drop_mask.h"
#include "ui/views/controls/highlight_path_generator.h"
#include "ui/views/view_class_properties.h"
namespace ash {
TopShortcutButton::TopShortcutButton(const gfx::VectorIcon& icon,
int accessible_name_id)
: TopShortcutButton(nullptr /* listener */, accessible_name_id) {
SetImage(views::Button::STATE_DISABLED,
gfx::CreateVectorIcon(
icon, kTrayTopShortcutButtonIconSize,
AshColorProvider::Get()->GetContentLayerColor(
AshColorProvider::ContentLayerType::kIconColorPrimary)));
SetEnabled(false);
focus_ring()->SetColor(UnifiedSystemTrayView::GetFocusRingColor());
}
TopShortcutButton::TopShortcutButton(views::ButtonListener* listener,
const gfx::VectorIcon& icon,
int accessible_name_id)
: TopShortcutButton(listener, accessible_name_id) {
const SkColor icon_color = AshColorProvider::Get()->GetContentLayerColor(
AshColorProvider::ContentLayerType::kIconColorPrimary);
SetImage(
views::Button::STATE_NORMAL,
gfx::CreateVectorIcon(icon, kTrayTopShortcutButtonIconSize, icon_color));
SetImage(
views::Button::STATE_DISABLED,
gfx::CreateVectorIcon(icon, kTrayTopShortcutButtonIconSize,
AshColorProvider::GetDisabledColor(icon_color)));
focus_ring()->SetColor(UnifiedSystemTrayView::GetFocusRingColor());
}
TopShortcutButton::TopShortcutButton(views::ButtonListener* listener,
int accessible_name_id)
: views::ImageButton(listener) {
SetImageHorizontalAlignment(ALIGN_CENTER);
SetImageVerticalAlignment(ALIGN_MIDDLE);
if (accessible_name_id)
SetTooltipText(l10n_util::GetStringUTF16(accessible_name_id));
TrayPopupUtils::ConfigureTrayPopupButton(this);
views::InstallCircleHighlightPathGenerator(this);
focus_ring()->SetColor(UnifiedSystemTrayView::GetFocusRingColor());
}
TopShortcutButton::~TopShortcutButton() = default;
gfx::Size TopShortcutButton::CalculatePreferredSize() const {
return gfx::Size(kTrayItemSize, kTrayItemSize);
}
void TopShortcutButton::PaintButtonContents(gfx::Canvas* canvas) {
cc::PaintFlags flags;
flags.setAntiAlias(true);
flags.setColor(AshColorProvider::Get()->GetControlsLayerColor(
AshColorProvider::ControlsLayerType::kControlBackgroundColorInactive));
flags.setStyle(cc::PaintFlags::kFill_Style);
canvas->DrawPath(views::GetHighlightPath(this), flags);
views::ImageButton::PaintButtonContents(canvas);
}
std::unique_ptr<views::InkDrop> TopShortcutButton::CreateInkDrop() {
return TrayPopupUtils::CreateInkDrop(this);
}
std::unique_ptr<views::InkDropRipple> TopShortcutButton::CreateInkDropRipple()
const {
return TrayPopupUtils::CreateInkDropRipple(
TrayPopupInkDropStyle::FILL_BOUNDS, this,
GetInkDropCenterBasedOnLastEvent());
}
std::unique_ptr<views::InkDropHighlight>
TopShortcutButton::CreateInkDropHighlight() const {
return TrayPopupUtils::CreateInkDropHighlight(this);
}
const char* TopShortcutButton::GetClassName() const {
return "TopShortcutButton";
}
} // namespace ash
| [
"[email protected]"
] | |
943addbae1d3a811b2163ca20d114425ca570f3f | c1dff4bedea4e5239e46b8996e0acb8191519bcc | /Cocos2dLearning/AudioControl.h | fb3852b56176b6972d86cdacf4817ea1af51241e | [] | no_license | WonderLoL/Cocos2dLearning | 3d5eaf08692ad30678968b5704f9442c39ebf6bd | 67a0e1b30d22829f5d430bddce1559c5161bbcd0 | refs/heads/master | 2020-03-25T16:40:07.034763 | 2018-08-14T00:43:39 | 2018-08-14T00:43:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 602 | h | #ifndef _AudioControl_H_
#define _AudioControl_H_
#include "cocos2d.h"
#include "SimpleAudioEngine.h"
#include "AudioEngine.h"
#include "ui\CocosGUI.h" <span style="white-space:pre">
USING_NS_CC;
using namespace CocosDenshion;
using namespace cocos2d;
using namespace ui;
class AudioControl:public Layer
{
public:
AudioControl();
static Scene* createScene();
virtual bool init();
CREATE_FUNC(AudioControl);
void CurrentLabel();
void MenuItem();
virtual void onEnter();
virtual void onExit();
private:
SimpleAudioEngine* myAudioEngine;
int audioId;
bool isLoop;
Size visibleSize;
};
#endif
| [
"[email protected]"
] | |
cfb0c85f57bfeb9bbc3384d717e0ff5de73614f6 | 62603134ccaf8310c3c4e58aa48a972469033f1c | /rsc/Length.h | 97d96fa3951e29b4f0dee0341b01a02e2eb4478b | [
"MIT"
] | permissive | RIscRIpt/rsc | 62bc6c548ae045e8f280d3049369b01a440523c7 | 605063dcfb121abe9e6a50d2ee6d1d3bace9cb22 | refs/heads/master | 2020-03-22T13:06:43.727988 | 2018-08-31T13:41:59 | 2018-08-31T13:41:59 | 140,083,894 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 608 | h | #pragma once
#include <vector>
#include <scb/Bytes.h>
namespace rsc {
class Length {
public:
enum {
IS_NUMBER_OF_BYTES = 0x80,
MASK_NUMBER_OF_BYTES = 0x7F,
};
Length(unsigned char const *buffer);
inline scb::Bytes const& bytes() const noexcept { return bytes_; }
inline size_t size() const noexcept { return bytes_.size(); }
inline size_t value() const noexcept { return value_; }
inline operator size_t() const noexcept { return value_; }
private:
scb::Bytes bytes_;
size_t value_;
};
}
| [
"[email protected]"
] | |
ae658f438df6731eb4073748e6d331dedb300b57 | c85cec2934b86ded18047a8e0bd1f97c75a72b0c | /src/crypto/sha512.cpp | 6cee59e2be7976af71d4221237b155a8050fd392 | [
"MIT"
] | permissive | ODUWAX/OduwaUSD | 1668e7e8eb615c60fe5d707284ddc9a57f58e1e0 | 8ba43a760ef85fb2b2679e772af8d2f1a3138b07 | refs/heads/master | 2023-01-08T23:47:01.636172 | 2020-11-04T10:55:27 | 2020-11-04T10:55:27 | 309,887,267 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,062 | cpp | // Copyright (c) 2014-2018 The Bitcoin Core developers
// Copyright (c) 2020 The OduwaUSD Coin developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include <crypto/sha512.h>
#include <crypto/common.h>
#include <string.h>
// Internal implementation code.
namespace
{
/// Internal SHA-512 implementation.
namespace sha512
{
uint64_t inline Ch(uint64_t x, uint64_t y, uint64_t z) { return z ^ (x & (y ^ z)); }
uint64_t inline Maj(uint64_t x, uint64_t y, uint64_t z) { return (x & y) | (z & (x | y)); }
uint64_t inline Sigma0(uint64_t x) { return (x >> 28 | x << 36) ^ (x >> 34 | x << 30) ^ (x >> 39 | x << 25); }
uint64_t inline Sigma1(uint64_t x) { return (x >> 14 | x << 50) ^ (x >> 18 | x << 46) ^ (x >> 41 | x << 23); }
uint64_t inline sigma0(uint64_t x) { return (x >> 1 | x << 63) ^ (x >> 8 | x << 56) ^ (x >> 7); }
uint64_t inline sigma1(uint64_t x) { return (x >> 19 | x << 45) ^ (x >> 61 | x << 3) ^ (x >> 6); }
/** One round of SHA-512. */
void inline Round(uint64_t a, uint64_t b, uint64_t c, uint64_t& d, uint64_t e, uint64_t f, uint64_t g, uint64_t& h, uint64_t k, uint64_t w)
{
uint64_t t1 = h + Sigma1(e) + Ch(e, f, g) + k + w;
uint64_t t2 = Sigma0(a) + Maj(a, b, c);
d += t1;
h = t1 + t2;
}
/** Initialize SHA-256 state. */
void inline Initialize(uint64_t* s)
{
s[0] = 0x6a09e667f3bcc908ull;
s[1] = 0xbb67ae8584caa73bull;
s[2] = 0x3c6ef372fe94f82bull;
s[3] = 0xa54ff53a5f1d36f1ull;
s[4] = 0x510e527fade682d1ull;
s[5] = 0x9b05688c2b3e6c1full;
s[6] = 0x1f83d9abfb41bd6bull;
s[7] = 0x5be0cd19137e2179ull;
}
/** Perform one SHA-512 transformation, processing a 128-byte chunk. */
void Transform(uint64_t* s, const unsigned char* chunk)
{
uint64_t a = s[0], b = s[1], c = s[2], d = s[3], e = s[4], f = s[5], g = s[6], h = s[7];
uint64_t w0, w1, w2, w3, w4, w5, w6, w7, w8, w9, w10, w11, w12, w13, w14, w15;
Round(a, b, c, d, e, f, g, h, 0x428a2f98d728ae22ull, w0 = ReadBE64(chunk + 0));
Round(h, a, b, c, d, e, f, g, 0x7137449123ef65cdull, w1 = ReadBE64(chunk + 8));
Round(g, h, a, b, c, d, e, f, 0xb5c0fbcfec4d3b2full, w2 = ReadBE64(chunk + 16));
Round(f, g, h, a, b, c, d, e, 0xe9b5dba58189dbbcull, w3 = ReadBE64(chunk + 24));
Round(e, f, g, h, a, b, c, d, 0x3956c25bf348b538ull, w4 = ReadBE64(chunk + 32));
Round(d, e, f, g, h, a, b, c, 0x59f111f1b605d019ull, w5 = ReadBE64(chunk + 40));
Round(c, d, e, f, g, h, a, b, 0x923f82a4af194f9bull, w6 = ReadBE64(chunk + 48));
Round(b, c, d, e, f, g, h, a, 0xab1c5ed5da6d8118ull, w7 = ReadBE64(chunk + 56));
Round(a, b, c, d, e, f, g, h, 0xd807aa98a3030242ull, w8 = ReadBE64(chunk + 64));
Round(h, a, b, c, d, e, f, g, 0x12835b0145706fbeull, w9 = ReadBE64(chunk + 72));
Round(g, h, a, b, c, d, e, f, 0x243185be4ee4b28cull, w10 = ReadBE64(chunk + 80));
Round(f, g, h, a, b, c, d, e, 0x550c7dc3d5ffb4e2ull, w11 = ReadBE64(chunk + 88));
Round(e, f, g, h, a, b, c, d, 0x72be5d74f27b896full, w12 = ReadBE64(chunk + 96));
Round(d, e, f, g, h, a, b, c, 0x80deb1fe3b1696b1ull, w13 = ReadBE64(chunk + 104));
Round(c, d, e, f, g, h, a, b, 0x9bdc06a725c71235ull, w14 = ReadBE64(chunk + 112));
Round(b, c, d, e, f, g, h, a, 0xc19bf174cf692694ull, w15 = ReadBE64(chunk + 120));
Round(a, b, c, d, e, f, g, h, 0xe49b69c19ef14ad2ull, w0 += sigma1(w14) + w9 + sigma0(w1));
Round(h, a, b, c, d, e, f, g, 0xefbe4786384f25e3ull, w1 += sigma1(w15) + w10 + sigma0(w2));
Round(g, h, a, b, c, d, e, f, 0x0fc19dc68b8cd5b5ull, w2 += sigma1(w0) + w11 + sigma0(w3));
Round(f, g, h, a, b, c, d, e, 0x240ca1cc77ac9c65ull, w3 += sigma1(w1) + w12 + sigma0(w4));
Round(e, f, g, h, a, b, c, d, 0x2de92c6f592b0275ull, w4 += sigma1(w2) + w13 + sigma0(w5));
Round(d, e, f, g, h, a, b, c, 0x4a7484aa6ea6e483ull, w5 += sigma1(w3) + w14 + sigma0(w6));
Round(c, d, e, f, g, h, a, b, 0x5cb0a9dcbd41fbd4ull, w6 += sigma1(w4) + w15 + sigma0(w7));
Round(b, c, d, e, f, g, h, a, 0x76f988da831153b5ull, w7 += sigma1(w5) + w0 + sigma0(w8));
Round(a, b, c, d, e, f, g, h, 0x983e5152ee66dfabull, w8 += sigma1(w6) + w1 + sigma0(w9));
Round(h, a, b, c, d, e, f, g, 0xa831c66d2db43210ull, w9 += sigma1(w7) + w2 + sigma0(w10));
Round(g, h, a, b, c, d, e, f, 0xb00327c898fb213full, w10 += sigma1(w8) + w3 + sigma0(w11));
Round(f, g, h, a, b, c, d, e, 0xbf597fc7beef0ee4ull, w11 += sigma1(w9) + w4 + sigma0(w12));
Round(e, f, g, h, a, b, c, d, 0xc6e00bf33da88fc2ull, w12 += sigma1(w10) + w5 + sigma0(w13));
Round(d, e, f, g, h, a, b, c, 0xd5a79147930aa725ull, w13 += sigma1(w11) + w6 + sigma0(w14));
Round(c, d, e, f, g, h, a, b, 0x06ca6351e003826full, w14 += sigma1(w12) + w7 + sigma0(w15));
Round(b, c, d, e, f, g, h, a, 0x142929670a0e6e70ull, w15 += sigma1(w13) + w8 + sigma0(w0));
Round(a, b, c, d, e, f, g, h, 0x27b70a8546d22ffcull, w0 += sigma1(w14) + w9 + sigma0(w1));
Round(h, a, b, c, d, e, f, g, 0x2e1b21385c26c926ull, w1 += sigma1(w15) + w10 + sigma0(w2));
Round(g, h, a, b, c, d, e, f, 0x4d2c6dfc5ac42aedull, w2 += sigma1(w0) + w11 + sigma0(w3));
Round(f, g, h, a, b, c, d, e, 0x53380d139d95b3dfull, w3 += sigma1(w1) + w12 + sigma0(w4));
Round(e, f, g, h, a, b, c, d, 0x650a73548baf63deull, w4 += sigma1(w2) + w13 + sigma0(w5));
Round(d, e, f, g, h, a, b, c, 0x766a0abb3c77b2a8ull, w5 += sigma1(w3) + w14 + sigma0(w6));
Round(c, d, e, f, g, h, a, b, 0x81c2c92e47edaee6ull, w6 += sigma1(w4) + w15 + sigma0(w7));
Round(b, c, d, e, f, g, h, a, 0x92722c851482353bull, w7 += sigma1(w5) + w0 + sigma0(w8));
Round(a, b, c, d, e, f, g, h, 0xa2bfe8a14cf10364ull, w8 += sigma1(w6) + w1 + sigma0(w9));
Round(h, a, b, c, d, e, f, g, 0xa81a664bbc423001ull, w9 += sigma1(w7) + w2 + sigma0(w10));
Round(g, h, a, b, c, d, e, f, 0xc24b8b70d0f89791ull, w10 += sigma1(w8) + w3 + sigma0(w11));
Round(f, g, h, a, b, c, d, e, 0xc76c51a30654be30ull, w11 += sigma1(w9) + w4 + sigma0(w12));
Round(e, f, g, h, a, b, c, d, 0xd192e819d6ef5218ull, w12 += sigma1(w10) + w5 + sigma0(w13));
Round(d, e, f, g, h, a, b, c, 0xd69906245565a910ull, w13 += sigma1(w11) + w6 + sigma0(w14));
Round(c, d, e, f, g, h, a, b, 0xf40e35855771202aull, w14 += sigma1(w12) + w7 + sigma0(w15));
Round(b, c, d, e, f, g, h, a, 0x106aa07032bbd1b8ull, w15 += sigma1(w13) + w8 + sigma0(w0));
Round(a, b, c, d, e, f, g, h, 0x19a4c116b8d2d0c8ull, w0 += sigma1(w14) + w9 + sigma0(w1));
Round(h, a, b, c, d, e, f, g, 0x1e376c085141ab53ull, w1 += sigma1(w15) + w10 + sigma0(w2));
Round(g, h, a, b, c, d, e, f, 0x2748774cdf8eeb99ull, w2 += sigma1(w0) + w11 + sigma0(w3));
Round(f, g, h, a, b, c, d, e, 0x34b0bcb5e19b48a8ull, w3 += sigma1(w1) + w12 + sigma0(w4));
Round(e, f, g, h, a, b, c, d, 0x391c0cb3c5c95a63ull, w4 += sigma1(w2) + w13 + sigma0(w5));
Round(d, e, f, g, h, a, b, c, 0x4ed8aa4ae3418acbull, w5 += sigma1(w3) + w14 + sigma0(w6));
Round(c, d, e, f, g, h, a, b, 0x5b9cca4f7763e373ull, w6 += sigma1(w4) + w15 + sigma0(w7));
Round(b, c, d, e, f, g, h, a, 0x682e6ff3d6b2b8a3ull, w7 += sigma1(w5) + w0 + sigma0(w8));
Round(a, b, c, d, e, f, g, h, 0x748f82ee5defb2fcull, w8 += sigma1(w6) + w1 + sigma0(w9));
Round(h, a, b, c, d, e, f, g, 0x78a5636f43172f60ull, w9 += sigma1(w7) + w2 + sigma0(w10));
Round(g, h, a, b, c, d, e, f, 0x84c87814a1f0ab72ull, w10 += sigma1(w8) + w3 + sigma0(w11));
Round(f, g, h, a, b, c, d, e, 0x8cc702081a6439ecull, w11 += sigma1(w9) + w4 + sigma0(w12));
Round(e, f, g, h, a, b, c, d, 0x90befffa23631e28ull, w12 += sigma1(w10) + w5 + sigma0(w13));
Round(d, e, f, g, h, a, b, c, 0xa4506cebde82bde9ull, w13 += sigma1(w11) + w6 + sigma0(w14));
Round(c, d, e, f, g, h, a, b, 0xbef9a3f7b2c67915ull, w14 += sigma1(w12) + w7 + sigma0(w15));
Round(b, c, d, e, f, g, h, a, 0xc67178f2e372532bull, w15 += sigma1(w13) + w8 + sigma0(w0));
Round(a, b, c, d, e, f, g, h, 0xca273eceea26619cull, w0 += sigma1(w14) + w9 + sigma0(w1));
Round(h, a, b, c, d, e, f, g, 0xd186b8c721c0c207ull, w1 += sigma1(w15) + w10 + sigma0(w2));
Round(g, h, a, b, c, d, e, f, 0xeada7dd6cde0eb1eull, w2 += sigma1(w0) + w11 + sigma0(w3));
Round(f, g, h, a, b, c, d, e, 0xf57d4f7fee6ed178ull, w3 += sigma1(w1) + w12 + sigma0(w4));
Round(e, f, g, h, a, b, c, d, 0x06f067aa72176fbaull, w4 += sigma1(w2) + w13 + sigma0(w5));
Round(d, e, f, g, h, a, b, c, 0x0a637dc5a2c898a6ull, w5 += sigma1(w3) + w14 + sigma0(w6));
Round(c, d, e, f, g, h, a, b, 0x113f9804bef90daeull, w6 += sigma1(w4) + w15 + sigma0(w7));
Round(b, c, d, e, f, g, h, a, 0x1b710b35131c471bull, w7 += sigma1(w5) + w0 + sigma0(w8));
Round(a, b, c, d, e, f, g, h, 0x28db77f523047d84ull, w8 += sigma1(w6) + w1 + sigma0(w9));
Round(h, a, b, c, d, e, f, g, 0x32caab7b40c72493ull, w9 += sigma1(w7) + w2 + sigma0(w10));
Round(g, h, a, b, c, d, e, f, 0x3c9ebe0a15c9bebcull, w10 += sigma1(w8) + w3 + sigma0(w11));
Round(f, g, h, a, b, c, d, e, 0x431d67c49c100d4cull, w11 += sigma1(w9) + w4 + sigma0(w12));
Round(e, f, g, h, a, b, c, d, 0x4cc5d4becb3e42b6ull, w12 += sigma1(w10) + w5 + sigma0(w13));
Round(d, e, f, g, h, a, b, c, 0x597f299cfc657e2aull, w13 += sigma1(w11) + w6 + sigma0(w14));
Round(c, d, e, f, g, h, a, b, 0x5fcb6fab3ad6faecull, w14 + sigma1(w12) + w7 + sigma0(w15));
Round(b, c, d, e, f, g, h, a, 0x6c44198c4a475817ull, w15 + sigma1(w13) + w8 + sigma0(w0));
s[0] += a;
s[1] += b;
s[2] += c;
s[3] += d;
s[4] += e;
s[5] += f;
s[6] += g;
s[7] += h;
}
} // namespace sha512
} // namespace
////// SHA-512
CSHA512::CSHA512() : bytes(0)
{
sha512::Initialize(s);
}
CSHA512& CSHA512::Write(const unsigned char* data, size_t len)
{
const unsigned char* end = data + len;
size_t bufsize = bytes % 128;
if (bufsize && bufsize + len >= 128) {
// Fill the buffer, and process it.
memcpy(buf + bufsize, data, 128 - bufsize);
bytes += 128 - bufsize;
data += 128 - bufsize;
sha512::Transform(s, buf);
bufsize = 0;
}
while (end >= data + 128) {
// Process full chunks directly from the source.
sha512::Transform(s, data);
data += 128;
bytes += 128;
}
if (end > data) {
// Fill the buffer with what remains.
memcpy(buf + bufsize, data, end - data);
bytes += end - data;
}
return *this;
}
void CSHA512::Finalize(unsigned char hash[OUTPUT_SIZE])
{
static const unsigned char pad[128] = {0x80};
unsigned char sizedesc[16] = {0x00};
WriteBE64(sizedesc + 8, bytes << 3);
Write(pad, 1 + ((239 - (bytes % 128)) % 128));
Write(sizedesc, 16);
WriteBE64(hash, s[0]);
WriteBE64(hash + 8, s[1]);
WriteBE64(hash + 16, s[2]);
WriteBE64(hash + 24, s[3]);
WriteBE64(hash + 32, s[4]);
WriteBE64(hash + 40, s[5]);
WriteBE64(hash + 48, s[6]);
WriteBE64(hash + 56, s[7]);
}
CSHA512& CSHA512::Reset()
{
bytes = 0;
sha512::Initialize(s);
return *this;
}
| [
"[email protected]"
] | |
ef01a24725239f9ef134f300bb7dadfe81a0d396 | 35f1e4e343eb889d1c0d7ad865f0c9c47cf8c410 | /include/main.cpp | c90ccd8de094a83c786f5c833ac2ea52cdb17983 | [] | no_license | rimokhy/my_gdb | 686a0e3c6edd7bfece283e6da688d4a5c425898b | dbb989570cb9c0222f9fa5e5638186ee11f01838 | refs/heads/master | 2020-04-09T22:57:07.851526 | 2016-09-13T08:55:39 | 2016-09-13T08:55:39 | 68,090,438 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 656 | cpp | //
// main.cpp for in /home/rimokh_y/secu_training/tracker
//
// Made by Yohan RIMOKH
// Login <[email protected]>
//
// Started on Wed May 4 05:30:30 2016 Yohan RIMOKH
// Last update Wed May 4 08:09:22 2016 Yohan RIMOKH
//
#include <iostream>
#include "Architecture.hpp"
int main(int ac, char **av)
{
if (av[1])
{
try {
Archi archi(av[1]);
archi.setArchi();
}
catch (Exception &e)
{
std::cerr << e.what() << std::endl;
return (-1);
}
}
else
{
std::cerr << "Set architecture for Traced filed" << std::endl;
return (-1);
}
return (0);
}
| [
"[email protected]"
] | |
aa4daac3c0d709b31cb223711a6902bd810c2945 | d3de50643925da3f5752128fe233d92eeae58da3 | /test/comp_avg_pred_test.h | ab2004c05bc4b458f4f1bacf315611cd04a3475c | [
"BSD-2-Clause"
] | permissive | kevleyski/aom | 45b955d191d1fab632e5906de648513b976e3b47 | dc79d472853862fa49806d6592476acdd386f0cf | refs/heads/master | 2022-10-02T01:35:54.132562 | 2022-09-15T08:35:42 | 2022-09-15T08:35:42 | 132,940,179 | 0 | 0 | BSD-2-Clause | 2022-09-15T08:35:43 | 2018-05-10T18:34:36 | C | UTF-8 | C++ | false | false | 21,124 | h | /*
* Copyright (c) 2018, Alliance for Open Media. All rights reserved
*
* This source code is subject to the terms of the BSD 2 Clause License and
* the Alliance for Open Media Patent License 1.0. If the BSD 2 Clause License
* was not distributed with this source code in the LICENSE file, you can
* obtain it at www.aomedia.org/license/software. If the Alliance for Open
* Media Patent License 1.0 was not distributed with this source code in the
* PATENTS file, you can obtain it at www.aomedia.org/license/patent.
*/
#ifndef TEST_COMP_AVG_PRED_TEST_H_
#define TEST_COMP_AVG_PRED_TEST_H_
#include "config/aom_dsp_rtcd.h"
#include "third_party/googletest/src/googletest/include/gtest/gtest.h"
#include "test/acm_random.h"
#include "test/util.h"
#include "test/clear_system_state.h"
#include "test/register_state_check.h"
#include "av1/common/common_data.h"
#include "aom_ports/aom_timer.h"
namespace libaom_test {
const int kMaxSize = 128 + 32; // padding
namespace AV1JNTCOMPAVG {
typedef void (*jntcompavg_func)(uint8_t *comp_pred, const uint8_t *pred,
int width, int height, const uint8_t *ref,
int ref_stride,
const JNT_COMP_PARAMS *jcp_param);
typedef void (*jntcompavgupsampled_func)(
MACROBLOCKD *xd, const struct AV1Common *const cm, int mi_row, int mi_col,
const MV *const mv, uint8_t *comp_pred, const uint8_t *pred, int width,
int height, int subpel_x_q3, int subpel_y_q3, const uint8_t *ref,
int ref_stride, const JNT_COMP_PARAMS *jcp_param);
typedef void (*highbdjntcompavg_func)(uint16_t *comp_pred, const uint8_t *pred8,
int width, int height,
const uint8_t *ref8, int ref_stride,
const JNT_COMP_PARAMS *jcp_param);
typedef void (*highbdjntcompavgupsampled_func)(
MACROBLOCKD *xd, const struct AV1Common *const cm, int mi_row, int mi_col,
const MV *const mv, uint16_t *comp_pred, const uint8_t *pred8, int width,
int height, int subpel_x_q3, int subpel_y_q3, const uint8_t *ref8,
int ref_stride, int bd, const JNT_COMP_PARAMS *jcp_param);
typedef ::testing::tuple<jntcompavg_func, BLOCK_SIZE> JNTCOMPAVGParam;
typedef ::testing::tuple<jntcompavgupsampled_func, BLOCK_SIZE>
JNTCOMPAVGUPSAMPLEDParam;
typedef ::testing::tuple<int, highbdjntcompavg_func, BLOCK_SIZE>
HighbdJNTCOMPAVGParam;
typedef ::testing::tuple<int, highbdjntcompavgupsampled_func, BLOCK_SIZE>
HighbdJNTCOMPAVGUPSAMPLEDParam;
::testing::internal::ParamGenerator<JNTCOMPAVGParam> BuildParams(
jntcompavg_func filter) {
return ::testing::Combine(::testing::Values(filter),
::testing::Range(BLOCK_4X4, BLOCK_SIZES_ALL));
}
::testing::internal::ParamGenerator<JNTCOMPAVGUPSAMPLEDParam> BuildParams(
jntcompavgupsampled_func filter) {
return ::testing::Combine(::testing::Values(filter),
::testing::Range(BLOCK_4X4, BLOCK_SIZES_ALL));
}
::testing::internal::ParamGenerator<HighbdJNTCOMPAVGParam> BuildParams(
highbdjntcompavg_func filter) {
return ::testing::Combine(::testing::Range(8, 13, 2),
::testing::Values(filter),
::testing::Range(BLOCK_4X4, BLOCK_SIZES_ALL));
}
::testing::internal::ParamGenerator<HighbdJNTCOMPAVGUPSAMPLEDParam> BuildParams(
highbdjntcompavgupsampled_func filter) {
return ::testing::Combine(::testing::Range(8, 13, 2),
::testing::Values(filter),
::testing::Range(BLOCK_4X4, BLOCK_SIZES_ALL));
}
class AV1JNTCOMPAVGTest : public ::testing::TestWithParam<JNTCOMPAVGParam> {
public:
~AV1JNTCOMPAVGTest() {}
void SetUp() { rnd_.Reset(ACMRandom::DeterministicSeed()); }
void TearDown() { libaom_test::ClearSystemState(); }
protected:
void RunCheckOutput(jntcompavg_func test_impl) {
const int w = kMaxSize, h = kMaxSize;
const int block_idx = GET_PARAM(1);
uint8_t pred8[kMaxSize * kMaxSize];
uint8_t ref8[kMaxSize * kMaxSize];
uint8_t output[kMaxSize * kMaxSize];
uint8_t output2[kMaxSize * kMaxSize];
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) {
pred8[i * w + j] = rnd_.Rand8();
ref8[i * w + j] = rnd_.Rand8();
}
const int in_w = block_size_wide[block_idx];
const int in_h = block_size_high[block_idx];
JNT_COMP_PARAMS jnt_comp_params;
jnt_comp_params.use_jnt_comp_avg = 1;
for (int ii = 0; ii < 2; ii++) {
for (int jj = 0; jj < 4; jj++) {
jnt_comp_params.fwd_offset = quant_dist_lookup_table[ii][jj][0];
jnt_comp_params.bck_offset = quant_dist_lookup_table[ii][jj][1];
const int offset_r = 3 + rnd_.PseudoUniform(h - in_h - 7);
const int offset_c = 3 + rnd_.PseudoUniform(w - in_w - 7);
aom_jnt_comp_avg_pred_c(output, pred8 + offset_r * w + offset_c, in_w,
in_h, ref8 + offset_r * w + offset_c, in_w,
&jnt_comp_params);
test_impl(output2, pred8 + offset_r * w + offset_c, in_w, in_h,
ref8 + offset_r * w + offset_c, in_w, &jnt_comp_params);
for (int i = 0; i < in_h; ++i) {
for (int j = 0; j < in_w; ++j) {
int idx = i * in_w + j;
ASSERT_EQ(output[idx], output2[idx])
<< "Mismatch at unit tests for AV1JNTCOMPAVGTest\n"
<< in_w << "x" << in_h << " Pixel mismatch at index " << idx
<< " = (" << i << ", " << j << ")";
}
}
}
}
}
void RunSpeedTest(jntcompavg_func test_impl) {
const int w = kMaxSize, h = kMaxSize;
const int block_idx = GET_PARAM(1);
uint8_t pred8[kMaxSize * kMaxSize];
uint8_t ref8[kMaxSize * kMaxSize];
uint8_t output[kMaxSize * kMaxSize];
uint8_t output2[kMaxSize * kMaxSize];
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) {
pred8[i * w + j] = rnd_.Rand8();
ref8[i * w + j] = rnd_.Rand8();
}
const int in_w = block_size_wide[block_idx];
const int in_h = block_size_high[block_idx];
JNT_COMP_PARAMS jnt_comp_params;
jnt_comp_params.use_jnt_comp_avg = 1;
jnt_comp_params.fwd_offset = quant_dist_lookup_table[0][0][0];
jnt_comp_params.bck_offset = quant_dist_lookup_table[0][0][1];
const int num_loops = 1000000000 / (in_w + in_h);
aom_usec_timer timer;
aom_usec_timer_start(&timer);
for (int i = 0; i < num_loops; ++i)
aom_jnt_comp_avg_pred_c(output, pred8, in_w, in_h, ref8, in_w,
&jnt_comp_params);
aom_usec_timer_mark(&timer);
const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
printf("jntcompavg c_code %3dx%-3d: %7.2f us\n", in_w, in_h,
1000.0 * elapsed_time / num_loops);
aom_usec_timer timer1;
aom_usec_timer_start(&timer1);
for (int i = 0; i < num_loops; ++i)
test_impl(output2, pred8, in_w, in_h, ref8, in_w, &jnt_comp_params);
aom_usec_timer_mark(&timer1);
const int elapsed_time1 = static_cast<int>(aom_usec_timer_elapsed(&timer1));
printf("jntcompavg test_code %3dx%-3d: %7.2f us\n", in_w, in_h,
1000.0 * elapsed_time1 / num_loops);
}
libaom_test::ACMRandom rnd_;
}; // class AV1JNTCOMPAVGTest
class AV1JNTCOMPAVGUPSAMPLEDTest
: public ::testing::TestWithParam<JNTCOMPAVGUPSAMPLEDParam> {
public:
~AV1JNTCOMPAVGUPSAMPLEDTest() {}
void SetUp() { rnd_.Reset(ACMRandom::DeterministicSeed()); }
void TearDown() { libaom_test::ClearSystemState(); }
protected:
void RunCheckOutput(jntcompavgupsampled_func test_impl) {
const int w = kMaxSize, h = kMaxSize;
const int block_idx = GET_PARAM(1);
uint8_t pred8[kMaxSize * kMaxSize];
uint8_t ref8[kMaxSize * kMaxSize];
DECLARE_ALIGNED(16, uint8_t, output[MAX_SB_SQUARE]);
DECLARE_ALIGNED(16, uint8_t, output2[MAX_SB_SQUARE]);
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) {
pred8[i * w + j] = rnd_.Rand8();
ref8[i * w + j] = rnd_.Rand8();
}
const int in_w = block_size_wide[block_idx];
const int in_h = block_size_high[block_idx];
JNT_COMP_PARAMS jnt_comp_params;
jnt_comp_params.use_jnt_comp_avg = 1;
int sub_x_q3, sub_y_q3;
for (sub_x_q3 = 0; sub_x_q3 < 8; ++sub_x_q3) {
for (sub_y_q3 = 0; sub_y_q3 < 8; ++sub_y_q3) {
for (int ii = 0; ii < 2; ii++) {
for (int jj = 0; jj < 4; jj++) {
jnt_comp_params.fwd_offset = quant_dist_lookup_table[ii][jj][0];
jnt_comp_params.bck_offset = quant_dist_lookup_table[ii][jj][1];
const int offset_r = 3 + rnd_.PseudoUniform(h - in_h - 7);
const int offset_c = 3 + rnd_.PseudoUniform(w - in_w - 7);
aom_jnt_comp_avg_upsampled_pred_c(
NULL, NULL, 0, 0, NULL, output, pred8 + offset_r * w + offset_c,
in_w, in_h, sub_x_q3, sub_y_q3, ref8 + offset_r * w + offset_c,
in_w, &jnt_comp_params);
test_impl(NULL, NULL, 0, 0, NULL, output2,
pred8 + offset_r * w + offset_c, in_w, in_h, sub_x_q3,
sub_y_q3, ref8 + offset_r * w + offset_c, in_w,
&jnt_comp_params);
for (int i = 0; i < in_h; ++i) {
for (int j = 0; j < in_w; ++j) {
int idx = i * in_w + j;
ASSERT_EQ(output[idx], output2[idx])
<< "Mismatch at unit tests for AV1JNTCOMPAVGUPSAMPLEDTest\n"
<< in_w << "x" << in_h << " Pixel mismatch at index " << idx
<< " = (" << i << ", " << j << "), sub pixel offset = ("
<< sub_y_q3 << ", " << sub_x_q3 << ")";
}
}
}
}
}
}
}
void RunSpeedTest(jntcompavgupsampled_func test_impl) {
const int w = kMaxSize, h = kMaxSize;
const int block_idx = GET_PARAM(1);
uint8_t pred8[kMaxSize * kMaxSize];
uint8_t ref8[kMaxSize * kMaxSize];
DECLARE_ALIGNED(16, uint8_t, output[MAX_SB_SQUARE]);
DECLARE_ALIGNED(16, uint8_t, output2[MAX_SB_SQUARE]);
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) {
pred8[i * w + j] = rnd_.Rand8();
ref8[i * w + j] = rnd_.Rand8();
}
const int in_w = block_size_wide[block_idx];
const int in_h = block_size_high[block_idx];
JNT_COMP_PARAMS jnt_comp_params;
jnt_comp_params.use_jnt_comp_avg = 1;
jnt_comp_params.fwd_offset = quant_dist_lookup_table[0][0][0];
jnt_comp_params.bck_offset = quant_dist_lookup_table[0][0][1];
int sub_x_q3 = 0;
int sub_y_q3 = 0;
const int num_loops = 1000000000 / (in_w + in_h);
aom_usec_timer timer;
aom_usec_timer_start(&timer);
for (int i = 0; i < num_loops; ++i)
aom_jnt_comp_avg_upsampled_pred_c(NULL, NULL, 0, 0, NULL, output, pred8,
in_w, in_h, sub_x_q3, sub_y_q3, ref8,
in_w, &jnt_comp_params);
aom_usec_timer_mark(&timer);
const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
printf("jntcompavgupsampled c_code %3dx%-3d: %7.2f us\n", in_w, in_h,
1000.0 * elapsed_time / num_loops);
aom_usec_timer timer1;
aom_usec_timer_start(&timer1);
for (int i = 0; i < num_loops; ++i)
test_impl(NULL, NULL, 0, 0, NULL, output2, pred8, in_w, in_h, sub_x_q3,
sub_y_q3, ref8, in_w, &jnt_comp_params);
aom_usec_timer_mark(&timer1);
const int elapsed_time1 = static_cast<int>(aom_usec_timer_elapsed(&timer1));
printf("jntcompavgupsampled test_code %3dx%-3d: %7.2f us\n", in_w, in_h,
1000.0 * elapsed_time1 / num_loops);
}
libaom_test::ACMRandom rnd_;
}; // class AV1JNTCOMPAVGUPSAMPLEDTest
class AV1HighBDJNTCOMPAVGTest
: public ::testing::TestWithParam<HighbdJNTCOMPAVGParam> {
public:
~AV1HighBDJNTCOMPAVGTest() {}
void SetUp() { rnd_.Reset(ACMRandom::DeterministicSeed()); }
void TearDown() { libaom_test::ClearSystemState(); }
protected:
void RunCheckOutput(highbdjntcompavg_func test_impl) {
const int w = kMaxSize, h = kMaxSize;
const int block_idx = GET_PARAM(2);
const int bd = GET_PARAM(0);
uint16_t pred8[kMaxSize * kMaxSize];
uint16_t ref8[kMaxSize * kMaxSize];
uint16_t output[kMaxSize * kMaxSize];
uint16_t output2[kMaxSize * kMaxSize];
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) {
pred8[i * w + j] = rnd_.Rand16() & ((1 << bd) - 1);
ref8[i * w + j] = rnd_.Rand16() & ((1 << bd) - 1);
}
const int in_w = block_size_wide[block_idx];
const int in_h = block_size_high[block_idx];
JNT_COMP_PARAMS jnt_comp_params;
jnt_comp_params.use_jnt_comp_avg = 1;
for (int ii = 0; ii < 2; ii++) {
for (int jj = 0; jj < 4; jj++) {
jnt_comp_params.fwd_offset = quant_dist_lookup_table[ii][jj][0];
jnt_comp_params.bck_offset = quant_dist_lookup_table[ii][jj][1];
const int offset_r = 3 + rnd_.PseudoUniform(h - in_h - 7);
const int offset_c = 3 + rnd_.PseudoUniform(w - in_w - 7);
aom_highbd_jnt_comp_avg_pred_c(
output, CONVERT_TO_BYTEPTR(pred8) + offset_r * w + offset_c, in_w,
in_h, CONVERT_TO_BYTEPTR(ref8) + offset_r * w + offset_c, in_w,
&jnt_comp_params);
test_impl(output2, CONVERT_TO_BYTEPTR(pred8) + offset_r * w + offset_c,
in_w, in_h,
CONVERT_TO_BYTEPTR(ref8) + offset_r * w + offset_c, in_w,
&jnt_comp_params);
for (int i = 0; i < in_h; ++i) {
for (int j = 0; j < in_w; ++j) {
int idx = i * in_w + j;
ASSERT_EQ(output[idx], output2[idx])
<< "Mismatch at unit tests for AV1HighBDJNTCOMPAVGTest\n"
<< in_w << "x" << in_h << " Pixel mismatch at index " << idx
<< " = (" << i << ", " << j << ")";
}
}
}
}
}
void RunSpeedTest(highbdjntcompavg_func test_impl) {
const int w = kMaxSize, h = kMaxSize;
const int block_idx = GET_PARAM(2);
const int bd = GET_PARAM(0);
uint16_t pred8[kMaxSize * kMaxSize];
uint16_t ref8[kMaxSize * kMaxSize];
uint16_t output[kMaxSize * kMaxSize];
uint16_t output2[kMaxSize * kMaxSize];
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) {
pred8[i * w + j] = rnd_.Rand16() & ((1 << bd) - 1);
ref8[i * w + j] = rnd_.Rand16() & ((1 << bd) - 1);
}
const int in_w = block_size_wide[block_idx];
const int in_h = block_size_high[block_idx];
JNT_COMP_PARAMS jnt_comp_params;
jnt_comp_params.use_jnt_comp_avg = 1;
jnt_comp_params.fwd_offset = quant_dist_lookup_table[0][0][0];
jnt_comp_params.bck_offset = quant_dist_lookup_table[0][0][1];
const int num_loops = 1000000000 / (in_w + in_h);
aom_usec_timer timer;
aom_usec_timer_start(&timer);
for (int i = 0; i < num_loops; ++i)
aom_highbd_jnt_comp_avg_pred_c(output, CONVERT_TO_BYTEPTR(pred8), in_w,
in_h, CONVERT_TO_BYTEPTR(ref8), in_w,
&jnt_comp_params);
aom_usec_timer_mark(&timer);
const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
printf("highbdjntcompavg c_code %3dx%-3d: %7.2f us\n", in_w, in_h,
1000.0 * elapsed_time / num_loops);
aom_usec_timer timer1;
aom_usec_timer_start(&timer1);
for (int i = 0; i < num_loops; ++i)
test_impl(output2, CONVERT_TO_BYTEPTR(pred8), in_w, in_h,
CONVERT_TO_BYTEPTR(ref8), in_w, &jnt_comp_params);
aom_usec_timer_mark(&timer1);
const int elapsed_time1 = static_cast<int>(aom_usec_timer_elapsed(&timer1));
printf("highbdjntcompavg test_code %3dx%-3d: %7.2f us\n", in_w, in_h,
1000.0 * elapsed_time1 / num_loops);
}
libaom_test::ACMRandom rnd_;
}; // class AV1HighBDJNTCOMPAVGTest
class AV1HighBDJNTCOMPAVGUPSAMPLEDTest
: public ::testing::TestWithParam<HighbdJNTCOMPAVGUPSAMPLEDParam> {
public:
~AV1HighBDJNTCOMPAVGUPSAMPLEDTest() {}
void SetUp() { rnd_.Reset(ACMRandom::DeterministicSeed()); }
void TearDown() { libaom_test::ClearSystemState(); }
protected:
void RunCheckOutput(highbdjntcompavgupsampled_func test_impl) {
const int w = kMaxSize, h = kMaxSize;
const int block_idx = GET_PARAM(2);
const int bd = GET_PARAM(0);
uint16_t pred8[kMaxSize * kMaxSize];
uint16_t ref8[kMaxSize * kMaxSize];
uint16_t output[kMaxSize * kMaxSize];
uint16_t output2[kMaxSize * kMaxSize];
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) {
pred8[i * w + j] = rnd_.Rand16() & ((1 << bd) - 1);
ref8[i * w + j] = rnd_.Rand16() & ((1 << bd) - 1);
}
const int in_w = block_size_wide[block_idx];
const int in_h = block_size_high[block_idx];
JNT_COMP_PARAMS jnt_comp_params;
jnt_comp_params.use_jnt_comp_avg = 1;
int sub_x_q3, sub_y_q3;
for (sub_x_q3 = 0; sub_x_q3 < 8; ++sub_x_q3) {
for (sub_y_q3 = 0; sub_y_q3 < 8; ++sub_y_q3) {
for (int ii = 0; ii < 2; ii++) {
for (int jj = 0; jj < 4; jj++) {
jnt_comp_params.fwd_offset = quant_dist_lookup_table[ii][jj][0];
jnt_comp_params.bck_offset = quant_dist_lookup_table[ii][jj][1];
const int offset_r = 3 + rnd_.PseudoUniform(h - in_h - 7);
const int offset_c = 3 + rnd_.PseudoUniform(w - in_w - 7);
aom_highbd_jnt_comp_avg_upsampled_pred_c(
NULL, NULL, 0, 0, NULL, output,
CONVERT_TO_BYTEPTR(pred8) + offset_r * w + offset_c, in_w, in_h,
sub_x_q3, sub_y_q3,
CONVERT_TO_BYTEPTR(ref8) + offset_r * w + offset_c, in_w, bd,
&jnt_comp_params);
test_impl(NULL, NULL, 0, 0, NULL, output2,
CONVERT_TO_BYTEPTR(pred8) + offset_r * w + offset_c, in_w,
in_h, sub_x_q3, sub_y_q3,
CONVERT_TO_BYTEPTR(ref8) + offset_r * w + offset_c, in_w,
bd, &jnt_comp_params);
for (int i = 0; i < in_h; ++i) {
for (int j = 0; j < in_w; ++j) {
int idx = i * in_w + j;
ASSERT_EQ(output[idx], output2[idx])
<< "Mismatch at unit tests for "
"AV1HighBDJNTCOMPAVGUPSAMPLEDTest\n"
<< in_w << "x" << in_h << " Pixel mismatch at index " << idx
<< " = (" << i << ", " << j << "), sub pixel offset = ("
<< sub_y_q3 << ", " << sub_x_q3 << ")";
}
}
}
}
}
}
}
void RunSpeedTest(highbdjntcompavgupsampled_func test_impl) {
const int w = kMaxSize, h = kMaxSize;
const int block_idx = GET_PARAM(2);
const int bd = GET_PARAM(0);
uint16_t pred8[kMaxSize * kMaxSize];
uint16_t ref8[kMaxSize * kMaxSize];
uint16_t output[kMaxSize * kMaxSize];
uint16_t output2[kMaxSize * kMaxSize];
for (int i = 0; i < h; ++i)
for (int j = 0; j < w; ++j) {
pred8[i * w + j] = rnd_.Rand16() & ((1 << bd) - 1);
ref8[i * w + j] = rnd_.Rand16() & ((1 << bd) - 1);
}
const int in_w = block_size_wide[block_idx];
const int in_h = block_size_high[block_idx];
JNT_COMP_PARAMS jnt_comp_params;
jnt_comp_params.use_jnt_comp_avg = 1;
jnt_comp_params.fwd_offset = quant_dist_lookup_table[0][0][0];
jnt_comp_params.bck_offset = quant_dist_lookup_table[0][0][1];
int sub_x_q3 = 0;
int sub_y_q3 = 0;
const int num_loops = 1000000000 / (in_w + in_h);
aom_usec_timer timer;
aom_usec_timer_start(&timer);
for (int i = 0; i < num_loops; ++i)
aom_highbd_jnt_comp_avg_upsampled_pred_c(
NULL, NULL, 0, 0, NULL, output, CONVERT_TO_BYTEPTR(pred8), in_w, in_h,
sub_x_q3, sub_y_q3, CONVERT_TO_BYTEPTR(ref8), in_w, bd,
&jnt_comp_params);
aom_usec_timer_mark(&timer);
const int elapsed_time = static_cast<int>(aom_usec_timer_elapsed(&timer));
printf("highbdjntcompavgupsampled c_code %3dx%-3d: %7.2f us\n", in_w, in_h,
1000.0 * elapsed_time / num_loops);
aom_usec_timer timer1;
aom_usec_timer_start(&timer1);
for (int i = 0; i < num_loops; ++i)
test_impl(NULL, NULL, 0, 0, NULL, output2, CONVERT_TO_BYTEPTR(pred8),
in_w, in_h, sub_x_q3, sub_y_q3, CONVERT_TO_BYTEPTR(ref8), in_w,
bd, &jnt_comp_params);
aom_usec_timer_mark(&timer1);
const int elapsed_time1 = static_cast<int>(aom_usec_timer_elapsed(&timer1));
printf("highbdjntcompavgupsampled test_code %3dx%-3d: %7.2f us\n", in_w,
in_h, 1000.0 * elapsed_time1 / num_loops);
}
libaom_test::ACMRandom rnd_;
}; // class AV1HighBDJNTCOMPAVGUPSAMPLEDTest
} // namespace AV1JNTCOMPAVG
} // namespace libaom_test
#endif // TEST_COMP_AVG_PRED_TEST_H_
| [
"[email protected]"
] | |
ce425896ca846a271be2e2fa071246481e6c8cc0 | ca69b648e5546c408b561e6453a1d967463bf5cc | /AOJ-ALDS/ALDS1_1_D.cpp | 2cffcbdff309e6cd3866a8e6d50c24f9f46661f7 | [] | no_license | IKKO-Ohta/contest | 4bc9c6385b5b4cf363f557fabd15130937e213a7 | 59f0a5981de62be90a357a87d248d703e6fa2b90 | refs/heads/master | 2021-01-20T05:15:47.862217 | 2017-07-15T14:27:59 | 2017-07-15T14:27:59 | 89,767,612 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 388 | cpp | #include <iostream>
using namespace std;
int main() {
int R[200000],n;
cin >> n;
for (int i = 0; i < n ; ++i) {
cin >> R[i];
}
int maxvalue = -2000000000;
int minvalue = R[0];
for (int i = 1; i < n ; ++i) {
maxvalue = max(maxvalue, R[i] - minvalue);
minvalue = min(minvalue, R[i]);
}
cout << maxvalue << endl;
return 0;
} | [
"[email protected]"
] | |
6836c100f646e1f718d74559c85ed7f7de10366c | b4970c5bfba340d9b61ce0beddd943d7f62aad09 | /Libraries/LibPthread/pthread.cpp | 1d8b8676838fbde3b7aeaf6a139d72cfad187c50 | [
"BSD-2-Clause"
] | permissive | OXiDE-dev/serenity | 3e5f8bda0006ecaabe32c080801d01370a310fae | 13dd3b70238b723c8e997a615ae76d31604f4257 | refs/heads/master | 2020-11-28T19:38:32.440812 | 2019-12-24T08:23:43 | 2019-12-24T08:23:43 | 229,904,668 | 0 | 0 | null | 2019-12-24T08:38:41 | 2019-12-24T08:38:40 | null | UTF-8 | C++ | false | false | 16,880 | cpp | #include <AK/Assertions.h>
#include <AK/Atomic.h>
#include <AK/InlineLinkedList.h>
#include <AK/StdLibExtras.h>
#include <Kernel/Syscall.h>
#include <limits.h>
#include <pthread.h>
#include <signal.h>
#include <stdio.h>
#include <sys/mman.h>
#include <time.h>
#include <unistd.h>
#define PTHREAD_DEBUG
namespace {
using PthreadAttrImpl = Syscall::SC_create_thread_params;
} // end anonymous namespace
constexpr size_t required_stack_alignment = 4 * MB;
constexpr size_t highest_reasonable_guard_size = 32 * PAGE_SIZE;
constexpr size_t highest_reasonable_stack_size = 8 * MB; // That's the default in Ubuntu?
extern "C" {
static int create_thread(void* (*entry)(void*), void* argument, void* thread_params)
{
return syscall(SC_create_thread, entry, argument, thread_params);
}
static void exit_thread(void* code)
{
syscall(SC_exit_thread, code);
ASSERT_NOT_REACHED();
}
int pthread_self()
{
return gettid();
}
int pthread_create(pthread_t* thread, pthread_attr_t* attributes, void* (*start_routine)(void*), void* argument_to_start_routine)
{
if (!thread)
return -EINVAL;
PthreadAttrImpl default_attributes {};
PthreadAttrImpl** arg_attributes = reinterpret_cast<PthreadAttrImpl**>(attributes);
PthreadAttrImpl* used_attributes = arg_attributes ? *arg_attributes : &default_attributes;
if (!used_attributes->m_stack_location) {
// adjust stack size, user might have called setstacksize, which has no restrictions on size/alignment
if (0 != (used_attributes->m_stack_size % required_stack_alignment))
used_attributes->m_stack_size += required_stack_alignment - (used_attributes->m_stack_size % required_stack_alignment);
used_attributes->m_stack_location = mmap_with_name(nullptr, used_attributes->m_stack_size, PROT_READ | PROT_WRITE, MAP_PRIVATE | MAP_ANONYMOUS | MAP_STACK, 0, 0, "Thread stack");
if (!used_attributes->m_stack_location)
return -1;
}
#ifdef PTHREAD_DEBUG
printf("pthread_create: Creating thread with attributes at %p, detach state %s, priority %d, guard page size %d, stack size %d, stack location %p\n",
used_attributes,
(PTHREAD_CREATE_JOINABLE == used_attributes->m_detach_state) ? "joinable" : "detached",
used_attributes->m_schedule_priority,
used_attributes->m_guard_page_size,
used_attributes->m_stack_size,
used_attributes->m_stack_location);
#endif
int rc = create_thread(start_routine, argument_to_start_routine, used_attributes);
if (rc < 0)
return rc;
*thread = rc;
return 0;
}
void pthread_exit(void* value_ptr)
{
exit_thread(value_ptr);
}
int pthread_join(pthread_t thread, void** exit_value_ptr)
{
return syscall(SC_join_thread, thread, exit_value_ptr);
}
int pthread_detach(pthread_t thread)
{
return syscall(SC_detach_thread, thread);
}
int pthread_sigmask(int how, const sigset_t* set, sigset_t* old_set)
{
if (sigprocmask(how, set, old_set))
return errno;
return 0;
}
int pthread_mutex_init(pthread_mutex_t* mutex, const pthread_mutexattr_t* attributes)
{
mutex->lock = 0;
mutex->owner = 0;
mutex->level = 0;
mutex->type = attributes ? attributes->type : PTHREAD_MUTEX_NORMAL;
return 0;
}
int pthread_mutex_destroy(pthread_mutex_t*)
{
return 0;
}
int pthread_mutex_lock(pthread_mutex_t* mutex)
{
auto& atomic = reinterpret_cast<Atomic<u32>&>(mutex->lock);
pthread_t this_thread = pthread_self();
for (;;) {
u32 expected = false;
if (!atomic.compare_exchange_strong(expected, true, AK::memory_order_acq_rel)) {
if (mutex->type == PTHREAD_MUTEX_RECURSIVE && mutex->owner == this_thread) {
mutex->level++;
return 0;
}
sched_yield();
continue;
}
mutex->owner = this_thread;
mutex->level = 0;
return 0;
}
}
int pthread_mutex_trylock(pthread_mutex_t* mutex)
{
auto& atomic = reinterpret_cast<Atomic<u32>&>(mutex->lock);
u32 expected = false;
if (!atomic.compare_exchange_strong(expected, true, AK::memory_order_acq_rel)) {
if (mutex->type == PTHREAD_MUTEX_RECURSIVE && mutex->owner == pthread_self()) {
mutex->level++;
return 0;
}
return EBUSY;
}
mutex->owner = pthread_self();
mutex->level = 0;
return 0;
}
int pthread_mutex_unlock(pthread_mutex_t* mutex)
{
if (mutex->type == PTHREAD_MUTEX_RECURSIVE && mutex->level > 0) {
mutex->level--;
return 0;
}
mutex->owner = 0;
mutex->lock = 0;
return 0;
}
int pthread_mutexattr_init(pthread_mutexattr_t* attr)
{
attr->type = PTHREAD_MUTEX_NORMAL;
return 0;
}
int pthread_mutexattr_destroy(pthread_mutexattr_t*)
{
return 0;
}
int pthread_mutexattr_settype(pthread_mutexattr_t* attr, int type)
{
if (!attr)
return EINVAL;
if (type != PTHREAD_MUTEX_NORMAL && type != PTHREAD_MUTEX_RECURSIVE)
return EINVAL;
attr->type = type;
return 0;
}
int pthread_attr_init(pthread_attr_t* attributes)
{
auto* impl = new PthreadAttrImpl {};
*attributes = impl;
#ifdef PTHREAD_DEBUG
printf("pthread_attr_init: New thread attributes at %p, detach state %s, priority %d, guard page size %d, stack size %d, stack location %p\n",
impl,
(PTHREAD_CREATE_JOINABLE == impl->m_detach_state) ? "joinable" : "detached",
impl->m_schedule_priority,
impl->m_guard_page_size,
impl->m_stack_size,
impl->m_stack_location);
#endif
return 0;
}
int pthread_attr_destroy(pthread_attr_t* attributes)
{
auto* attributes_impl = *(reinterpret_cast<PthreadAttrImpl**>(attributes));
delete attributes_impl;
return 0;
}
int pthread_attr_getdetachstate(const pthread_attr_t* attributes, int* p_detach_state)
{
auto* attributes_impl = *(reinterpret_cast<const PthreadAttrImpl* const*>(attributes));
if (!attributes_impl || !p_detach_state)
return EINVAL;
*p_detach_state = attributes_impl->m_detach_state;
return 0;
}
int pthread_attr_setdetachstate(pthread_attr_t* attributes, int detach_state)
{
auto* attributes_impl = *(reinterpret_cast<PthreadAttrImpl**>(attributes));
if (!attributes_impl)
return EINVAL;
if ((PTHREAD_CREATE_JOINABLE != detach_state) || PTHREAD_CREATE_DETACHED != detach_state)
return EINVAL;
attributes_impl->m_detach_state = detach_state;
#ifdef PTHREAD_DEBUG
printf("pthread_attr_setdetachstate: Thread attributes at %p, detach state %s, priority %d, guard page size %d, stack size %d, stack location %p\n",
attributes_impl,
(PTHREAD_CREATE_JOINABLE == attributes_impl->m_detach_state) ? "joinable" : "detached",
attributes_impl->m_schedule_priority,
attributes_impl->m_guard_page_size,
attributes_impl->m_stack_size,
attributes_impl->m_stack_location);
#endif
return 0;
}
int pthread_attr_getguardsize(const pthread_attr_t* attributes, size_t* p_guard_size)
{
auto* attributes_impl = *(reinterpret_cast<const PthreadAttrImpl* const*>(attributes));
if (!attributes_impl || !p_guard_size)
return EINVAL;
*p_guard_size = attributes_impl->m_reported_guard_page_size;
return 0;
}
int pthread_attr_setguardsize(pthread_attr_t* attributes, size_t guard_size)
{
auto* attributes_impl = *(reinterpret_cast<PthreadAttrImpl**>(attributes));
if (!attributes_impl)
return EINVAL;
size_t actual_guard_size = guard_size;
// round up
if (0 != (guard_size % PAGE_SIZE))
actual_guard_size += PAGE_SIZE - (guard_size % PAGE_SIZE);
// what is the user even doing?
if (actual_guard_size > highest_reasonable_guard_size) {
return EINVAL;
}
attributes_impl->m_guard_page_size = actual_guard_size;
attributes_impl->m_reported_guard_page_size = guard_size; // POSIX, why?
#ifdef PTHREAD_DEBUG
printf("pthread_attr_setguardsize: Thread attributes at %p, detach state %s, priority %d, guard page size %d, stack size %d, stack location %p\n",
attributes_impl,
(PTHREAD_CREATE_JOINABLE == attributes_impl->m_detach_state) ? "joinable" : "detached",
attributes_impl->m_schedule_priority,
attributes_impl->m_guard_page_size,
attributes_impl->m_stack_size,
attributes_impl->m_stack_location);
#endif
return 0;
}
int pthread_attr_getschedparam(const pthread_attr_t* attributes, struct sched_param* p_sched_param)
{
auto* attributes_impl = *(reinterpret_cast<const PthreadAttrImpl* const*>(attributes));
if (!attributes_impl || !p_sched_param)
return EINVAL;
p_sched_param->sched_priority = attributes_impl->m_schedule_priority;
return 0;
}
int pthread_attr_setschedparam(pthread_attr_t* attributes, const struct sched_param* p_sched_param)
{
auto* attributes_impl = *(reinterpret_cast<PthreadAttrImpl**>(attributes));
if (!attributes_impl || !p_sched_param)
return EINVAL;
// NOTE: This must track sched_get_priority_[min,max] and ThreadPriority enum in Thread.h
if (p_sched_param->sched_priority < 0 || p_sched_param->sched_priority > 3)
return ENOTSUP;
attributes_impl->m_schedule_priority = p_sched_param->sched_priority;
#ifdef PTHREAD_DEBUG
printf("pthread_attr_setschedparam: Thread attributes at %p, detach state %s, priority %d, guard page size %d, stack size %d, stack location %p\n",
attributes_impl,
(PTHREAD_CREATE_JOINABLE == attributes_impl->m_detach_state) ? "joinable" : "detached",
attributes_impl->m_schedule_priority,
attributes_impl->m_guard_page_size,
attributes_impl->m_stack_size,
attributes_impl->m_stack_location);
#endif
return 0;
}
int pthread_attr_getstack(const pthread_attr_t* attributes, void** p_stack_ptr, size_t* p_stack_size)
{
auto* attributes_impl = *(reinterpret_cast<const PthreadAttrImpl* const*>(attributes));
if (!attributes_impl || !p_stack_ptr || !p_stack_size)
return EINVAL;
*p_stack_ptr = attributes_impl->m_stack_location;
*p_stack_size = attributes_impl->m_stack_size;
return 0;
}
int pthread_attr_setstack(pthread_attr_t* attributes, void* p_stack, size_t stack_size)
{
auto* attributes_impl = *(reinterpret_cast<PthreadAttrImpl**>(attributes));
if (!attributes_impl || !p_stack)
return EINVAL;
// Check for required alignment on size
if (0 != (stack_size % required_stack_alignment))
return EINVAL;
// FIXME: Check for required alignment on pointer?
// FIXME: "[EACCES] The stack page(s) described by stackaddr and stacksize are not both readable and writable by the thread."
// Have to check that the whole range is mapped to this process/thread? Can we defer this to create_thread?
attributes_impl->m_stack_size = stack_size;
attributes_impl->m_stack_location = p_stack;
#ifdef PTHREAD_DEBUG
printf("pthread_attr_setstack: Thread attributes at %p, detach state %s, priority %d, guard page size %d, stack size %d, stack location %p\n",
attributes_impl,
(PTHREAD_CREATE_JOINABLE == attributes_impl->m_detach_state) ? "joinable" : "detached",
attributes_impl->m_schedule_priority,
attributes_impl->m_guard_page_size,
attributes_impl->m_stack_size,
attributes_impl->m_stack_location);
#endif
return 0;
}
int pthread_attr_getstacksize(const pthread_attr_t* attributes, size_t* p_stack_size)
{
auto* attributes_impl = *(reinterpret_cast<const PthreadAttrImpl* const*>(attributes));
if (!attributes_impl || !p_stack_size)
return EINVAL;
*p_stack_size = attributes_impl->m_stack_size;
return 0;
}
int pthread_attr_setstacksize(pthread_attr_t* attributes, size_t stack_size)
{
auto* attributes_impl = *(reinterpret_cast<PthreadAttrImpl**>(attributes));
if (!attributes_impl)
return EINVAL;
if ((stack_size < PTHREAD_STACK_MIN) || stack_size > highest_reasonable_stack_size)
return EINVAL;
attributes_impl->m_stack_size = stack_size;
#ifdef PTHREAD_DEBUG
printf("pthread_attr_setstacksize: Thread attributes at %p, detach state %s, priority %d, guard page size %d, stack size %d, stack location %p\n",
attributes_impl,
(PTHREAD_CREATE_JOINABLE == attributes_impl->m_detach_state) ? "joinable" : "detached",
attributes_impl->m_schedule_priority,
attributes_impl->m_guard_page_size,
attributes_impl->m_stack_size,
attributes_impl->m_stack_location);
#endif
return 0;
}
int pthread_getschedparam(pthread_t thread, int* policy, struct sched_param* param)
{
(void)thread;
(void)policy;
(void)param;
return 0;
}
int pthread_setschedparam(pthread_t thread, int policy, const struct sched_param* param)
{
(void)thread;
(void)policy;
(void)param;
return 0;
}
struct WaitNode : public InlineLinkedListNode<WaitNode> {
volatile bool waiting { true };
WaitNode* m_next { nullptr };
WaitNode* m_prev { nullptr };
};
struct ConditionVariable {
InlineLinkedList<WaitNode> waiters;
clockid_t clock { CLOCK_MONOTONIC };
};
int pthread_cond_init(pthread_cond_t* cond, const pthread_condattr_t* attr)
{
auto& condvar = *new ConditionVariable;
cond->storage = &condvar;
if (attr)
condvar.clock = attr->clockid;
return 0;
}
int pthread_cond_destroy(pthread_cond_t* cond)
{
delete static_cast<ConditionVariable*>(cond->storage);
return 0;
}
int pthread_cond_wait(pthread_cond_t* cond, pthread_mutex_t* mutex)
{
WaitNode node;
auto& condvar = *(ConditionVariable*)cond->storage;
condvar.waiters.append(&node);
while (node.waiting) {
pthread_mutex_unlock(mutex);
sched_yield();
pthread_mutex_lock(mutex);
}
return 0;
}
int pthread_condattr_init(pthread_condattr_t* attr)
{
attr->clockid = CLOCK_MONOTONIC;
return 0;
}
int pthread_condattr_destroy(pthread_condattr_t*)
{
return 0;
}
int pthread_condattr_setclock(pthread_condattr_t* attr, clockid_t clock)
{
attr->clockid = clock;
return 0;
}
int pthread_cond_timedwait(pthread_cond_t* cond, pthread_mutex_t* mutex, const struct timespec* abstime)
{
WaitNode node;
auto& condvar = *(ConditionVariable*)cond->storage;
condvar.waiters.append(&node);
while (node.waiting) {
struct timespec now;
if (clock_gettime(condvar.clock, &now) < 0) {
dbgprintf("pthread_cond_timedwait: clock_gettime() failed\n");
return errno;
}
if ((abstime->tv_sec < now.tv_sec) || (abstime->tv_sec == now.tv_sec && abstime->tv_nsec <= now.tv_nsec)) {
return ETIMEDOUT;
}
pthread_mutex_unlock(mutex);
sched_yield();
pthread_mutex_lock(mutex);
}
return 0;
}
int pthread_cond_signal(pthread_cond_t* cond)
{
auto& condvar = *(ConditionVariable*)cond->storage;
if (condvar.waiters.is_empty())
return 0;
auto* node = condvar.waiters.remove_head();
node->waiting = false;
return 0;
}
int pthread_cond_broadcast(pthread_cond_t* cond)
{
auto& condvar = *(ConditionVariable*)cond->storage;
while (!condvar.waiters.is_empty()) {
auto* node = condvar.waiters.remove_head();
node->waiting = false;
}
return 0;
}
static const int max_keys = 64;
typedef void (*KeyDestructor)(void*);
struct KeyTable {
// FIXME: Invoke key destructors on thread exit!
KeyDestructor destructors[64] { nullptr };
int next { 0 };
pthread_mutex_t mutex = PTHREAD_MUTEX_INITIALIZER;
};
struct SpecificTable {
void* values[64] { nullptr };
};
static KeyTable s_keys;
__thread SpecificTable t_specifics;
int pthread_key_create(pthread_key_t* key, KeyDestructor destructor)
{
int ret = 0;
pthread_mutex_lock(&s_keys.mutex);
if (s_keys.next >= max_keys) {
ret = ENOMEM;
} else {
*key = s_keys.next++;
s_keys.destructors[*key] = destructor;
ret = 0;
}
pthread_mutex_unlock(&s_keys.mutex);
return ret;
}
void* pthread_getspecific(pthread_key_t key)
{
if (key < 0)
return nullptr;
if (key >= max_keys)
return nullptr;
return t_specifics.values[key];
}
int pthread_setspecific(pthread_key_t key, const void* value)
{
if (key < 0)
return EINVAL;
if (key >= max_keys)
return EINVAL;
t_specifics.values[key] = const_cast<void*>(value);
return 0;
}
int pthread_setname_np(pthread_t thread, const char* buffer, int buffer_size)
{
return syscall(SC_set_thread_name, thread, buffer, buffer_size);
}
int pthread_getname_np(pthread_t thread, char* buffer, int buffer_size)
{
return syscall(SC_get_thread_name, thread, buffer, buffer_size);
}
} // extern "C"
| [
"[email protected]"
] | |
b82f30b4100e1e9f9489a096e865d8ed9cfdca46 | 868ba990839028b738584acbf20ec587fb318503 | /src/impl/tilemap/tileset_constructor.cc | e2c4dda189507cc9547f620adf7fcc49a5e1bf01 | [] | no_license | jackHay22/swamp-surveyor | ffa122c08221c1a0f1de5551e184f4975fcfdd51 | 867c33cda7bb173921a3d1c401cb87a8da2e973b | refs/heads/main | 2023-04-07T01:04:14.514055 | 2021-04-03T19:35:46 | 2021-04-03T19:35:46 | 324,853,090 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,739 | cc | /*
* (C) 2021 Jack Hay
*
* Untitled Swamp game
*/
#include "tileset_constructor.h"
namespace impl {
namespace tilemap {
/**
* Constructor
*/
tileset_constructor_t::tileset_constructor_t(int dim)
: dim(dim),
texture_constructor(),
last_type(-1) {}
/**
* Get the x offset of a tile in the map
* @param tile the tile
* @return the x offset
*/
int tileset_constructor_t::offset_x(int tile) {
return (tile % TILESET_MAX_WIDTH) * dim;
}
/**
* Get the y offset of a tile in the map
* @param tile the tile
* @return the offset
*/
int tileset_constructor_t::offset_y(int tile) {
return (tile / TILESET_MAX_WIDTH) * dim;
}
/**
* Set the default drawing color
*/
void tileset_constructor_t::set_default_color(Uint8 r, Uint8 g, Uint8 b) {
texture_constructor.set_default_color(r,g,b);
}
/**
* Set a pixel
*/
void tileset_constructor_t::set(int tile, int x, int y) {
texture_constructor.set(
offset_x(tile) + x,
offset_y(tile) + y
);
}
/**
* Fill a tile with some color
*/
void tileset_constructor_t::fill_tile(int tile, Uint8 r, Uint8 g, Uint8 b) {
//set the default color
texture_constructor.set_default_color(r,g,b);
texture_constructor.set_rect(
offset_x(tile), offset_y(tile),
dim,dim
);
}
/**
* Draw a rectangle in some tile
* @param tile the tile
* @param x,y origin
* @param w,h dimensions
*/
void tileset_constructor_t::draw_rect(int tile, int x, int y, int w, int h) {
texture_constructor.set_rect(
offset_x(tile), offset_y(tile),
w,h
);
}
/**
* Draw a line on some tile
* @param tile the tile
* @param x1,y1 p1
* @param x2,y2 p2
*/
void tileset_constructor_t::draw_line(int tile, int x1, int y1, int x2, int y2, int thickness) {
int offx = offset_x(tile);
int offy = offset_y(tile);
//set the line with the correct offset
texture_constructor.set_line(
x1 + offx,
y1 + offy,
x2 + offx,
y2 + offy,
thickness
);
}
/**
* Erase a pixel in a given tile
* @param tile the tile
* @param x pos x
* @param y pos y
*/
void tileset_constructor_t::erase(int tile, int x, int y) {
texture_constructor.erase(x + offset_x(tile), y + offset_y(tile));
}
/**
* Add pixels to the tile
* Note: these are relocated within the texture so each position
* should be in the range 0 -> dim, 0 -> dim
* Since the tiles aren't animated, frames are disregarded
* @param pxs the pixels to add
* @return the tile type
*/
[[nodiscard]] int tileset_constructor_t::add_tile(const std::vector<environment::px_t>& pxs) {
last_type++;
for (size_t i=0; i<pxs.size(); i++) {
texture_constructor.set(
std::get<PINFO_POS>(pxs.at(i)).first + offset_x(last_type),
std::get<PINFO_POS>(pxs.at(i)).second + offset_y(last_type),
std::get<0>(std::get<PINFO_RGB>(pxs.at(i))),
std::get<1>(std::get<PINFO_RGB>(pxs.at(i))),
std::get<2>(std::get<PINFO_RGB>(pxs.at(i)))
);
}
return last_type;
}
/**
* Create space for a new tile without setting any pixels
* @return the tile type
*/
[[nodiscard]] int tileset_constructor_t::add_tile() {
last_type++;
return last_type;
}
/**
* Generate the tileset so far
* @param renderer the renderer
* @return the tileset
*/
std::shared_ptr<tileset_t> tileset_constructor_t::generate_tileset(SDL_Renderer& renderer) const {
int tsw,tsh;
SDL_Texture *t = texture_constructor.generate(renderer,tsw,tsh);
//make tileset
return std::make_shared<tileset_t>(t,tsw,tsh,dim);
}
}}
| [
"[email protected]"
] | |
efa5a9168b0c68003db3332837f38fce878aa130 | 8abd6c3d2a8ae24fbaa33a52e12f116541b1f175 | /TestGridListCtrl/Dialog1.h | c467493d1a3fe8bd8a3a153882537f98d24f7aab | [
"LicenseRef-scancode-warranty-disclaimer"
] | no_license | kamex-kumax/Rhino4Samples_CPP | a5ac780e3a9b3028541b2fe59dcba110deb10335 | fbbe856850f0d67e305e070a4b69ce9eadece9d6 | refs/heads/master | 2020-03-28T19:17:53.064301 | 2017-03-17T22:10:21 | 2017-03-17T22:10:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 929 | h | #pragma once
#include "resource.h"
#include "afxcmn.h"
class CDialog1ListCtrl : public CRhinoUiGridListCtrl
{
DECLARE_DYNAMIC(CDialog1ListCtrl)
public:
CDialog1ListCtrl( CRhinoDoc& doc);
virtual ~CDialog1ListCtrl();
// CRhinoUiGridListCtrl overrides
BOOL DoneEditing( long nItem, int nSubItem, LPCTSTR lpszText);
BOOL ModifyGridItem( long nItem, int nSubItem);
protected:
CRhinoDoc& m_doc;
ON_wString m_wOriginalString;
protected:
DECLARE_MESSAGE_MAP()
};
// CDialog1 dialog
class CDialog1 : public CRhinoDialog
{
DECLARE_DYNAMIC(CDialog1)
public:
CDialog1( CRhinoDoc& doc, CWnd* pParent = NULL); // standard constructor
virtual ~CDialog1();
// Dialog Data
enum { IDD = IDD_DIALOG1 };
protected:
CRhinoDoc& m_doc;
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
DECLARE_MESSAGE_MAP()
public:
virtual BOOL OnInitDialog();
CDialog1ListCtrl m_ListCtrl;
};
| [
"[email protected]"
] | |
f62ef47838c9e3fca16e2d27a8a9e0300368cdf7 | 533039f833fc90eacad10ecba6fb93635b781564 | /Source/OnlineGame/Widgets/MainMenuErrorDialogueWidget.h | a4fbbf9aec0e2c582f27ad23dacdc37898e8c20c | [] | no_license | Lordmatics/OnlineGame | 5c6b4f501cefcba8fab6e0042df5daf2bb2a1130 | 0cb7511c32d1fcf5a43a06c3ebe0f627627e10e5 | refs/heads/master | 2021-01-11T07:32:25.100665 | 2017-04-27T21:54:26 | 2017-04-27T21:54:26 | 80,136,316 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 424 | h | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "Blueprint/UserWidget.h"
#include "MainMenuErrorDialogueWidget.generated.h"
/**
*
*/
UCLASS()
class ONLINEGAME_API UMainMenuErrorDialogueWidget : public UUserWidget
{
GENERATED_BODY()
private:
public:
protected:
//virtual void NativeConstruct() override;
//
//TSharedRef<SWidget> RebuildWidget() override;
};
| [
"[email protected]"
] | |
d31ea78cecc9ef00ccf51f65757e3d140ed04bec | 169033d64b02a319965fa523b13864fe9d4b01d4 | /cf_gcd_array.cpp | dbf7cdddac4c51916c6692efdb14fc0c4095e973 | [] | no_license | gutaussehend-Harshal/codeforces | 34f8dc683a606ba941174b09cd3d36723355b101 | 898dc82cb098fc741eaf2c61d12d7f46a6f5a664 | refs/heads/main | 2023-07-26T20:16:12.711901 | 2021-08-28T08:07:51 | 2021-08-28T08:07:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 742 | cpp | #include <bits/stdc++.h>
#define ll long long int
#define vll vector<ll>
#define pb push_back
#define mp make_pair
#define input_arr for(int i=0;i<n;i++) cin>>arr[i];
#define f(i,s,e) for(ll i=s;i<e;i++)
#define test int t; cin>>t; while(t--)
#define fast_IO ios_base::sync_with_stdio(false); cin.tie(NULL);
using namespace std;
void fast()
{
#ifndef ONLINE_JUDGE
freopen("input1.txt","r",stdin);
freopen("output1.txt","w",stdout);
#endif
fast_IO
cout.tie(NULL);
}
void solve()
{
int a,b,c;
cin>>a>>b>>c;
int x=pow(10,a-1) + pow(10,c-1);
int y=pow(10,b-1);
cout<<x<<" "<<y<<endl;
}
int main()
{
fast();
test
{
solve();
}
return 0;
}
| [
"[email protected]"
] | |
6024c6ba1801a0d90d87935726354ed473142463 | 104a89f166f3f97c3c25700e786a7fd952da8186 | /Projeler/MPU6050_Gyro_sensor/MPU6050_Gyro_sensor.ino | ddaecfc267a26ec30cc83d2c885d083f0a1c5ce7 | [] | no_license | Bugrabugra/Arduino | 3a50ab6097c5eeeee29a836a0b0262876ba750d0 | 778eca4fe0a066c1047ed2b7809f3d9fc7cff1ce | refs/heads/master | 2023-03-18T09:19:16.513221 | 2023-03-10T07:24:48 | 2023-03-10T07:24:48 | 205,795,849 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 419 | ino |
#include <MPU6050_tockn.h>
#include <Wire.h>
MPU6050 mpu6050(Wire);
void setup()
{
Serial.begin(9600);
Wire.begin();
mpu6050.begin();
mpu6050.calcGyroOffsets(true);
}
void loop()
{
mpu6050.update();
Serial.print("angleX : ");
Serial.print(mpu6050.getAngleX());
Serial.print("\tangleY : ");
Serial.print(mpu6050.getAngleY());
Serial.print("\tangleZ : ");
Serial.println(mpu6050.getAngleZ());
}
| [
"[email protected]"
] | |
33d54f93c11891b8668a168049eaa8846f46f6b9 | a1cc22bafb4429b53898962b1131333420eddf05 | /cmdstan/stan/lib/stan_math/test/prob/neg_binomial_2/neg_binomial_2_test.hpp | bee0da5760bf17a5f9fa37fdf3e3eed01089af84 | [
"LicenseRef-scancode-unknown-license-reference",
"GPL-2.0-only",
"Apache-2.0",
"BSD-3-Clause",
"GPL-3.0-only"
] | permissive | metrumresearchgroup/Torsten | d9510b00242b9f77cdc989657a4956b3018a5f3a | 0168482d400e4b819acadbc28cc817dd1a037c1b | refs/heads/master | 2023-09-01T17:44:46.020886 | 2022-05-18T22:46:35 | 2022-05-18T22:46:35 | 124,574,336 | 50 | 18 | BSD-3-Clause | 2023-09-09T06:32:36 | 2018-03-09T17:48:27 | C++ | UTF-8 | C++ | false | false | 2,986 | hpp | // Arguments: Ints, Doubles, Doubles
#include <stan/math/prim.hpp>
using stan::math::var;
using std::numeric_limits;
using std::vector;
class AgradDistributionsNegBinomial2 : public AgradDistributionTest {
public:
void valid_values(vector<vector<double> >& parameters,
vector<double>& log_prob) {
vector<double> param(3);
param[0] = 10; // n
param[1] = 2.0; // mu
param[2] = 1.5; // phi
parameters.push_back(param);
log_prob.push_back(-5.55873452880806); // expected log_prob
param[0] = 100; // n
param[1] = 3.0; // mu
param[2] = 3.5; // phi
parameters.push_back(param);
log_prob.push_back(-69.1303554183435); // expected log_prob
param[0] = 100; // n
param[1] = 4; // mu
param[2] = 200; // phi
parameters.push_back(param);
log_prob.push_back(-209.614066642678); // expected log_prob
}
void invalid_values(vector<size_t>& index, vector<double>& value) {
// n
index.push_back(0U);
value.push_back(-1);
// mu
index.push_back(1U);
value.push_back(-1);
// phi
index.push_back(2U);
value.push_back(-1);
}
template <class T_n, class T_location, class T_inv_scale, typename T3,
typename T4, typename T5>
stan::return_type_t<T_location, T_inv_scale> log_prob(const T_n& n,
const T_location& mu,
const T_inv_scale& phi,
const T3&, const T4&,
const T5&) {
return stan::math::neg_binomial_2_log(n, mu, phi);
}
template <bool propto, class T_n, class T_location, class T_inv_scale,
typename T3, typename T4, typename T5>
stan::return_type_t<T_location, T_inv_scale> log_prob(const T_n& n,
const T_location& mu,
const T_inv_scale& phi,
const T3&, const T4&,
const T5&) {
return stan::math::neg_binomial_2_log<propto>(n, mu, phi);
}
template <class T_n, class T_location, class T_inv_scale, typename T3,
typename T4, typename T5>
stan::return_type_t<T_location, T_inv_scale> log_prob_function(
const T_n& n, const T_location& mu, const T_inv_scale& phi, const T3&,
const T4&, const T5&) {
using stan::math::binomial_coefficient_log;
using stan::math::multiply_log;
using std::log;
if (n != 0)
return binomial_coefficient_log<
typename stan::scalar_type<T_inv_scale>::type>(n + phi - 1.0,
n)
+ multiply_log(n, mu) + multiply_log(phi, phi)
- (n + phi) * log(mu + phi);
return log(0.0);
}
};
| [
"[email protected]"
] | |
aed1165fd76e6d1211986aad5d8f743e03b4d34a | 36183993b144b873d4d53e7b0f0dfebedcb77730 | /GameDevelopment/AI Game Programming Wisdom/SourceCode/06 General Architectures/04 Christian/ierule.cpp | 6eedbee3c7db6cc12d4670227a7903152b22735c | [] | no_license | alecnunn/bookresources | b95bf62dda3eb9b0ba0fb4e56025c5c7b6d605c0 | 4562f6430af5afffde790c42d0f3a33176d8003b | refs/heads/master | 2020-04-12T22:28:54.275703 | 2018-12-22T09:00:31 | 2018-12-22T09:00:31 | 162,790,540 | 20 | 14 | null | null | null | null | UTF-8 | C++ | false | false | 559 | cpp |
#include "ierule.h"
#include "iegoal.h"
IERule::IERule ( IEExec * condition )
{
m_condition = condition;
m_goal = NULL;
m_fired = false;
}
IERule::~IERule ()
{
}
void IERule::setGoal ( IEGoal * goal )
{
m_goal = goal;
}
void IERule::setGoal ( char * name, char * lineInfo )
{
m_goalName = name;
m_lineInfo = lineInfo;
}
IEGoal * IERule::getGoal()
{
if ( m_type == IERule::Return )
{
return m_goal->m_lastGoal;
}
else
{
return m_goal;
}
}
void IERule::setType ( RuleType type )
{
m_type = type;
}
| [
"[email protected]"
] | |
f934522cbbee32df492013b41b224803983030f5 | 6b40e9dccf2edc767c44df3acd9b626fcd586b4d | /NT/admin/wmi/wbem/shell/atlui/cmprops/cmprops.cpp | c37f8df1e30999dae2e9847f7ba55281383567e8 | [] | no_license | jjzhang166/WinNT5_src_20201004 | 712894fcf94fb82c49e5cd09d719da00740e0436 | b2db264153b80fbb91ef5fc9f57b387e223dbfc2 | refs/heads/Win2K3 | 2023-08-12T01:31:59.670176 | 2021-10-14T15:14:37 | 2021-10-14T15:14:37 | 586,134,273 | 1 | 0 | null | 2023-01-07T03:47:45 | 2023-01-07T03:47:44 | null | UTF-8 | C++ | false | false | 2,061 | cpp | // Copyright (c) 1997-1999 Microsoft Corporation
// CMProps.cpp : Implementation of DLL Exports.
// Note: Proxy/Stub Information
// To build a separate proxy/stub DLL,
// run nmake -f CMPropsps.mk in the project directory.
#include "precomp.h"
#include "resource.h"
#include "initguid.h"
#include "CMProps.h"
#include "..\common\ServiceThread.h"
#include "CMProps_i.c"
#include "CMSnapin.h"
CExeModule _Module;
BEGIN_OBJECT_MAP(ObjectMap)
OBJECT_ENTRY(CLSID_CMSnapin, CCMSnapin)
OBJECT_ENTRY(CLSID_CMSnapinAbout, CCMSnapinAbout)
END_OBJECT_MAP()
/////////////////////////////////////////////////////////////////////////////
// DLL Entry Point
extern "C"
BOOL WINAPI DllMain(HINSTANCE hInstance, DWORD dwReason, LPVOID /*lpReserved*/)
{
if (dwReason == DLL_PROCESS_ATTACH)
{
_Module.Init(ObjectMap, hInstance);
CSnapInItem::Init();
DisableThreadLibraryCalls(hInstance);
}
else if (dwReason == DLL_PROCESS_DETACH)
{
_Module.Term();
}
return TRUE; // ok
}
/////////////////////////////////////////////////////////////////////////////
// Used to determine whether the DLL can be unloaded by OLE
STDAPI DllCanUnloadNow(void)
{
return (_Module.GetLockCount()==0) ? S_OK : S_FALSE;
}
/////////////////////////////////////////////////////////////////////////////
// Returns a class factory to create an object of the requested type
STDAPI DllGetClassObject(REFCLSID rclsid, REFIID riid, LPVOID* ppv)
{
return _Module.GetClassObject(rclsid, riid, ppv);
}
/////////////////////////////////////////////////////////////////////////////
// DllRegisterServer - Adds entries to the system registry
STDAPI DllRegisterServer(void)
{
// registers object, typelib and all interfaces in typelib
return _Module.RegisterServer(TRUE);
}
/////////////////////////////////////////////////////////////////////////////
// DllUnregisterServer - Removes entries from the system registry
STDAPI DllUnregisterServer(void)
{
_Module.UnregisterServer();
return S_OK;
}
| [
"[email protected]"
] | |
234dc4d12d547e3f8518ffebebb039457ebb23c3 | 01fcc3838359a0d5629d78fc957a0ec7a3dd0006 | /main.cpp | 33d945aa386ca814b7bbf5f8f0b4859c71de8e42 | [] | no_license | raag27/Simple-SIC-absolute-loader | ac78623d20cd45987ce8558272586f06defd9c8c | 0077ad91c28ce6ce2028da487e930d88248c9946 | refs/heads/master | 2021-04-09T16:12:13.505530 | 2016-05-07T10:01:40 | 2016-05-07T10:01:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,362 | cpp | //*+++++++++++++++++++++++++++++++++++++++++*//
// ~~~~~ @VIN@SH ~~~~~ //
// ~~~~ IIEST SHIBPUR ~~~~ //
//*+++++++++++++++++++++++++++++++++++++++++*//
/*============================= A SIMPLE ABSOLUTE LOADER FOR SIC MACHINE ==============================*/
#include <windows.h>
#include <exception>
#include <iostream>
#include <fstream>
#include <cstddef>
#include <cassert>
#include <cstdlib>
#include <cstring>
#include <cstdlib>
#include <vector>
using namespace std;
#include "AbsoluteLoader.hpp"
int main() {
try {
int MEM_SZ = 0x8000; // total memory of an SIC machine is 2^15 ,i.e.,0x8000
string FileName = "OBJECT.txt"; // default file name
string MemoryName = "COPY"; // default program name
cout << "\nEnter the object file name : ";
cin >> FileName;
cout << "\nEnter the name of the program : ";
cin >> MemoryName;
AbsoluteLoader Loader(MEM_SZ,FileName,MemoryName);
Loader.LoadIntoMemory();
Loader.DisplayMemoryMapping();
cout << "\nPROGRAM EXECUTED SUCCESSFULLY !!!\n\n";
cout << "Check the OUTPUT.txt file.\n";
}
catch(const char* msg) {
cerr << msg << endl;
}
return 0;
}
/*========================================================================================================*/
| [
"[email protected]"
] | |
1d78d94640823f7d11a92f69ccc7cb451e0c0f32 | 0a8a08725556fc55b69c58cdda0a9b2f2819d39f | /Game_SE102.J31/SplittingPlatform.h | 05c1f6b04ddc689de3d52dc945197bae606c0024 | [] | no_license | thinhdat1999/UIT_GAME_HKI_HE | e07c5b42a025b08ba5b9f8107fc09e5c09d3deb9 | d697ab2e15119148b55f62a74c3bc202de853c34 | refs/heads/master | 2020-06-23T10:25:33.815095 | 2019-08-14T07:41:29 | 2019-08-14T07:41:29 | 198,595,508 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 336 | h | #pragma once
#include "Enemy.h"
class SplittingPlatform : public Enemy {
public:
float delayTime;
bool isHasPlayerOn;
Platform *platform;
SplittingPlatform();
~SplittingPlatform() {}
void UpdateDistance(float dt);
void Update(float dt);
void Render(float cameraX = 0, float cameraY = 0);
void ChangeState(State StateName);
}; | [
"[email protected]"
] | |
8afe8fa17b46ae6371307519e24334f63e0cdd7e | 54218a62fe028f9edef8901b217af9735daaee8c | /RC_Prepare/RC_bluetooth_piezo/RC_bluetooth_piezo.ino | f7086fa6666a407f3c2195423c7d1816ddde8e94 | [] | no_license | xururuca82/RC-CAR | 5e6de616f62d8ef91cd266a440d7d8d21af5b2db | 96015a87d576c2b3f75fce97c7bf6a82bf93d9f2 | refs/heads/master | 2020-04-19T01:33:16.748084 | 2019-05-06T00:04:53 | 2019-05-06T00:04:53 | 167,874,998 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 412 | ino | #define C 262 // 도
#define D 294 // 레
int piezoPin = 4;
int tempo = 200;
int notes[2] = {C,D};
void setup() {
Serial.begin(9600);
pinMode(piezoPin, OUTPUT);
}
void loop() {
char inputSignal = Serial.read();
if(Serial.available()){
Serial.write(inputSignal);
}
if(inputSignal=='4'){
for(int i=0; i<2; i++){
tone(piezoPin, notes[i], tempo);
delay(300);
}
}
}
| [
"[email protected]"
] | |
70462cd4c602b07f3411c01d0f3570f28029611a | 026af1cf32ca6ae9f14e638c477b6bf556468ee9 | /tms_rc/tms_rc_double/vitalmonitor/OpenNI/OniEnums.h | 018f22271bc4133f329773ed117179a57aa68b64 | [] | permissive | irvs/ros_tms | f2449fc2d51e369bd962398aded8e1829a314b16 | 3d6b6579e89aa9cb216cd3cb6157fabc553c18f1 | refs/heads/develop | 2023-01-28T03:29:27.004140 | 2020-02-22T04:53:33 | 2020-02-22T04:53:33 | 24,835,814 | 56 | 24 | BSD-3-Clause | 2023-01-11T22:23:41 | 2014-10-06T06:19:21 | TSQL | UTF-8 | C++ | false | false | 2,775 | h | /*****************************************************************************
* *
* OpenNI 2.x Alpha *
* Copyright (C) 2012 PrimeSense Ltd. *
* *
* This file is part of OpenNI. *
* *
* Licensed under the Apache License, Version 2.0 (the "License"); *
* you may not use this file except in compliance with the License. *
* You may obtain a copy of the License at *
* *
* http://www.apache.org/licenses/LICENSE-2.0 *
* *
* Unless required by applicable law or agreed to in writing, software *
* distributed under the License is distributed on an "AS IS" BASIS, *
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. *
* See the License for the specific language governing permissions and *
* limitations under the License. *
* *
*****************************************************************************/
#ifndef _ONI_ENUMS_H_
#define _ONI_ENUMS_H_
namespace openni
{
/** Possible failure values */
typedef enum
{
STATUS_OK = 0,
STATUS_ERROR = 1,
STATUS_NOT_IMPLEMENTED = 2,
STATUS_NOT_SUPPORTED = 3,
STATUS_BAD_PARAMETER = 4,
STATUS_OUT_OF_FLOW = 5,
STATUS_NO_DEVICE = 6,
STATUS_TIME_OUT = 102,
} Status;
/** The source of the stream */
typedef enum
{
SENSOR_IR = 1,
SENSOR_COLOR = 2,
SENSOR_DEPTH = 3,
} SensorType;
/** All available formats of the output of a stream */
typedef enum
{
// Depth
PIXEL_FORMAT_DEPTH_1_MM = 100,
PIXEL_FORMAT_DEPTH_100_UM = 101,
PIXEL_FORMAT_SHIFT_9_2 = 102,
PIXEL_FORMAT_SHIFT_9_3 = 103,
// Color
PIXEL_FORMAT_RGB888 = 200,
PIXEL_FORMAT_YUV422 = 201,
PIXEL_FORMAT_GRAY8 = 202,
PIXEL_FORMAT_GRAY16 = 203,
PIXEL_FORMAT_JPEG = 204,
PIXEL_FORMAT_YUYV = 205,
} PixelFormat;
typedef enum
{
DEVICE_STATE_OK = 0,
DEVICE_STATE_ERROR = 1,
DEVICE_STATE_NOT_READY = 2,
DEVICE_STATE_EOF = 3
} DeviceState;
typedef enum
{
IMAGE_REGISTRATION_OFF = 0,
IMAGE_REGISTRATION_DEPTH_TO_COLOR = 1,
} ImageRegistrationMode;
static const int TIMEOUT_NONE = 0;
static const int TIMEOUT_FOREVER = -1;
} // namespace openni
#endif // _ONI_ENUMS_H_
| [
"[email protected]"
] | |
98c3cfff1a7f20263b90a15a45be6a76d29de075 | 7fa051e192bc69fbaf99203a2154d43d8334a0fa | /mp_intro/cs225/HSLAPixel.h | 56e394452bc2e5f6b4ba3cf74ab393df266b1df0 | [] | no_license | xiaot6/Data_Structure_Projects | f04057914bc870c3bdee30f9d37c72f1ed055531 | b0a14d0def08b3bba5f48069a6f4ef343f5b0557 | refs/heads/master | 2022-12-22T20:25:15.555416 | 2020-10-04T22:10:27 | 2020-10-04T22:10:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 479 | h | /**
* @file HSLAPixel.h
*
* @author CS 225: Data Structures
*/
#pragma once
#include <iostream>
#include <sstream>
namespace cs225 {
class HSLAPixel{
public:
HSLAPixel();
HSLAPixel(double hue, double saturation, double luminance);
HSLAPixel(double hue, double saturation, double luminance,double alpha);
double h; //[0, 360)
double s; //[0, 1].
double l; //[0, 1].
double a; //[0, 1].
private:
};
};
| [
"[email protected]"
] | |
61a9f7d5541ee2c458229f5803deac2be88d82e3 | 080d949bbd6aa4e05a5ede553f94d3c7a13544a2 | /Project2/p6/Runway.cpp | 2ff5b20780f524e662791a7227e1a5422ea73ef7 | [] | no_license | tanxiaosysu/Lectures_DataStructures | 58a44e21008c17fdde3e464c7c7a5fd39f24df3a | 8c145df4359f7a74753f685e1a593307eccbb7d7 | refs/heads/master | 2021-01-01T05:51:52.742620 | 2014-11-19T12:12:17 | 2014-11-19T12:12:17 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,601 | cpp | /*
* Runway.cpp
* Created on: 2014年11月3日
* Author: TanXiao
*/
#include "Runway.h"
Runway::Runway(int limit)
/*
Post: The Runway data members are initialized to record no prior Runway use
and to record the limit on queue sizes.
*/
{
queue_limit = limit;
num_land_requests = num_takeoff_requests = 0;
num_landings = num_takeoffs = 0;
num_land_refused = num_takeoff_refused = 0;
num_land_accepted = num_takeoff_accepted = 0;
land_wait = takeoff_wait = idle_time = 0;
}
Error_code Runway::can_land(const Plane ¤t)
/*
Post: If possible, the Plane current is added to the landing Queue; otherwise,
an Error_code of overflow is returned. The Runway statistics are updated.
Uses: class Extended_queue.
*/
{
Error_code result;
if (landing.size() < queue_limit)
result = landing.append(current);
else
result = fail;
num_land_requests++;
if (result != success)
num_land_refused++;
else
num_land_accepted++;
return result;
}
Error_code Runway::can_depart(const Plane ¤t)
/* Post: If possible, the Plane current is added to the takeoff Queue;
otherwise, an Error_code of overflow is returned. The Runway statistics
are updated.
Uses: class Extended_queue.
*/
{
Error_code result;
if (_takeoff.size() < queue_limit)
result = _takeoff.append(current);
else
result = fail;
num_takeoff_requests++;
if (result != success)
num_takeoff_refused++;
else
num_takeoff_accepted++;
return result;
}
Runway_activity Runway::activity(int time, Plane &moving)
/* Post: If the landing Queue has entries, its front Plane is copied to the
parameter moving and a result land is returned. Otherwise, if the takeoff Queue
has entries, its front Plane is copied to the parameter moving and a result
takeoff is returned. Otherwise, idle is returned. Runway statistics are
updated.
Uses: class Extended_queue.
*/
{
Runway_activity in_progress;
if (!landing.empty()) {
landing.retrieve(moving);
land_wait += time - moving.started();
num_landings++;
in_progress = land;
landing.serve();
} else if (!_takeoff.empty()) {
_takeoff.retrieve(moving);
takeoff_wait += time - moving.started();
num_takeoffs++;
in_progress = takeoff;
_takeoff.serve();
} else {
idle_time++;
in_progress = idle;
}
return in_progress;
}
void Runway::shut_down(int time) const
/* Post: Runway usage statistics are summarized and printed. */
{
std::cout << "Simulation has concluded after " << time << " time units."
<< std::endl << "Total number of planes processed "
<< (num_land_requests + num_takeoff_requests) << std::endl
<< "Total number of planes asking to land " << num_land_requests
<< std::endl << "Total number of planes asking to take off "
<< num_takeoff_requests << std::endl
<< "Total number of planes accepted for landing "
<< num_land_accepted << std::endl
<< "Total number of planes accepted for takeoff "
<< num_takeoff_accepted << std::endl
<< "Total number of planes refused for landing " << num_land_refused
<< std::endl << "Total number of planes refused for takeoff "
<< num_takeoff_refused << std::endl
<< "Total number of planes that landed " << num_landings
<< std::endl << "Total number of planes that took off "
<< num_takeoffs << std::endl
<< "Total number of planes left in landing queue " << landing.size()
<< std::endl << "Total number of planes left in takeoff queue "
<< _takeoff.size() << std::endl;
std::cout << "Percentage of time runway idle "
<< 100.0 * ((float) idle_time) / ((float) time) << "%" << std::endl;
std::cout << "Average wait in landing queue "
<< ((float) land_wait) / ((float) num_landings) << " time units"
<< std::endl;
std::cout << "Average wait in takeoff queue "
<< ((float) takeoff_wait) / ((float) num_takeoffs) << " time units"
<< std::endl;
std::cout << "Average observed rate of planes wanting to land "
<< ((float) num_land_requests) / ((float) time) << " per time unit"
<< std::endl;
std::cout << "Average observed rate of planes wanting to take off "
<< ((float) num_takeoff_requests) / ((float) time)
<< " per time unit" << std::endl;
}
| [
"[email protected]"
] | |
e54d9496a640e48fd85286d45da09256b67418fa | c8f3687e8cac43a45deb8f023693795a12f5b288 | /zh/bor/main2.cpp | d64ca424f60b615d9e8fc9996204852899aa3326 | [] | no_license | 8emi95/elte-ik-progalap | 116050aff96a631df99353feba3d6b1a183e0a50 | 16f184689b610d1939dd3f781a8272a77e8cadc7 | refs/heads/master | 2020-07-25T09:10:54.255091 | 2019-02-18T21:00:06 | 2019-02-18T21:00:06 | 171,355,340 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,058 | cpp | #include <iostream>
using namespace std;
const int MAXN = 100;
typedef struct
{
int mennyiseg;
int ar;
}bor;
void beolvas(int &N, bor borok[MAXN])
{
cin >> N;
for(int i = 0; i < N; i++)
{
cin >> borok[i].mennyiseg;
cin >> borok[i].ar;
}
}
int A_feladat(int &N, bor borok[MAXN])
{
int legkevesebb = 0;
for(int i = 1 ; i < N ; i++)
{
if(borok[i].mennyiseg < borok[legkevesebb].mennyiseg)
{
legkevesebb = i;
}
}
return legkevesebb+1;
}
int B_feladat(int &N , bor borok[MAXN])
{
int legdragabb = 0;
for (int i = N-1 ; i >= 0 ; i--)
{
if(borok[i].mennyiseg > 1000)
{
legdragabb = i;
}
}
for(int i = 0; i < N; i++)
{
if(borok[i].mennyiseg > 1000 && borok[i].ar > borok[legdragabb].ar)
{
legdragabb = i;
}
}
if(borok[legdragabb].mennyiseg < 1000)
{
legdragabb = -1;
}
else
{
legdragabb = borok[legdragabb].ar;
}
return legdragabb;
}
int C_feladat(int &N, bor borok[MAXN])
{
int hanyfele = 1;
for(int i = 1, j = 0; i < N;i++)
{
while(j < i && borok[i].ar != borok[j].ar)
{
j++;
};
if(i==j)
{
hanyfele++;
}
j = 0;
}
return hanyfele;
}
void D_feladat(int &N, bor borok[MAXN])
{
int szamuk[MAXN];
int szamdb=0;
for(int i = 1,j = 0; i < N; i++)
{
while(j < i && borok[j].mennyiseg < borok[i].mennyiseg)
{
j++;
};
if(j==i)
{
szamuk[szamdb]=i+1;
szamdb++;
}
j = 0;
}
cout << szamdb << " ";
for(int i = 0; i < szamdb ; i++)
{
cout << szamuk[i] <<" ";
}
}
int main()
{
bor borok[MAXN];
int N;
beolvas(N, borok);
cout << A_feladat(N, borok) << endl;
cout << B_feladat(N, borok) << endl;
cout << C_feladat(N, borok) << endl;
D_feladat(N, borok);
return 0;
}
| [
"[email protected]"
] | |
864e41a975aaf6ef57488f62b4063a70188cebd2 | 91a882547e393d4c4946a6c2c99186b5f72122dd | /Source/XPSP1/NT/ds/adsi/nwnds/cenumt.cxx | 6dd67f5796d9546bc0f70d0dc4ee2871904ad678 | [] | no_license | IAmAnubhavSaini/cryptoAlgorithm-nt5src | 94f9b46f101b983954ac6e453d0cf8d02aa76fc7 | d9e1cdeec650b9d6d3ce63f9f0abe50dabfaf9e2 | refs/heads/master | 2023-09-02T10:14:14.795579 | 2021-11-20T13:47:06 | 2021-11-20T13:47:06 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 10,325 | cxx | //---------------------------------------------------------------------------
//
// Microsoft Windows
// Copyright (C) Microsoft Corporation, 1992 - 1995
//
// File: cenumdom.cxx
//
// Contents: NDS Object Enumeration Code
//
// CNDSTreeEnum::CNDSTreeEnum()
// CNDSTreeEnum::CNDSTreeEnum
// CNDSTreeEnum::EnumObjects
// CNDSTreeEnum::EnumObjects
//
// History:
//----------------------------------------------------------------------------
#include "NDS.hxx"
#pragma hdrstop
//+---------------------------------------------------------------------------
//
// Function: CNDSEnumVariant::Create
//
// Synopsis:
//
// Arguments: [pCollection]
// [ppEnumVariant]
//
// Returns: HRESULT
//
// Modifies:
//
// History: 01-30-95 krishnag Created.
//
//----------------------------------------------------------------------------
HRESULT
CNDSTreeEnum::Create(
CNDSTreeEnum FAR* FAR* ppenumvariant,
BSTR ADsPath,
VARIANT var,
CCredentials& Credentials
)
{
HRESULT hr = NOERROR;
CNDSTreeEnum FAR* penumvariant = NULL;
WCHAR szObjectFullName[MAX_PATH];
WCHAR szObjectClassName[MAX_PATH];
LPWSTR pszTreeName = NULL, pszDn = NULL;
DWORD dwModificationTime = 0L;
DWORD dwNumberOfEntries = 0L;
DWORD dwStatus = 0L;
*ppenumvariant = NULL;
penumvariant = new CNDSTreeEnum();
if (!penumvariant) {
hr = E_OUTOFMEMORY;
BAIL_ON_FAILURE(hr);
}
hr = ADsAllocString( ADsPath, &penumvariant->_ADsPath);
BAIL_ON_FAILURE(hr);
hr = BuildNDSFilterArray(
var,
(LPBYTE *)&penumvariant->_pNdsFilterList
);
if (FAILED(hr)) {
penumvariant->_pNdsFilterList = NULL;
}
/*
hr = ObjectTypeList::CreateObjectTypeList(
var,
&penumvariant->_pObjList
);
BAIL_ON_FAILURE(hr);
*/
penumvariant->_Credentials = Credentials;
*ppenumvariant = penumvariant;
hr = BuildNDSPathFromADsPath2(
ADsPath,
&pszTreeName,
&pszDn
);
BAIL_ON_FAILURE(hr);
hr = ADsNdsOpenContext(
pszTreeName,
Credentials,
&penumvariant->_hADsContext
);
if (pszTreeName) {
FreeADsStr(pszTreeName);
}
if (pszDn) {
FreeADsStr(pszDn);
}
RRETURN(hr);
error:
if (penumvariant) {
}
delete penumvariant;
*ppenumvariant = NULL;
if (pszTreeName) {
FreeADsStr(pszTreeName);
}
if (pszDn) {
FreeADsStr(pszDn);
}
RRETURN(hr);
}
CNDSTreeEnum::CNDSTreeEnum():
_ADsPath(NULL)
{
_pObjList = NULL;
_dwObjectReturned = 0;
_dwObjectCurrentEntry = 0;
_dwObjectTotal = 0;
_hADsContext = NULL;
_hOperationData = NULL;
_lpObjects = NULL;
_pNdsFilterList = NULL;
_fSchemaReturned = NULL;
_bNoMore = FALSE;
}
CNDSTreeEnum::~CNDSTreeEnum()
{
if (_ADsPath) {
ADsFreeString(_ADsPath);
}
if (_pNdsFilterList) {
FreeFilterList((LPBYTE)_pNdsFilterList);
}
if (_hADsContext) {
ADsNdsCloseContext(_hADsContext);
}
ADsNdsFreeNdsObjInfoList(_lpObjects, _dwObjectReturned);
}
HRESULT
CNDSTreeEnum::EnumObjects(
DWORD ObjectType,
ULONG cElements,
VARIANT FAR * pvar,
ULONG FAR * pcElementFetched
)
{
//
// Multi-level detection of Objects may not be necessary for NDS code
//
RRETURN(EnumGenericObjects(cElements, pvar, pcElementFetched));
//
// BugBug- commenting out this layer of code
//
/*
switch (ObjectType) {
default:
RRETURN(EnumObjects(cElements, pvar, pcElementFetched));
} */
}
HRESULT
CNDSTreeEnum::EnumObjects(
ULONG cElements,
VARIANT FAR* pvar,
ULONG FAR* pcElementFetched
)
{
DWORD i;
ULONG cRequested = 0;
ULONG cFetchedByPath = 0;
ULONG cTotalFetched = 0;
VARIANT FAR* pPathvar = pvar;
HRESULT hr;
DWORD ObjectType;
for (i = 0; i < cElements; i++) {
VariantInit(&pvar[i]);
}
cRequested = cElements;
while (SUCCEEDED(_pObjList->GetCurrentObject(&ObjectType)) &&
((hr = EnumObjects(ObjectType,
cRequested,
pPathvar,
&cFetchedByPath)) == S_FALSE )) {
pPathvar += cFetchedByPath;
cRequested -= cFetchedByPath;
cTotalFetched += cFetchedByPath;
cFetchedByPath = 0;
if (FAILED(_pObjList->Next())){
if (pcElementFetched)
*pcElementFetched = cTotalFetched;
RRETURN(S_FALSE);
}
}
if (pcElementFetched) {
*pcElementFetched = cTotalFetched + cFetchedByPath;
}
RRETURN(hr);
}
HRESULT
CNDSTreeEnum::EnumGenericObjects(
ULONG cElements,
VARIANT FAR* pvar,
ULONG FAR* pcElementFetched
)
{
HRESULT hr = S_OK;
IDispatch *pDispatch = NULL;
DWORD i = 0;
while (i < cElements) {
hr = GetGenObject(&pDispatch);
if (hr == S_FALSE) {
break;
}
VariantInit(&pvar[i]);
pvar[i].vt = VT_DISPATCH;
pvar[i].pdispVal = pDispatch;
(*pcElementFetched)++;
i++;
}
return(hr);
}
HRESULT
CNDSTreeEnum::GetGenObject(
IDispatch ** ppDispatch
)
{
HRESULT hr = S_OK;
DWORD dwStatus = 0L;
PADSNDS_OBJECT_INFO lpCurrentObject = NULL;
IADs * pADs = NULL;
*ppDispatch = NULL;
if (!_hOperationData || (_dwObjectCurrentEntry == _dwObjectReturned)) {
if (_hOperationData) {
ADsNdsFreeNdsObjInfoList(_lpObjects, _dwObjectReturned);
_lpObjects = NULL;
}
_dwObjectCurrentEntry = 0;
_dwObjectReturned = 0;
if (_bNoMore) {
hr = S_FALSE;
goto error;
}
hr = ADsNdsListObjects(
_hADsContext,
L"[Root]",
L"",
L"",
NULL,
FALSE,
&_hOperationData
);
BAIL_ON_FAILURE(hr);
if (hr == S_ADS_NOMORE_ROWS) {
_bNoMore = TRUE;
}
hr = ADsNdsGetObjectListFromBuffer(
_hADsContext,
_hOperationData,
&_dwObjectReturned,
&_lpObjects
);
BAIL_ON_FAILURE(hr);
if (_dwObjectReturned == 0 ) {
RRETURN (S_FALSE);
goto error;
}
}
//
// Now send back the current object
//
lpCurrentObject = _lpObjects + _dwObjectCurrentEntry;
//
// Bump up the object count. The instantiation of this object
// may fail; if we come into this function again, we do not want
// to pick up the same object.
//
_dwObjectCurrentEntry++;
hr = CNDSGenObject::CreateGenericObject(
_ADsPath,
lpCurrentObject->szObjectName,
lpCurrentObject->szObjectClass,
_Credentials,
ADS_OBJECT_BOUND,
IID_IADs,
(void **)&pADs
);
BAIL_ON_FAILURE(hr);
//
// InstantiateDerivedObject should addref this pointer for us.
//
hr = InstantiateDerivedObject(
pADs,
_Credentials,
IID_IDispatch,
(void **)ppDispatch
);
if (FAILED(hr)) {
hr = pADs->QueryInterface(
IID_IDispatch,
(void **)ppDispatch
);
BAIL_ON_FAILURE(hr);
}
error:
if (hr == S_FALSE) {
ADsNdsFreeBuffer(_hOperationData);
_hOperationData = NULL;
}
//
// GetGenObject returns only S_FALSE
//
if (FAILED(hr)) {
hr = S_FALSE;
}
//
// Free the intermediate pADs pointer.
//
if (pADs) {
pADs->Release();
}
RRETURN(hr);
}
//+---------------------------------------------------------------------------
//
// Function: CNDSTreeEnum::Next
//
// Synopsis: Returns cElements number of requested NetOle objects in the
// array supplied in pvar.
//
// Arguments: [cElements] -- The number of elements requested by client
// [pvar] -- ptr to array of VARIANTs to for return objects
// [pcElementFetched] -- if non-NULL, then number of elements
// -- actually returned is placed here
//
// Returns: HRESULT -- S_OK if number of elements requested are returned
// -- S_FALSE if number of elements is < requested
//
// Modifies:
//
// History: 11-3-95 krishnag Created.
//
//----------------------------------------------------------------------------
STDMETHODIMP
CNDSTreeEnum::Next(
ULONG cElements,
VARIANT FAR* pvar,
ULONG FAR* pcElementFetched
)
{
ULONG cElementFetched = 0;
HRESULT hr = S_OK;
hr = EnumGenericObjects(
cElements,
pvar,
&cElementFetched
);
if (pcElementFetched) {
*pcElementFetched = cElementFetched;
}
RRETURN(hr);
}
HRESULT
CNDSTreeEnum::EnumSchema(
ULONG cElements,
VARIANT FAR* pvar,
ULONG FAR* pcElementFetched
)
{
HRESULT hr = S_OK;
IDispatch *pDispatch = NULL;
if ( _fSchemaReturned )
RRETURN(S_FALSE);
if ( cElements > 0 )
{
hr = CNDSSchema::CreateSchema(
_ADsPath,
TEXT("Schema"),
_Credentials,
ADS_OBJECT_BOUND,
IID_IDispatch,
(void **)&pDispatch
);
if ( hr == S_OK )
{
VariantInit(&pvar[0]);
pvar[0].vt = VT_DISPATCH;
pvar[0].pdispVal = pDispatch;
(*pcElementFetched)++;
_fSchemaReturned = TRUE;
}
}
RRETURN(hr);
}
| [
"[email protected]"
] | |
517d6c36514220161cbd5b07d5eb8ef342ebcd01 | de2b445d31b67be34093cc15ef3f020a299928dc | /cpp/ABC/abc203/e/main.cpp | 9226145064c5aba0da9fd0cfcdd503eb625ba436 | [
"MIT"
] | permissive | KATO-Hiro/atcoder-1 | 7d45abb7f5d3cef7e8733a216a334c9c66889b71 | c2cbfcfd5c3d46ac9810ba330a37d437aa2839c2 | refs/heads/master | 2023-06-23T09:25:53.545274 | 2021-07-25T14:20:01 | 2021-07-25T14:20:01 | 339,631,102 | 0 | 0 | MIT | 2021-07-25T16:56:58 | 2021-02-17T06:25:11 | C++ | UTF-8 | C++ | false | false | 3,316 | cpp | #include <bits/stdc++.h>
using namespace std;
using ll = long long;
using ld = long double;
// --------------------------------------------------------
template<class T> bool chmax(T& a, const T b) { if (a < b) { a = b; return 1; } return 0; }
template<class T> bool chmin(T& a, const T b) { if (b < a) { a = b; return 1; } return 0; }
#define FOR(i,l,r) for (ll i = (l); i < (r); ++i)
#define RFOR(i,l,r) for (ll i = (r)-1; (l) <= i; --i)
#define REP(i,n) FOR(i,0,n)
#define RREP(i,n) RFOR(i,0,n)
#define ALL(c) (c).begin(), (c).end()
#define RALL(c) (c).rbegin(), (c).rend()
#define SORT(c) sort(ALL(c))
#define RSORT(c) sort(RALL(c))
#define MIN(c) *min_element(ALL(c))
#define MAX(c) *max_element(ALL(c))
#define SUMLL(c) accumulate(ALL(c), 0LL)
#define COUNT(c,v) count(ALL(c),(v))
#define SZ(c) ((ll)(c).size())
#define BIT(b,i) (((b)>>(i)) & 1)
#define PCNT(b) __builtin_popcountll(b)
#define CIN(c) cin >> (c)
#define COUT(c) cout << (c) << '\n'
#define debug(x) cerr << "l." << __LINE__ << " : " << #x << " = " << (x) << '\n'
ll llceil(ll a, ll b) { return (a + b - 1) / b; }
ll bitlen(ll b) { if (b <= 0) { return 0; } return (64LL - __builtin_clzll(b)); }
string toupper(const string& S) { string T(S); REP(i,SZ(T)) T[i] = toupper(T[i]); return T; }
string tolower(const string& S) { string T(S); REP(i,SZ(T)) T[i] = tolower(T[i]); return T; }
template<class T> void cout_line(const vector<T>& ans, ll l, ll r) { for (ll i = l; i < r; i++) { if (i != l) { cout << " "; } cout << ans[i]; } cout << '\n'; }
template<class T> void debug_line(const vector<T>& ans, ll l, ll r, ll L = 0) { cerr << "l." << L << " :"; for (ll i = l; i < r; i++) { cerr << " " << ans[i]; } cerr << '\n'; }
using P = pair<ll,ll>;
using VP = vector<P>;
using VVP = vector<VP>;
using VS = vector<string>;
using VVS = vector<VS>;
using VLL = vector<ll>;
using VVLL = vector<VLL>;
using VVVLL = vector<VVLL>;
using VB = vector<bool>;
using VVB = vector<VB>;
using VVVB = vector<VVB>;
using VD = vector<double>;
using VVD = vector<VD>;
using VVVD = vector<VVD>;
using VLD = vector<ld>;
using VVLD = vector<VLD>;
using VVVLD = vector<VVLD>;
static const double EPS = 1e-10;
static const double PI = acos(-1.0);
static const ll MOD = 1000000007;
// static const ll MOD = 998244353;
static const ll INF = (1LL << 62) - 1; // 4611686018427387904 - 1
// --------------------------------------------------------
// #include <atcoder/all>
// using namespace atcoder;
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cout << fixed << setprecision(15);
ll N, M; cin >> N >> M;
map<ll,VLL> E;
REP(_,M) {
ll X, Y; cin >> X >> Y;
E[X].push_back(Y);
}
set<ll> S;
S.insert(N);
for (auto& [x, YY] : E) {
VP Q;
for (ll y : YY) {
if (S.count(y)) {
if (S.count(y-1)) continue;
if (S.count(y+1)) continue;
Q.push_back(P(y,-1));
} else {
if (S.count(y-1) || S.count(y+1)) {
Q.push_back(P(y,+1));
}
}
}
for (auto [y, q] : Q) {
if (q == -1) {
S.erase(y);
} else {
S.insert(y);
}
}
}
ll ans = SZ(S);
COUT(ans);
return 0;
}
| [
"[email protected]"
] | |
301ffbb1dd98d56b65172b314f784ed8fdd0604a | 6b2a8dd202fdce77c971c412717e305e1caaac51 | /solutions_2453486_1/C++/centipede80/GCJ2013Qual1.cpp | a3f65f59fb12ab30c97e17fb7d7551fad5151ee7 | [] | no_license | alexandraback/datacollection | 0bc67a9ace00abbc843f4912562f3a064992e0e9 | 076a7bc7693f3abf07bfdbdac838cb4ef65ccfcf | refs/heads/master | 2021-01-24T18:27:24.417992 | 2017-05-23T09:23:38 | 2017-05-23T09:23:38 | 84,313,442 | 2 | 4 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 2,020 | cpp | // GCJ 2011 Qual 1.cpp : main project file.
// Test.cpp : main project file.
#include "stdafx.h"
#include <iostream>
#include <vector>
#include <string>
#include <fstream>
#include <sstream>
#include <math.h>
#include <map>
#include <set>
using namespace std;
/*
•"X won" (the game is over, and X won)
•"O won" (the game is over, and O won)
•"Draw" (the game is over, and it ended in a draw)
•"Game has not completed" (the game is not over yet)
*/
string doit(vector<string> rows) {
for(int i=0;i<4;i++) cout<<rows[i]<<endl;
vector<int> startX, startY, dirX, dirY;
for(int i=0;i<4;i++) {
startX.push_back(0);
startY.push_back(i);
dirX.push_back(1);
dirY.push_back(0);
startX.push_back(i);
startY.push_back(0);
dirX.push_back(0);
dirY.push_back(1);
}
startX.push_back(0);
startY.push_back(0);
dirX.push_back(1);
dirY.push_back(1);
startX.push_back(0);
startY.push_back(3);
dirX.push_back(1);
dirY.push_back(-1);
for(int i=0;i<dirX.size();i++) {
int countX=0,countO=0;
for(int j=0;j<4;j++) {
int x=startX[i]+dirX[i]*j;
int y=startY[i]+dirY[i]*j;
char c = rows[y][x];
if(c=='X') countX++;
else if(c=='O') countO++;
else if(c=='T') { countX++; countO++; }
}
if(countX==4) return "X won";
if(countO==4) return "O won";
}
bool draw=true;
for(int i=0;i<4;i++) for(int j=0;j<4;j++) if(rows[i][j]=='.') draw=false;
if(draw) return "Draw";
return "Game has not completed";
}
int main()
{
ifstream infile;
string prefix = "A-large";
infile.open(prefix + ".in");
ofstream outfile(prefix + ".out");
int cases;
if (infile.is_open()) {
infile>>cases;
}
else {
return 0;
}
for(int i=0;i<cases;i++) {
vector<string> rows;
for(int j=0;j<4;j++) {
string row;
infile>>row;
rows.push_back(row);
}
outfile << "Case #" << (i+1) << ": " << doit(rows) << endl;
}
cout<<"DONE"<<endl;
string zzz;
cin>>zzz;
outfile.close();
return 0;
} | [
"[email protected]"
] | |
4c3d4f753174192347535e317653e0af121d8a6f | c2b2828b32a846f5e7923aae379db87170b6318b | /GOESP/ImGuiCustom.cpp | 89fba4f3d9c0b257258ae0af0c8b60dcc80e3c7f | [
"MIT"
] | permissive | ORG-MARS/GOESP | 4ea4bd5593daefed92fd81e574796b2cebe77429 | cbe72a74a0ebadec98f343a8be05873a871aed47 | refs/heads/master | 2023-02-01T10:47:06.953995 | 2020-12-18T06:55:46 | 2020-12-18T06:55:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,972 | cpp | #include "ConfigStructs.h"
#include "ImGuiCustom.h"
#include "imgui/imgui.h"
#include "imgui/imgui_internal.h"
void ImGuiCustom::colorPopup(const char* name, std::array<float, 4>& color, bool* rainbow, float* rainbowSpeed, bool* enable, float* thickness, float* rounding) noexcept
{
ImGui::PushID(name);
if (enable) {
ImGui::Checkbox("##check", enable);
ImGui::SameLine(0.0f, 5.0f);
}
bool openPopup = ImGui::ColorButton("##btn", color, ImGuiColorEditFlags_NoTooltip | ImGuiColorEditFlags_AlphaPreview);
if (ImGui::BeginDragDropTarget()) {
if (const ImGuiPayload* payload = ImGui::AcceptDragDropPayload(IMGUI_PAYLOAD_TYPE_COLOR_4F))
color = *(std::array<float, 4>*)payload->Data;
ImGui::EndDragDropTarget();
}
ImGui::SameLine(0.0f, 5.0f);
ImGui::TextUnformatted(name);
if (openPopup)
ImGui::OpenPopup("##popup");
if (ImGui::BeginPopup("##popup")) {
ImGui::ColorPicker4("##picker", color.data(), ImGuiColorEditFlags_DisplayRGB | ImGuiColorEditFlags_NoSidePreview | ImGuiColorEditFlags_AlphaPreview | ImGuiColorEditFlags_AlphaBar);
if (rainbow || rainbowSpeed || thickness || rounding) {
ImGui::SameLine();
if (ImGui::BeginChild("##child", { 150.0f, 0.0f })) {
if (rainbow)
ImGui::Checkbox("Rainbow", rainbow);
ImGui::PushItemWidth(85.0f);
if (rainbowSpeed)
ImGui::InputFloat("Speed", rainbowSpeed, 0.01f, 0.15f, "%.2f");
if (rounding || thickness)
ImGui::Separator();
if (rounding) {
ImGui::InputFloat("Rounding", rounding, 0.1f, 0.0f, "%.1f");
*rounding = std::max(*rounding, 0.0f);
}
if (thickness) {
ImGui::InputFloat("Thickness", thickness, 0.1f, 0.0f, "%.1f");
*thickness = std::max(*thickness, 0.0f);
}
ImGui::PopItemWidth();
ImGui::EndChild();
}
}
ImGui::EndPopup();
}
ImGui::PopID();
}
void ImGuiCustom::colorPicker(const char* name, Color& colorConfig, bool* enable, float* thickness) noexcept
{
colorPopup(name, colorConfig.color, &colorConfig.rainbow, &colorConfig.rainbowSpeed, enable, thickness);
}
void ImGuiCustom::colorPicker(const char* name, ColorToggle& colorConfig) noexcept
{
colorPopup(name, colorConfig.color, &colorConfig.rainbow, &colorConfig.rainbowSpeed, &colorConfig.enabled);
}
void ImGuiCustom::colorPicker(const char* name, ColorToggleRounding& colorConfig) noexcept
{
colorPopup(name, colorConfig.color, &colorConfig.rainbow, &colorConfig.rainbowSpeed, &colorConfig.enabled, nullptr, &colorConfig.rounding);
}
void ImGuiCustom::colorPicker(const char* name, ColorToggleThickness& colorConfig) noexcept
{
colorPopup(name, colorConfig.color, &colorConfig.rainbow, &colorConfig.rainbowSpeed, &colorConfig.enabled, &colorConfig.thickness);
}
void ImGuiCustom::colorPicker(const char* name, ColorToggleThicknessRounding& colorConfig) noexcept
{
colorPopup(name, colorConfig.color, &colorConfig.rainbow, &colorConfig.rainbowSpeed, &colorConfig.enabled, &colorConfig.thickness, &colorConfig.rounding);
}
bool ImGui::smallButtonFullWidth(const char* label, bool disabled) noexcept
{
ImGuiContext& g = *GImGui;
float backup_padding_y = g.Style.FramePadding.y;
g.Style.FramePadding.y = 0.0f;
if (disabled)
PushStyleVar(ImGuiStyleVar_Alpha, ImGui::GetStyle().Alpha * 0.5f);
bool pressed = ButtonEx(label, ImVec2(-1, 0), ImGuiButtonFlags_AlignTextBaseLine | (disabled ? ImGuiButtonFlags_Disabled : 0));
if (disabled)
PopStyleVar();
g.Style.FramePadding.y = backup_padding_y;
return pressed;
}
bool ImGui::beginTable(const char* str_id, int columns_count, ImGuiTableFlags flags, const ImVec2& outer_size, float inner_width) noexcept
{
ImGuiID id = GetID(str_id);
return beginTableEx(str_id, id, columns_count, flags, outer_size, inner_width);
}
static const float TABLE_BORDER_SIZE = 1.0f;
inline ImGuiTableFlags TableFixFlags(ImGuiTableFlags flags, ImGuiWindow* outer_window)
{
// Adjust flags: set default sizing policy
if ((flags & (ImGuiTableFlags_ColumnsWidthStretch | ImGuiTableFlags_ColumnsWidthFixed)) == 0)
flags |= (flags & ImGuiTableFlags_ScrollX) ? ImGuiTableFlags_ColumnsWidthFixed : ImGuiTableFlags_ColumnsWidthStretch;
// Adjust flags: MultiSortable automatically enable Sortable
if (flags & ImGuiTableFlags_MultiSortable)
flags |= ImGuiTableFlags_Sortable;
// Adjust flags: disable Resizable when using SameWidths (done above enforcing BordersInnerV)
if (flags & ImGuiTableFlags_SameWidths)
flags = (flags & ~ImGuiTableFlags_Resizable) | ImGuiTableFlags_NoKeepColumnsVisible;
// Adjust flags: enforce borders when resizable
if (flags & ImGuiTableFlags_Resizable)
flags |= ImGuiTableFlags_BordersInnerV;
// Adjust flags: disable NoHostExtendY if we have any scrolling going on
if ((flags & ImGuiTableFlags_NoHostExtendY) && (flags & (ImGuiTableFlags_ScrollX | ImGuiTableFlags_ScrollY)) != 0)
flags &= ~ImGuiTableFlags_NoHostExtendY;
// Adjust flags: NoBordersInBodyUntilResize takes priority over NoBordersInBody
if (flags & ImGuiTableFlags_NoBordersInBodyUntilResize)
flags &= ~ImGuiTableFlags_NoBordersInBody;
// Adjust flags: disable saved settings if there's nothing to save
if ((flags & (ImGuiTableFlags_Resizable | ImGuiTableFlags_Hideable | ImGuiTableFlags_Reorderable | ImGuiTableFlags_Sortable)) == 0)
flags |= ImGuiTableFlags_NoSavedSettings;
// Inherit _NoSavedSettings from top-level window (child windows always have _NoSavedSettings set)
#ifdef IMGUI_HAS_DOCK
ImGuiWindow* window_for_settings = outer_window->RootWindowDockStop;
#else
ImGuiWindow* window_for_settings = outer_window->RootWindow;
#endif
if (window_for_settings->Flags & ImGuiWindowFlags_NoSavedSettings)
flags |= ImGuiTableFlags_NoSavedSettings;
return flags;
}
bool ImGui::beginTableEx(const char* name, ImGuiID id, int columns_count, ImGuiTableFlags flags, const ImVec2& outer_size, float inner_width) noexcept
{
ImGuiContext& g = *GImGui;
ImGuiWindow* outer_window = GetCurrentWindow();
if (outer_window->SkipItems) // Consistent with other tables + beneficial side effect that assert on miscalling EndTable() will be more visible.
return false;
// Sanity checks
IM_ASSERT(columns_count > 0 && columns_count <= IMGUI_TABLE_MAX_COLUMNS && "Only 1..64 columns allowed!");
if (flags & ImGuiTableFlags_ScrollX)
IM_ASSERT(inner_width >= 0.0f);
// If an outer size is specified ahead we will be able to early out when not visible. Exact clipping rules may evolve.
const bool use_child_window = (flags & (ImGuiTableFlags_ScrollX | ImGuiTableFlags_ScrollY)) != 0;
const ImVec2 avail_size = GetContentRegionAvail();
ImVec2 actual_outer_size = CalcItemSize(outer_size, ImMax(avail_size.x, 1.0f), use_child_window ? ImMax(avail_size.y, 1.0f) : 0.0f);
ImRect outer_rect(outer_window->DC.CursorPos, outer_window->DC.CursorPos + actual_outer_size);
if (use_child_window && IsClippedEx(outer_rect, 0, false))
{
ItemSize(outer_rect);
return false;
}
// Acquire storage for the table
ImGuiTable* table = g.Tables.GetOrAddByKey(id);
const int instance_no = (table->LastFrameActive != g.FrameCount) ? 0 : table->InstanceCurrent + 1;
const ImGuiID instance_id = id + instance_no;
const ImGuiTableFlags table_last_flags = table->Flags;
if (instance_no > 0)
IM_ASSERT(table->ColumnsCount == columns_count && "BeginTable(): Cannot change columns count mid-frame while preserving same ID");
// Fix flags
flags = TableFixFlags(flags, outer_window);
// Initialize
table->ID = id;
table->Flags = flags;
table->InstanceCurrent = (ImS16)instance_no;
table->LastFrameActive = g.FrameCount;
table->OuterWindow = table->InnerWindow = outer_window;
table->ColumnsCount = columns_count;
table->IsLayoutLocked = false;
table->InnerWidth = inner_width;
table->OuterRect = outer_rect;
table->WorkRect = outer_rect;
// When not using a child window, WorkRect.Max will grow as we append contents.
if (use_child_window)
{
// Ensure no vertical scrollbar appears if we only want horizontal one, to make flag consistent
// (we have no other way to disable vertical scrollbar of a window while keeping the horizontal one showing)
ImVec2 override_content_size(FLT_MAX, FLT_MAX);
if ((flags & ImGuiTableFlags_ScrollX) && !(flags & ImGuiTableFlags_ScrollY))
override_content_size.y = FLT_MIN;
// Ensure specified width (when not specified, Stretched columns will act as if the width == OuterWidth and
// never lead to any scrolling). We don't handle inner_width < 0.0f, we could potentially use it to right-align
// based on the right side of the child window work rect, which would require knowing ahead if we are going to
// have decoration taking horizontal spaces (typically a vertical scrollbar).
if ((flags & ImGuiTableFlags_ScrollX) && inner_width > 0.0f)
override_content_size.x = inner_width;
if (override_content_size.x != FLT_MAX || override_content_size.y != FLT_MAX)
SetNextWindowContentSize(ImVec2(override_content_size.x != FLT_MAX ? override_content_size.x : 0.0f, override_content_size.y != FLT_MAX ? override_content_size.y : 0.0f));
// Create scrolling region (without border and zero window padding)
ImGuiWindowFlags child_flags = (flags & ImGuiTableFlags_ScrollX) ? ImGuiWindowFlags_HorizontalScrollbar : ImGuiWindowFlags_None;
child_flags |= (g.CurrentWindow->Flags & ImGuiWindowFlags_NoInputs);
BeginChildEx(name, instance_id, table->OuterRect.GetSize(), false, child_flags);
table->InnerWindow = g.CurrentWindow;
table->WorkRect = table->InnerWindow->WorkRect;
table->OuterRect = table->InnerWindow->Rect();
IM_ASSERT(table->InnerWindow->WindowPadding.x == 0.0f && table->InnerWindow->WindowPadding.y == 0.0f && table->InnerWindow->WindowBorderSize == 0.0f);
}
// Push a standardized ID for both child-using and not-child-using tables
PushOverrideID(instance_id);
// Backup a copy of host window members we will modify
ImGuiWindow* inner_window = table->InnerWindow;
table->HostIndentX = inner_window->DC.Indent.x;
table->HostClipRect = inner_window->ClipRect;
table->HostSkipItems = inner_window->SkipItems;
table->HostBackupWorkRect = inner_window->WorkRect;
table->HostBackupParentWorkRect = inner_window->ParentWorkRect;
table->HostBackupColumnsOffset = outer_window->DC.ColumnsOffset;
table->HostBackupPrevLineSize = inner_window->DC.PrevLineSize;
table->HostBackupCurrLineSize = inner_window->DC.CurrLineSize;
table->HostBackupCursorMaxPos = inner_window->DC.CursorMaxPos;
table->HostBackupItemWidth = outer_window->DC.ItemWidth;
table->HostBackupItemWidthStackSize = outer_window->DC.ItemWidthStack.Size;
inner_window->ParentWorkRect = table->WorkRect;
inner_window->DC.PrevLineSize = inner_window->DC.CurrLineSize = ImVec2(0.0f, 0.0f);
// Padding and Spacing
// - None ........Content..... Pad .....Content........
// - PadOuter | Pad ..Content..... Pad .....Content.. Pad |
// - PadInner ........Content.. Pad | Pad ..Content........
// - PadOuter+PadInner | Pad ..Content.. Pad | Pad ..Content.. Pad |
const bool pad_outer_x = (flags & ImGuiTableFlags_NoPadOuterX) ? false : (flags & ImGuiTableFlags_PadOuterX) ? true : (flags & ImGuiTableFlags_BordersOuterV) != 0;
const bool pad_inner_x = (flags & ImGuiTableFlags_NoPadInnerX) ? false : true;
const float inner_spacing_for_border = (flags & ImGuiTableFlags_BordersInnerV) ? TABLE_BORDER_SIZE : 0.0f;
const float inner_spacing_explicit = (pad_inner_x && (flags & ImGuiTableFlags_BordersInnerV) == 0) ? g.Style.CellPadding.x : 0.0f;
const float inner_padding_explicit = (pad_inner_x && (flags & ImGuiTableFlags_BordersInnerV) != 0) ? g.Style.CellPadding.x : 0.0f;
const float inner_spacing = inner_spacing_for_border + inner_spacing_explicit;
table->CellSpacingX1 = ImCeil(inner_spacing * 0.5f);
table->CellSpacingX2 = inner_spacing - table->CellSpacingX1;
table->CellPaddingX = inner_padding_explicit;
table->CellPaddingY = g.Style.CellPadding.y;
const float outer_padding_for_border = (flags & ImGuiTableFlags_BordersOuterV) ? TABLE_BORDER_SIZE : 0.0f;
const float outer_padding_explicit = pad_outer_x ? g.Style.CellPadding.x : 0.0f;
table->OuterPaddingX = (outer_padding_for_border + outer_padding_explicit) - table->CellPaddingX;
table->CurrentColumn = -1;
table->CurrentRow = -1;
table->RowBgColorCounter = 0;
table->LastRowFlags = ImGuiTableRowFlags_None;
table->InnerClipRect = (inner_window == outer_window) ? table->WorkRect : inner_window->ClipRect;
table->InnerClipRect.ClipWith(table->WorkRect); // We need this to honor inner_width
table->InnerClipRect.ClipWithFull(table->HostClipRect);
table->InnerClipRect.Max.y = (flags & ImGuiTableFlags_NoHostExtendY) ? ImMin(table->InnerClipRect.Max.y, inner_window->WorkRect.Max.y) : inner_window->ClipRect.Max.y;
// Initial draw cmd starts with a BgClipRect that matches the one of its host, to facilitate merge draw commands by default.
// This is because all our cell highlight are manually clipped with BgClipRect
// Larger at first, if/after unfreezing will become same as tight
table->BgClipRect = table->InnerClipRect;
table->BgClipRectForDrawCmd = table->HostClipRect;
IM_ASSERT(table->BgClipRect.Min.y <= table->BgClipRect.Max.y);
table->RowPosY1 = table->RowPosY2 = table->WorkRect.Min.y; // This is needed somehow
table->RowTextBaseline = 0.0f; // This will be cleared again by TableBeginRow()
table->FreezeRowsRequest = table->FreezeRowsCount = 0; // This will be setup by TableSetupScrollFreeze(), if any
table->FreezeColumnsRequest = table->FreezeColumnsCount = 0;
table->IsUnfrozen = true;
table->DeclColumnsCount = 0;
table->RightMostEnabledColumn = -1;
// Using opaque colors facilitate overlapping elements of the grid
table->BorderColorStrong = GetColorU32(ImGuiCol_TableBorderStrong);
table->BorderColorLight = GetColorU32(ImGuiCol_TableBorderLight);
table->BorderX1 = table->InnerClipRect.Min.x;// +((table->Flags & ImGuiTableFlags_BordersOuter) ? 0.0f : -1.0f);
table->BorderX2 = table->InnerClipRect.Max.x;// +((table->Flags & ImGuiTableFlags_BordersOuter) ? 0.0f : +1.0f);
// Make table current
const int table_idx = g.Tables.GetIndex(table);
g.CurrentTableStack.push_back(ImGuiPtrOrIndex(table_idx));
g.CurrentTable = table;
outer_window->DC.CurrentTableIdx = table_idx;
if (inner_window != outer_window) // So EndChild() within the inner window can restore the table properly.
inner_window->DC.CurrentTableIdx = table_idx;
if ((table_last_flags & ImGuiTableFlags_Reorderable) && (flags & ImGuiTableFlags_Reorderable) == 0)
table->IsResetDisplayOrderRequest = true;
// Mark as used
if (table_idx >= g.TablesLastTimeActive.Size)
g.TablesLastTimeActive.resize(table_idx + 1, -1.0f);
g.TablesLastTimeActive[table_idx] = (float)g.Time;
table->MemoryCompacted = false;
// Setup memory buffer (clear data if columns count changed)
const int stored_size = table->Columns.size();
if (stored_size != 0 && stored_size != columns_count)
{
IM_FREE(table->RawData);
table->RawData = NULL;
}
if (table->RawData == NULL)
{
TableBeginInitMemory(table, columns_count);
table->IsInitializing = table->IsSettingsRequestLoad = true;
}
if (table->IsResetAllRequest)
TableResetSettings(table);
if (table->IsInitializing)
{
// Initialize for new settings
table->SettingsOffset = -1;
table->IsSortSpecsDirty = true;
for (int n = 0; n < columns_count; n++)
{
ImGuiTableColumn* column = &table->Columns[n];
float width_auto = column->WidthAuto;
*column = ImGuiTableColumn();
column->WidthAuto = width_auto;
column->IsPreserveWidthAuto = true; // Preserve WidthAuto when reinitializing a live table: not technically necessary but remove a visible flicker
column->DisplayOrder = table->DisplayOrderToIndex[n] = (ImGuiTableColumnIdx)n;
column->IsEnabled = column->IsEnabledNextFrame = true;
}
}
// Load settings
if (table->IsSettingsRequestLoad)
TableLoadSettings(table);
// Handle DPI/font resize
// This is designed to facilitate DPI changes with the assumption that e.g. style.CellPadding has been scaled as well.
// It will also react to changing fonts with mixed results. It doesn't need to be perfect but merely provide a decent transition.
// FIXME-DPI: Provide consistent standards for reference size. Perhaps using g.CurrentDpiScale would be more self explanatory.
// This is will lead us to non-rounded WidthRequest in columns, which should work but is a poorly tested path.
const float new_ref_scale_unit = g.FontSize; // g.Font->GetCharAdvance('A') ?
if (table->RefScale != 0.0f && table->RefScale != new_ref_scale_unit)
{
const float scale_factor = new_ref_scale_unit / table->RefScale;
//IMGUI_DEBUG_LOG("[table] %08X RefScaleUnit %.3f -> %.3f, scaling width by %.3f\n", table->ID, table->RefScaleUnit, new_ref_scale_unit, scale_factor);
for (int n = 0; n < columns_count; n++)
table->Columns[n].WidthRequest = table->Columns[n].WidthRequest * scale_factor;
}
table->RefScale = new_ref_scale_unit;
// Disable output until user calls TableNextRow() or TableNextColumn() leading to the TableUpdateLayout() call..
// This is not strictly necessary but will reduce cases were "out of table" output will be misleading to the user.
// Because we cannot safely assert in EndTable() when no rows have been created, this seems like our best option.
inner_window->SkipItems = true;
// Clear names
// FIXME-TABLES: probably could be done differently...
if (table->ColumnsNames.Buf.Size > 0)
{
table->ColumnsNames.Buf.resize(0);
for (int column_n = 0; column_n < table->ColumnsCount; column_n++)
{
ImGuiTableColumn* column = &table->Columns[column_n];
column->NameOffset = -1;
}
}
// Apply queued resizing/reordering/hiding requests
TableBeginApplyRequests(table);
return true;
}
void ImGui::textEllipsisInTableCell(const char* text) noexcept
{
ImGuiContext& g = *GImGui;
ImGuiWindow* window = g.CurrentWindow;
ImGuiTable* table = g.CurrentTable;
IM_ASSERT(table != NULL && "Need to call textEllipsisInTableCell() after BeginTable()!");
IM_ASSERT(table->CurrentColumn != -1);
const char* textEnd = FindRenderedTextEnd(text);
ImVec2 textSize = CalcTextSize(text, textEnd, true);
ImVec2 textPos = window->DC.CursorPos;
float textHeight = ImMax(textSize.y, table->RowMinHeight - table->CellPaddingY * 2.0f);
float ellipsisMax = TableGetCellBgRect(table, table->CurrentColumn).Max.x;
RenderTextEllipsis(window->DrawList, textPos, ImVec2(ellipsisMax, textPos.y + textHeight + g.Style.FramePadding.y), ellipsisMax, ellipsisMax, text, textEnd, &textSize);
ImRect bb(textPos, textPos + textSize);
ItemSize(textSize, 0.0f);
ItemAdd(bb, 0);
}
| [
"[email protected]"
] | |
d1d1becbead1a4d133adae2a1e0c2d690bc158ca | 76f818c897400fac8932638ac6c1857811af8854 | /trunk/src/meshstat.cxx | 22328c1ab047c1e68b82e375f78c1d6514ffc13a | [] | no_license | BackupTheBerlios/tetgen-svn | e834cf5c017e4542525a8430425d1bda3a3281c6 | ad79f29a56a152397fdd183526af5e02fc377dca | refs/heads/master | 2020-05-19T08:18:04.528799 | 2010-06-09T11:25:55 | 2010-06-09T11:25:55 | 40,801,067 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 59,039 | cxx | #ifndef meshstatCXX
#define meshstatCXX
#include "tetgen.h"
///////////////////////////////////////////////////////////////////////////////
// //
// Initialize fast look-up tables. //
// //
///////////////////////////////////////////////////////////////////////////////
int tetgenmesh::ve[6] = { 2, 5, 4, 1, 0, 3 };
int tetgenmesh::ve2[6] = { 4, 3, 0, 5, 2, 1 };
int tetgenmesh::vo[6] = { 0, 1, 1, 2, 2, 0 };
int tetgenmesh::vd[6] = { 1, 0, 2, 1, 0, 2 };
int tetgenmesh::va[6] = { 2, 2, 0, 0, 1, 1 };
int tetgenmesh::verver2zero[6][6] = {
{0, 0, 2, 2, 4, 4},
{0, 0, 2, 2, 4, 4},
{2, 2, 4, 4, 0, 0},
{2, 2, 4, 4, 0, 0},
{4, 4, 0, 0, 2, 2},
{4, 4, 0, 0, 2, 2}
};
int tetgenmesh::ver2zero[6] = {0, 0, 2, 2, 4, 4};
int tetgenmesh::zero2ver[6][6] = {
{0, 0, 2, 2, 4, 4},
{0, 0, 2, 2, 4, 4},
{4, 4, 0, 0, 2, 2},
{4, 4, 0, 0, 2, 2},
{2, 2, 4, 4, 0, 0},
{2, 2, 4, 4, 0, 0}
};
int tetgenmesh::locver2org[4][6] = {
{0, 1, 1, 2, 2, 0},
{0, 3, 3, 1, 1, 0},
{1, 3, 3, 2, 2, 1},
{2, 3, 3, 0, 0, 2}
};
int tetgenmesh::locver2dest[4][6] = {
{1, 0, 2, 1, 0, 2},
{3, 0, 1, 3, 0, 1},
{3, 1, 2, 3, 1, 2},
{3, 2, 0, 3, 2, 0}
};
int tetgenmesh::locver2apex[4][6] = {
{2, 2, 0, 0, 1, 1},
{1, 1, 0, 0, 3, 3},
{2, 2, 1, 1, 3, 3},
{0, 0, 2, 2, 3, 3}
};
int tetgenmesh::loc2oppo[4] = { 3, 2, 0, 1 };
int tetgenmesh::locver2nextf[32] = {
1, 5, 2, 5, 3, 5, 0, 0,
3, 3, 2, 1, 0, 1, 0, 0,
1, 3, 3, 1, 0, 3, 0, 0,
2, 3, 1, 1, 0, 5, 0, 0
};
int tetgenmesh::locver2edge[4][6] = {
{0, 0, 1, 1, 2, 2},
{3, 3, 4, 4, 0, 0},
{4, 4, 5, 5, 1, 1},
{5, 5, 3, 3, 2, 2}
};
int tetgenmesh::edge2locver[6][2] = {
{0, 0}, // 0 v0 -> v1
{0, 2}, // 1 v1 -> v2
{0, 4}, // 2 v2 -> v0
{1, 0}, // 3 v0 -> v3
{1, 2}, // 4 v1 -> v3
{2, 2} // 5 v2 -> v3
};
int tetgenmesh::locpivot[4][3] = {
{1, 2, 3},
{0, 2, 3},
{0, 1, 3},
{0, 1, 2}
};
int tetgenmesh::locverpivot[4][6][2] = {
{{2, 3}, {2, 3}, {1, 3}, {1, 3}, {1, 2}, {1, 2}},
{{0, 2}, {0, 2}, {0, 3}, {0, 3}, {2, 3}, {2, 3}},
{{0, 3}, {0, 3}, {0, 1}, {0, 1}, {1, 3}, {1, 3}},
{{0, 1}, {0, 1}, {0, 2}, {0, 2}, {1, 2}, {1, 2}}
};
int tetgenmesh::mi1mo3[3] = {2, 0, 1};
///////////////////////////////////////////////////////////////////////////////
// //
// checkmesh() Test mesh for geometrical and topological consistencies. //
// //
///////////////////////////////////////////////////////////////////////////////
int tetgenmesh::checkmesh()
{
triface tetloop;
triface neightet, symtet;
point pa, pb, pc, pd;
REAL ori;
int horrors, i;
if (!b->quiet) {
printf(" Checking consistency of mesh...\n");
}
horrors = 0;
tetloop.ver = 0;
// Run through the list of tetrahedra, checking each one.
tetrahedronpool->traversalinit();
tetloop.tet = tetrahedrontraverse();
while (tetloop.tet != (tetrahedron *) NULL) {
// Check all four faces of the tetrahedron.
for (tetloop.loc = 0; tetloop.loc < 4; tetloop.loc++) {
pa = org(tetloop);
pb = dest(tetloop);
pc = apex(tetloop);
pd = oppo(tetloop);
if (tetloop.loc == 0) { // Only test for inversion once.
if (pd != dummypoint) { // Only do test if it is not a hull tet.
ori = orient3d(pa, pb, pc, pd);
if (ori >= 0.0) {
printf(" !! !! %s ", ori > 0.0 ? "Inverted" : "Degenerated");
printf(" (%d, %d, %d, %d) (ori = %.17g)\n", pointmark(pa),
pointmark(pb), pointmark(pc), pointmark(pd), ori);
horrors++;
}
}
if (infected(tetloop)) {
// This may be a bug. Report it.
printf(" !! (%d, %d, %d, %d) is infected.\n", pointmark(pa),
pointmark(pb), pointmark(pc), pointmark(pd));
}
if (marktested(tetloop)) {
// This may be a bug. Report it.
printf(" !! (%d, %d, %d, %d) is marked.\n", pointmark(pa),
pointmark(pb), pointmark(pc), pointmark(pd));
}
}
if (tetloop.tet[tetloop.loc] == NULL) {
printf(" !! !! No neighbor at face (%d, %d, %d).\n", pointmark(pa),
pointmark(pb), pointmark(pc));
horrors++;
} else {
// Find the neighboring tetrahedron on this face.
symedge(tetloop, neightet);
// Check that the tetrahedron's neighbor knows it's a neighbor.
sym(neightet, symtet);
if ((tetloop.tet != symtet.tet) || (tetloop.loc != symtet.loc)) {
printf(" !! !! Asymmetric tetra-tetra bond:\n");
if (tetloop.tet == symtet.tet) {
printf(" (Right tetrahedron, wrong orientation)\n");
}
printf(" First: (%d, %d, %d, %d)\n", pointmark(pa),
pointmark(pb), pointmark(pc), pointmark(pd));
printf(" Second: (%d, %d, %d, %d)\n", pointmark(org(neightet)),
pointmark(dest(neightet)), pointmark(apex(neightet)),
pointmark(oppo(neightet)));
horrors++;
}
// Check if they have the same edge (the bond() operation).
if ((org(neightet) != pb) || (dest(neightet) != pa)) {
printf(" !! !! Wrong edge-edge bond:\n");
printf(" First: (%d, %d, %d, %d)\n", pointmark(pa),
pointmark(pb), pointmark(pc), pointmark(pd));
printf(" Second: (%d, %d, %d, %d)\n", pointmark(org(neightet)),
pointmark(dest(neightet)), pointmark(apex(neightet)),
pointmark(oppo(neightet)));
horrors++;
}
// Check if they have the same apex.
if (apex(neightet) != pc) {
printf(" !! !! Wrong face-face bond:\n");
printf(" First: (%d, %d, %d, %d)\n", pointmark(pa),
pointmark(pb), pointmark(pc), pointmark(pd));
printf(" Second: (%d, %d, %d, %d)\n", pointmark(org(neightet)),
pointmark(dest(neightet)), pointmark(apex(neightet)),
pointmark(oppo(neightet)));
horrors++;
}
// Check if they have the same opposite.
if (oppo(neightet) == pd) {
printf(" !! !! Two identical tetra:\n");
printf(" First: (%d, %d, %d, %d)\n", pointmark(pa),
pointmark(pb), pointmark(pc), pointmark(pd));
printf(" Second: (%d, %d, %d, %d)\n", pointmark(org(neightet)),
pointmark(dest(neightet)), pointmark(apex(neightet)),
pointmark(oppo(neightet)));
horrors++;
}
}
if (facemarked(tetloop)) {
// This may be a bug. Report it.
printf(" !! tetface (%d, %d, %d) %d is marked.\n", pointmark(pa),
pointmark(pb), pointmark(pc), pointmark(pd));
}
}
// Check the six edges of this tet.
for (i = 0; i < 6; i++) {
tetloop.loc = edge2locver[i][0];
tetloop.ver = edge2locver[i][1];
if (edgemarked(tetloop)) {
// This may be a bug. Report it.
printf(" !! tetedge (%d, %d) %d, %d is marked.\n",
pointmark(org(tetloop)), pointmark(dest(tetloop)),
pointmark(apex(tetloop)), pointmark(oppo(tetloop)));
}
}
tetloop.tet = tetrahedrontraverse();
}
if (horrors == 0) {
if (!b->quiet) {
printf(" In my studied opinion, the mesh appears to be consistent.\n");
}
} else {
printf(" !! !! !! !! %d %s witnessed.\n", horrors,
horrors > 1 ? "abnormity" : "abnormities");
}
return horrors;
}
///////////////////////////////////////////////////////////////////////////////
// //
// checkshells() Test the surface mesh for consistencies. //
// //
// If 'sub2tet' > 0, it also checks the subface-to-tet connections. //
// //
///////////////////////////////////////////////////////////////////////////////
int tetgenmesh::checkshells(int sub2tet)
{
triface neightet, symtet;
face shloop, spinsh, nextsh;
face checkseg;
point pa, pb, *ppt;
int count;
int horrors, i;
tetrahedron ptr;
if (!b->quiet) {
printf(" Checking consistency of the mesh boundary...\n");
}
horrors = 0;
void **bakpathblock = subfacepool->pathblock;
void *bakpathitem = subfacepool->pathitem;
int bakpathitemsleft = subfacepool->pathitemsleft;
int bakalignbytes = subfacepool->alignbytes;
subfacepool->traversalinit();
shloop.sh = shellfacetraverse(subfacepool);
while (shloop.sh != NULL) {
shloop.shver = 0;
for (i = 0; i < 3; i++) {
// Check the face ring at this edge.
pa = sorg(shloop);
pb = sdest(shloop);
spinsh = shloop;
spivot(spinsh, nextsh);
while ((nextsh.sh != NULL) && (nextsh.sh != shloop.sh)) {
// check if they have the same edge.
if (!((sorg(nextsh) == pa) && (sdest(nextsh) == pb) ||
(sorg(nextsh) == pb) && (sdest(nextsh) == pa))) {
printf(" !! !! Wrong subface-subface connection.\n");
printf(" First: x%lx (%d, %d, %d).\n", (unsigned long) spinsh.sh,
pmark(sorg(spinsh)), pmark(sdest(spinsh)), pmark(sapex(spinsh)));
printf(" Scond: x%lx (%d, %d, %d).\n", (unsigned long) nextsh.sh,
pmark(sorg(nextsh)), pmark(sdest(nextsh)), pmark(sapex(nextsh)));
horrors++;
}
spinsh = nextsh;
spivot(spinsh, nextsh);
}
// Check subface-subseg bond.
sspivot(shloop, checkseg);
if (checkseg.sh != NULL) {
if (!((sorg(checkseg) == pa) && (sdest(checkseg) == pb) ||
(sorg(checkseg) == pb) && (sdest(checkseg) == pa))) {
printf(" !! !! Wrong subface-subseg connection.\n");
printf(" Sub: x%lx (%d, %d, %d).\n", (unsigned long) shloop.sh,
pmark(sorg(shloop)), pmark(sdest(shloop)), pmark(sapex(shloop)));
printf(" Seg: x%lx (%d, %d).\n", (unsigned long) checkseg.sh,
pmark(sorg(checkseg)), pmark(sdest(checkseg)));
horrors++;
}
}
senextself(shloop);
}
if (sub2tet > 0) {
// Check the tet-subface connections.
stpivot(shloop, neightet);
if (neightet.tet != NULL) {
// Check if the tet and subface have the same vertices.
ppt = (point *) shloop.sh;
for (i = 0; i < 3; i++) {
pinfect(ppt[3 + i]); // Infect the subface vertices.
}
ppt = (point *) neightet.tet;
count = 0; // Count the infected vertices of this tet.
for (i = 0; i < 4; i++) {
if (pinfected(ppt[4 + i])) count++;
}
ppt = (point *) shloop.sh;
for (i = 0; i < 3; i++) {
puninfect(ppt[3 + i]); // Uninfect the subface vertices.
}
if (count != 3) {
printf(" !! !! Wrong tet-sub connection (face does not match).\n");
printf(" Sub: x%lx (%d, %d, %d).\n", (unsigned long) shloop.sh,
pmark(sorg(shloop)), pmark(sdest(shloop)), pmark(sapex(shloop)));
printf(" Tet: x%lx (%d, %d, %d, %d).\n",
(unsigned long) neightet.tet, pmark(org(neightet)),
pmark(dest(neightet)), pmark(apex(neightet)),
pmark(oppo(neightet)));
horrors++;
}
tspivot(neightet, spinsh);
if (spinsh.sh != shloop.sh) {
printf(" !! !! Wrong tet-sub connection (wrong subfaces).\n");
printf(" Sub: x%lx (%d, %d, %d).\n", (unsigned long) shloop.sh,
pmark(sorg(shloop)), pmark(sdest(shloop)), pmark(sapex(shloop)));
printf(" Tet: x%lx (%d, %d, %d, %d).\n",
(unsigned long) neightet.tet, pmark(org(neightet)),
pmark(dest(neightet)), pmark(apex(neightet)),
pmark(oppo(neightet)));
horrors++;
} else {
symself(neightet);
tspivot(neightet, spinsh);
if (spinsh.sh != shloop.sh) {
printf(" !! !! Wrong tet-sub connection (wrong subfaces).\n");
printf(" Sub: x%lx (%d, %d, %d).\n", (unsigned long) shloop.sh,
pmark(sorg(shloop)), pmark(sdest(shloop)), pmark(sapex(shloop)));
printf(" Tet: x%lx (%d, %d, %d, %d).\n",
(unsigned long) neightet.tet, pmark(org(neightet)),
pmark(dest(neightet)), pmark(apex(neightet)),
pmark(oppo(neightet)));
horrors++;
}
}
} else {
// printf(" !! A dangling subface.\n");
// printf(" Sub: x%lx (%d, %d, %d).\n", (unsigned long) shloop.sh,
// pmark(sorg(shloop)), pmark(sdest(shloop)), pmark(sapex(shloop)));
// horrors++;
}
}
if (sinfected(shloop)) {
// This may be a bug. report it.
printf(" !! A infected subface: (%d, %d, %d).\n", pmark(sorg(shloop)),
pmark(sdest(shloop)), pmark(sapex(shloop)));
}
if (smarktested(shloop)) {
// This may be a bug. report it.
printf(" !! A marked subface: (%d, %d, %d).\n", pmark(sorg(shloop)),
pmark(sdest(shloop)), pmark(sapex(shloop)));
}
shloop.sh = shellfacetraverse(subfacepool);
}
if (horrors == 0) {
if (!b->quiet) {
printf(" Mesh boundaries connected correctly.\n");
}
} else {
printf(" !! !! !! !! %d boundary connection viewed with horror.\n",
horrors);
}
subfacepool->pathblock = bakpathblock;
subfacepool->pathitem = bakpathitem;
subfacepool->pathitemsleft = bakpathitemsleft;
subfacepool->alignbytes = bakalignbytes;
return horrors;
}
///////////////////////////////////////////////////////////////////////////////
// //
// checkdelaunay() Ensure that the mesh is (constrained) Delaunay. //
// //
///////////////////////////////////////////////////////////////////////////////
int tetgenmesh::checkdelaunay(int constrained)
{
triface tetloop;
triface symtet;
face checksh;
point pa, pb, pc, pd, pe;
REAL sign;
int horrors;
if (!b->quiet) {
printf(" Checking %s property of the mesh...\n", constrained > 0 ?
"constrained Delaunay" : "Delaunay");
}
horrors = 0;
tetloop.ver = 0;
// Run through the list of triangles, checking each one.
tetrahedronpool->traversalinit();
tetloop.tet = tetrahedrontraverse();
while (tetloop.tet != (tetrahedron *) NULL) {
// Check all four faces of the tetrahedron.
for (tetloop.loc = 0; tetloop.loc < 4; tetloop.loc++) {
sym(tetloop, symtet);
// Only do test if its adjoining tet is not a hull tet or its pointer
// is larger (to ensure that each pair isn't tested twice).
if (((point) symtet.tet[7] != dummypoint)&&(tetloop.tet < symtet.tet)) {
pa = org(tetloop);
pb = dest(tetloop);
pc = apex(tetloop);
pd = oppo(tetloop);
pe = oppo(symtet);
sign = insphere_sos(pa, pb, pc, pd, pe);
if (sign < 0.0) {
if (constrained > 0) {
tspivot(tetloop, checksh);
}
if ((constrained == 0) ||
((constrained > 0) && (checksh.sh == NULL))) {
printf(" !! Non-locally Delaunay (%d, %d, %d) - %d, %d\n",
pointmark(pa), pointmark(pb), pointmark(pc), pointmark(pd),
pointmark(pe));
horrors++;
}
}
}
}
tetloop.tet = tetrahedrontraverse();
}
if (horrors == 0) {
if (!b->quiet) {
printf(" The mesh is %s.\n", constrained > 0 ? "constrained Delaunay"
: "Delaunay");
}
} else {
printf(" !! !! !! !! Found %d non-Delaunay faces.\n", horrors);
}
return horrors;
}
///////////////////////////////////////////////////////////////////////////////
// //
// checksegments() Check the connections between tetrahedra and segments. //
// //
///////////////////////////////////////////////////////////////////////////////
int tetgenmesh::checksegments()
{
triface tetloop, neightet;
shellface *segs;
face sseg, checkseg;
point pa, pb;
int horrors, i;
if (!b->quiet) {
printf(" Checking tet-seg connections...\n");
}
horrors = 0;
tetrahedronpool->traversalinit();
tetloop.tet = tetrahedrontraverse();
while (tetloop.tet != NULL) {
// Loop the six edges of the tet.
if (tetloop.tet[8] != NULL) {
segs = (shellface *) tetloop.tet[8];
for (i = 0; i < 6; i++) {
sdecode(segs[i], sseg);
if (sseg.sh != NULL) {
// Get the edge of the tet.
tetloop.loc = edge2locver[i][0];
tetloop.ver = edge2locver[i][1];
// Check if they are the same edge.
pa = (point) sseg.sh[3];
pb = (point) sseg.sh[4];
if (!(((org(tetloop) == pa) && (dest(tetloop) == pb)) ||
((org(tetloop) == pb) && (dest(tetloop) == pa)))) {
printf(" !! Wrong tet-seg connection.\n");
printf(" Tet: x%lx (%d, %d, %d, %d) - Seg: x%lx (%d, %d).\n",
(unsigned long) tetloop.tet, pointmark(org(tetloop)),
pointmark(dest(tetloop)), pointmark(apex(tetloop)),
pointmark(oppo(tetloop)), (unsigned long) sseg.sh,
pointmark(pa), pointmark(pb));
horrors++;
} else {
// Loop all tets sharing at this edge.
neightet = tetloop;
do {
tsspivot(neightet, checkseg);
if (checkseg.sh != sseg.sh) {
printf(" !! Wrong tet->seg connection.\n");
printf(" Tet: x%lx (%d, %d, %d, %d) - ",
(unsigned long) neightet.tet, pointmark(org(neightet)),
pointmark(dest(neightet)), pointmark(apex(neightet)),
pointmark(oppo(neightet)));
if (checkseg.sh != NULL) {
printf("Seg x%lx (%d, %d).\n", (unsigned long) checkseg.sh,
pointmark(sorg(checkseg)), pointmark(sdest(checkseg)));
} else {
printf("Seg: NULL.\n");
}
horrors++;
}
fnextself(neightet);
} while (neightet.tet != tetloop.tet);
}
// Check the seg->tet pointer.
stpivot(sseg, neightet);
if (neightet.tet == NULL) {
printf(" !! Wrong seg->tet connection (A NULL tet).\n");
horrors++;
} else {
if (!(((org(neightet) == pa) && (dest(neightet) == pb)) ||
((org(neightet) == pb) && (dest(neightet) == pa)))) {
printf(" !! Wrong seg->tet connection (Wrong edge).\n");
printf(" Tet: x%lx (%d, %d, %d, %d) - Seg: x%lx (%d, %d).\n",
(unsigned long) neightet.tet, pointmark(org(neightet)),
pointmark(dest(neightet)), pointmark(apex(neightet)),
pointmark(oppo(neightet)), (unsigned long) sseg.sh,
pointmark(pa), pointmark(pb));
horrors++;
}
}
}
}
}
tetloop.tet = tetrahedrontraverse();
}
if (horrors == 0) {
printf(" Segments are connected properly.\n");
} else {
printf(" !! !! !! !! Found %d missing connections.\n", horrors);
}
return horrors;
}
///////////////////////////////////////////////////////////////////////////////
// //
// checkconforming() Check if the mesh is boundary conforming Delaunay. //
// //
///////////////////////////////////////////////////////////////////////////////
int tetgenmesh::checkconforming()
{
face shloop;
int horrors;
horrors = 0;
// Find all encroached segments.
subsegpool->traversalinit();
shloop.shver = 0;
shloop.sh = shellfacetraverse(subsegpool);
while (shloop.sh != NULL) {
if (checkedge4encroach(shloop, NULL, 0)) {
printf(" !! Segment x%lx (%d, %d) is encroached.\n",
(unsigned long) shloop.sh, pointmark(sorg(shloop)),
pointmark(sdest(shloop)));
horrors++;
}
shloop.sh = shellfacetraverse(subsegpool);
}
if (horrors == 0) {
printf(" Segments are boundary conforming Delaunay.\n");
} else {
printf(" !! !! !! !! Found %d encroached segments.\n", horrors);
}
return horrors;
}
///////////////////////////////////////////////////////////////////////////////
// //
// algorithmstatistics() Report algorithmic performances. //
// //
///////////////////////////////////////////////////////////////////////////////
void tetgenmesh::algorithmstatistics()
{
/*// Report memory usages.
unsigned long totalmeshbytes;
printf("Memory allocation statistics:\n\n");
printf(" Maximum number of vertices: %ld\n", pointpool->maxitems);
totalmeshbytes = pointpool->maxitems * pointpool->itembytes;
printf(" Maximum number of tetrahedra: %ld\n", tetrahedronpool->maxitems);
totalmeshbytes += tetrahedronpool->maxitems * tetrahedronpool->itembytes;
if (subfacepool != (memorypool *) NULL) {
printf(" Maximum number of subfaces: %ld\n", subfacepool->maxitems);
totalmeshbytes += subfacepool->maxitems * subfacepool->itembytes;
}
if (subsegpool != (memorypool *) NULL) {
printf(" Maximum number of segments: %ld\n", subsegpool->maxitems);
totalmeshbytes += subsegpool->maxitems * subsegpool->itembytes;
}
printf(" Heap memory used by the mesh (K bytes): %g\n\n",
((double) totalmeshbytes) / 1024.0);
*/
printf("Algorithmic statistics:\n\n");
printf(" Number of orient3d tests: %ld\n", orient3dcount);
printf(" Number of insphere tests: %ld\n", inspherecount);
printf(" Number of symbolic insphere tests: %ld\n", insphere_sos_count);
printf(" Number of visited tets in point location: %ld\n", ptloc_count);
printf(" Maximal number of tets per point location: %ld\n",ptloc_max_count);
printf(" Number of 1-to-4 flips: %ld\n", flip14count);
printf(" Number of 2-to-6 flips: %ld\n", flip26count);
printf(" Number of n-t-2n flips: %ld\n", flipn2ncount);
if (!b->plc) {
if (b->bowyerwatson) {
printf(" Number of deleted tets: %ld\n", totaldeadtets);
printf(" Number of created tets: %ld\n", totalbowatcavsize);
printf(" Maximum number of tets per new point: %ld\n", maxbowatcavsize);
printf(" Number of 3-to-2 flips: %ld\n", flip32count);
} else {
printf(" Number of 3-to-2 flips: %ld\n", flip32count);
printf(" Number of 2-to-3 flips: %ld\n", flip23count);
printf(" Number of n-to-m flips: %ld\n", flipnmcount);
printf(" Total number of primitive flips: %ld\n",
flip23count + flip32count);
}
}
if (b->plc) {
printf(" Number of 2-to-2 flips: %ld\n", flip22count);
printf(" Number of tri-edge inter (coplanar) tests: %ld (%ld)\n",
triedgcount, triedgcopcount);
printf(" Number of crossed faces (edges) in scout segs: %ld (%ld)\n",
across_face_count, across_edge_count);
printf(" Maximal number of crossed faces per segment: %ld\n",
across_max_count);
printf(" Number of rule-1 points: %ld\n", r1count);
printf(" Number of rule-2 points: %ld\n", r2count);
printf(" Number of rule-3 points: %ld\n", r3count);
printf(" Maximal size of a missing region: %ld\n", maxregionsize);
printf(" Maximal size of a recovered cavity: %ld\n", maxcavsize);
printf(" Number of non-Delaunay edges: %ld\n", ndelaunayedgecount);
printf(" Number of cavity expansions: %ld\n", cavityexpcount);
}
// printf(" Total point location time (millisec): %g\n", tloctime * 1e+3);
// printf(" Total point insertion time (millisec): %g\n",tinserttime*1e+3);
// if (b->bowyerwatson == 0) {
// printf(" Total flip time (millisec): %g\n", tfliptime * 1e+3);
// }
printf("\n");
}
///////////////////////////////////////////////////////////////////////////////
// //
// statistics() Print all sorts of cool facts. //
// //
///////////////////////////////////////////////////////////////////////////////
void tetgenmesh::statistics()
{
long tetnumber, facenumber;
printf("\nStatistics:\n\n");
printf(" Input points: %d\n", in->numberofpoints);
if (b->refine) {
printf(" Input tetrahedra: %d\n", in->numberoftetrahedra);
}
if (b->plc) {
printf(" Input facets: %d\n", in->numberoffacets);
printf(" Input segments: %ld\n", insegments);
printf(" Input holes: %d\n", in->numberofholes);
printf(" Input regions: %d\n", in->numberofregions);
}
tetnumber = tetrahedronpool->items - hullsize;
facenumber = (tetnumber * 4l + hullsize) / 2l;
printf("\n Mesh points: %ld\n", pointpool->items);
printf(" Mesh tetrahedra: %ld\n", tetnumber);
printf(" Mesh faces: %ld\n", facenumber);
printf(" Mesh edges: %ld\n", meshedges);
if (b->plc || b->refine) {
printf(" Mesh boundary faces: %ld\n", subfacepool->items);
printf(" Mesh boundary edges: %ld\n", meshsubedges);
printf(" Mesh subsegments: %ld\n", subsegpool->items);
} else {
printf(" Convex hull faces: %ld\n", hullsize);
}
printf("\n");
if (b->verbose > 0) {
printf(" Euler characteristic of mesh domain: %ld\n", pointpool->items
- meshedges + facenumber - tetnumber);
//printf(" Euler characteristic of boundary: %ld\n", pointpool->items
// - meshsubedges + subfacepool->items);
printf("\n");
}
if (b->verbose > 0) {
// qualitystatistics();
algorithmstatistics();
}
}
///////////////////////////////////////////////////////////////////////////////
// //
// terminatetetgen() Terminate TetGen with a given exit code. //
// //
///////////////////////////////////////////////////////////////////////////////
void terminatetetgen(int x)
{
#ifdef TETLIBRARY
throw x;
#else
exit(x);
#endif // #ifdef TETLIBRARY
}
///////////////////////////////////////////////////////////////////////////////
// //
// Debug functions. //
// //
///////////////////////////////////////////////////////////////////////////////
///////////////////////////////////////////////////////////////////////////////
// Print the detail informations of a tetrahedron.
void tetgenmesh::ptet(triface* t)
{
triface tmpface, prtface;
shellface *shells;
face checksh;
point *pts, tmppt;
REAL ori;
int facecount;
printf("Tetra x%lx with loc(%i) ver(%i):",
(unsigned long)(t->tet), t->loc, t->ver);
if (t->tet == NULL) {
printf(" !! NOT A VALID HANDLE\n");
return;
}
pts = (point *) t->tet;
if (pts[4] == NULL) {
printf(" !! A DEAD TET\n");
return;
}
if (pts[7] != dummypoint) {
ori = orient3d(pts[4], pts[5], pts[6], pts[7]);
printf(" ori = %g.\n", ori);
} else {
printf(" (hull tet).\n");
}
// Report the status of this tet.
printf(" ");
if (infected(*t)) {
printf("(infected) ");
}
if (marktested(*t)) {
printf("(marktested) ");
}
if (edgemarked(*t)) {
printf("(edgemarked) ");
}
if (b->regionattrib) {
printf("attr(%d)", elemattribute(t->tet, 0));
}
printf("\n");
tmpface = *t;
facecount = 0;
while(facecount < 4) {
tmpface.loc = facecount;
sym(tmpface, prtface);
if (prtface.tet == NULL) {
printf(" [%i] Open !!\n", facecount);
} else {
printf(" [%i] x%lx loc(%i) ver(%i)", facecount,
(unsigned long)(prtface.tet), prtface.loc, prtface.ver);
if ((point) prtface.tet[7] == dummypoint) {
printf(" (hull tet)");
}
if (infected(prtface)) {
printf(" (infected)");
}
printf("\n");
}
facecount++;
}
tmppt = org(*t);
if(tmppt == (point) NULL) {
printf(" Org [%i] NULL\n", locver2org[t->loc][t->ver]);
} else {
printf(" Org [%i] x%lx (%.12g,%.12g,%.12g) %d\n",
locver2org[t->loc][t->ver], (unsigned long)(tmppt),
tmppt[0], tmppt[1], tmppt[2], pointmark(tmppt));
}
tmppt = dest(*t);
if(tmppt == (point) NULL) {
printf(" Dest[%i] NULL\n", locver2dest[t->loc][t->ver]);
} else {
printf(" Dest[%i] x%lx (%.12g,%.12g,%.12g) %d\n",
locver2dest[t->loc][t->ver], (unsigned long)(tmppt),
tmppt[0], tmppt[1], tmppt[2], pointmark(tmppt));
}
tmppt = apex(*t);
if(tmppt == (point) NULL) {
printf(" Apex[%i] NULL\n", locver2apex[t->loc][t->ver]);
} else {
printf(" Apex[%i] x%lx (%.12g,%.12g,%.12g) %d\n",
locver2apex[t->loc][t->ver], (unsigned long)(tmppt),
tmppt[0], tmppt[1], tmppt[2], pointmark(tmppt));
}
tmppt = oppo(*t);
if(tmppt == (point) NULL) {
printf(" Oppo[%i] NULL\n", loc2oppo[t->loc]);
} else {
printf(" Oppo[%i] x%lx (%.12g,%.12g,%.12g) %d\n",
loc2oppo[t->loc], (unsigned long)(tmppt),
tmppt[0], tmppt[1], tmppt[2], pointmark(tmppt));
}
if (checksubsegs) {
if (t->tet[8] != NULL) {
shells = (shellface *) t->tet[8];
for (facecount = 0; facecount < 6; facecount++) {
sdecode(shells[facecount], checksh);
if (checksh.sh != NULL) {
printf(" [%d] x%lx %d.", facecount, (unsigned long) checksh.sh,
checksh.shver);
} else {
printf(" [%d] NULL.", facecount);
}
if (locver2edge[t->loc][t->ver] == facecount) {
printf(" (*)"); // It is the current edge.
}
printf("\n");
}
}
}
if (checksubfaces) {
if (t->tet[9] != NULL) {
shells = (shellface *) t->tet[9];
for (facecount = 0; facecount < 4; facecount++) {
sdecode(shells[facecount], checksh);
if (checksh.sh != NULL) {
printf(" [%d] x%lx %d.", facecount, (unsigned long) checksh.sh,
checksh.shver);
} else {
printf(" [%d] NULL.", facecount);
}
if (t->loc == facecount) {
printf(" (*)"); // It is the current face.
}
printf("\n");
}
}
}
}
///////////////////////////////////////////////////////////////////////////////
// Print the detail informations of a shellface.
void tetgenmesh::psh(face *s)
{
face prtsh;
triface prttet;
point *pt, printpoint;
REAL n[3];
if (s->sh == NULL) {
printf("Not a handle.\n");
return;
}
if (s->sh[3] == NULL) {
printf("A dead subface x%lx.\n", (unsigned long)(s->sh));
return;
}
pt = (point *) s->sh;
if (s->sh[5] != NULL) {
printf("subface x%lx, ver %d, mark %d:\n",(unsigned long)(s->sh),s->shver,
getshellmark(*s));
facenormal(pt[3], pt[4], pt[5], n, 1);
printf(" area %g, edge lengths %g %g %g\n", 0.5 * sqrt(DOT(n, n)),
DIST(pt[3], pt[4]), DIST(pt[4], pt[5]), DIST(pt[5], pt[3]));
} else {
printf("Subsegment x%lx, ver %d, mark %d:\n", (unsigned long)(s->sh),
s->shver, getshellmark(*s));
printf(" length %g", DIST(pt[3], pt[4]));
}
if (sinfected(*s)) {
printf(" (infected)");
}
if (smarktested(*s)) {
printf(" (marked)");
}
// if (shell2badface(*sface)) {
// printf(" (queued)");
// }
// if (checkpbcs) {
// if (shellpbcgroup(*sface) >= 0) {
// printf(" (pbc %d)", shellpbcgroup(*sface));
// }
// }
printf("\n");
sdecode(s->sh[0], prtsh);
if (prtsh.sh == NULL) {
printf(" [0] = No shell\n");
} else {
printf(" [0] = x%lx %d\n", (unsigned long)(prtsh.sh), prtsh.shver);
}
sdecode(s->sh[1], prtsh);
if (prtsh.sh == NULL) {
printf(" [1] = No shell\n");
} else {
printf(" [1] = x%lx %d\n", (unsigned long)(prtsh.sh), prtsh.shver);
}
sdecode(s->sh[2], prtsh);
if (prtsh.sh == NULL) {
printf(" [2] = No shell\n");
} else {
printf(" [2] = x%lx %d\n", (unsigned long)(prtsh.sh), prtsh.shver);
}
printpoint = sorg(*s);
if (printpoint == (point) NULL)
printf(" Org [%d] = NULL\n", vo[s->shver]);
else
printf(" Org [%d] = x%lx (%.12g,%.12g,%.12g) %d\n",
vo[s->shver], (unsigned long)(printpoint), printpoint[0],
printpoint[1], printpoint[2], pointmark(printpoint));
printpoint = sdest(*s);
if (printpoint == (point) NULL)
printf(" Dest[%d] = NULL\n", vd[s->shver]);
else
printf(" Dest[%d] = x%lx (%.12g,%.12g,%.12g) %d\n",
vd[s->shver], (unsigned long)(printpoint), printpoint[0],
printpoint[1], printpoint[2], pointmark(printpoint));
printpoint = sapex(*s);
if (printpoint == (point) NULL)
printf(" Apex[%d] = NULL\n", va[s->shver]);
else
printf(" Apex[%d] = x%lx (%.12g,%.12g,%.12g) %d\n",
va[s->shver], (unsigned long)(printpoint), printpoint[0],
printpoint[1], printpoint[2], pointmark(printpoint));
if (s->sh[5] != NULL) {
sdecode(s->sh[6], prtsh);
if (prtsh.sh == NULL) {
printf(" [6] = No subsegment\n");
} else {
printf(" [6] = x%lx %d\n", (unsigned long) prtsh.sh, prtsh.shver);
}
sdecode(s->sh[7], prtsh);
if (prtsh.sh == NULL) {
printf(" [7] = No subsegment\n");
} else {
printf(" [7] = x%lx %d\n", (unsigned long) prtsh.sh, prtsh.shver);
}
sdecode(s->sh[8], prtsh);
if (prtsh.sh == NULL) {
printf(" [8] = No subsegment\n");
} else {
printf(" [8] = x%lx %d\n", (unsigned long) prtsh.sh, prtsh.shver);
}
}
// Print the adjacent tet of this subface or segment.
decode(s->sh[9], prttet);
if (prttet.tet == NULL) {
printf(" [9] = Outer space\n");
} else {
printf(" [9] = x%lx (%d, %d, %d, %d)\n",(unsigned long) prttet.tet,
pointmark(org(prttet)), pointmark(dest(prttet)),
pointmark(apex(prttet)), pointmark(oppo(prttet)));
}
}
///////////////////////////////////////////////////////////////////////////////
// Find and print the tetrahedron (or face or edge) with the given indices.
// Do not handle 'dummypoint' (-1).
void tetgenmesh::pteti(int i, int j, int k, int l)
{
triface t;
point *pts;
int *marklist;
int ii;
marklist = new int[pointpool->items + 1];
for (ii = 0; ii < pointpool->items + 1; ii++) marklist[ii] = 0;
// Marke the given indices.
marklist[i] = marklist[j] = marklist[k] = marklist[l] = 1;
t.loc = t.ver = 0;
tetrahedronpool->traversalinit();
t.tet = tetrahedrontraverse();
while (t.tet != NULL) {
pts = (point *) t.tet;
if (pts[7] != dummypoint) {
if ((marklist[pointmark(pts[4])] + marklist[pointmark(pts[5])] +
marklist[pointmark(pts[6])] + marklist[pointmark(pts[7])]) == 4) {
ptet(&t); // Find!
break;
}
}
t.tet = tetrahedrontraverse();
}
if (t.tet == NULL) {
printf(" !! Not exist.\n");
}
delete [] marklist;
}
void tetgenmesh::pface(int i, int j, int k)
{
triface t, t1;
point *pts;
REAL sign;
int *marklist;
int ii;
marklist = new int[pointpool->items + 1];
for (ii = 0; ii < pointpool->items + 1; ii++) marklist[ii] = 0;
// Marke the given indices.
marklist[i] = marklist[j] = marklist[k] = 1;
t.ver = t1.ver = 0;
tetrahedronpool->traversalinit();
t.tet = tetrahedrontraverse();
while (t.tet != NULL) {
pts = (point *) t.tet;
if (pts[7] != dummypoint) {
if ((marklist[pointmark(pts[4])] + marklist[pointmark(pts[5])] +
marklist[pointmark(pts[6])] + marklist[pointmark(pts[7])]) == 3) {
// Find a tet containing the search face.
for (t.loc = 0; t.loc < 4; t.loc++) {
sym(t, t1);
pts = (point *) t1.tet;
if ((marklist[pointmark(pts[4])] + marklist[pointmark(pts[5])] +
marklist[pointmark(pts[6])] +
(pts[7] != dummypoint ? marklist[pointmark(pts[7])] : 0)) == 3)
break;
}
assert(t.loc < 4);
// Now t and t1 share the face.
printf(" tet x%lx (%d, %d, %d, %d) %d\n", (unsigned long) t.tet,
pointmark(org(t)), pointmark(dest(t)), pointmark(apex(t)),
pointmark(oppo(t)), t.loc);
printf(" tet x%lx (%d, %d, %d, %d) %d\n", (unsigned long) t1.tet,
pointmark(org(t1)), pointmark(dest(t1)), pointmark(apex(t1)),
pointmark(oppo(t1)), t1.loc);
if ((point) t1.tet[7] != dummypoint) {
pts = (point *) t.tet;
sign = insphere(pts[4], pts[5], pts[6], pts[7], oppo(t1));
printf(" %s (sign = %.g).\n", sign > 0 ? "Delaunay" :
(sign < 0 ? "Non-Delaunay" : "Cosphere"), sign);
if (sign == 0) {
sign = insphere_sos(pts[4], pts[5], pts[6], pts[7], oppo(t1));
printf(" %s (symbolic).\n", sign > 0 ? "Delaunay":"Non-Delaunay");
}
}
break;
}
}
t.tet = tetrahedrontraverse();
}
if (t.tet == NULL) {
printf(" !! Not exist.\n");
}
delete [] marklist;
}
bool tetgenmesh::pedge(int i, int j)
{
triface t, t1;
face ssub, sseg;
int ii;
t.ver = t1.ver = 0;
tetrahedronpool->traversalinit();
t.tet = tetrahedrontraverse();
while (t.tet != NULL) {
for (ii = 0; ii < 6; ii++) {
t.loc = edge2locver[ii][0];
t.ver = edge2locver[ii][1];
if ((pointmark(org(t)) == i && pointmark(dest(t)) == j) ||
(pointmark(org(t)) == j && pointmark(dest(t)) == i)) break;
}
if (ii < 6) {
// Now t is the edge (i, j). Find all tets at (i, j).
t1 = t;
do {
printf(" tet x%lx (%d, %d, %d, %d)", (unsigned long) t1.tet,
pointmark(org(t1)), pointmark(dest(t1)), pointmark(apex(t1)),
pointmark(oppo(t1)));
if (checksubsegs) {
tsspivot(t1, sseg);
if (sseg.sh != NULL) {
printf(" (seg)");
}
}
if (checksubfaces) {
tspivot(t1, ssub);
if (ssub.sh != NULL) {
printf(" (sub)");
}
}
if (edgemarked(t1)) {
printf(" (marked)");
}
printf("\n");
// Go to the next tet.
fnextself(t1);
} while (t1.tet != t.tet);
break;
}
t.tet = tetrahedrontraverse();
}
if (t.tet == NULL) {
printf(" !! Not exist.\n");
}
return t.tet != NULL;
}
///////////////////////////////////////////////////////////////////////////////
// Find the subface with indices (i, j, k)
void tetgenmesh::psubface(int i, int j, int k)
{
triface t, t1;
face s, s1;
point *pts;
REAL n[3], sign;
int *marklist;
int ii;
void **bakpathblock = subfacepool->pathblock;
void *bakpathitem = subfacepool->pathitem;
int bakpathitemsleft = subfacepool->pathitemsleft;
int bakalignbytes = subfacepool->alignbytes;
marklist = new int[pointpool->items + 1];
for (ii = 0; ii < pointpool->items + 1; ii++) marklist[ii] = 0;
// Marke the given indices.
marklist[i] = marklist[j] = marklist[k] = 1;
s.shver = 0;
subfacepool->traversalinit();
s.sh = shellfacetraverse(subfacepool);
while (s.sh != NULL) {
pts = (point *) s.sh;
if (pts[3] != NULL) {
if ((marklist[pointmark(pts[3])] + marklist[pointmark(pts[4])] +
marklist[pointmark(pts[5])]) == 3) {
// Found.
printf(" sub x%lx (%d, %d, %d) mark=%d\n", (unsigned long) s.sh,
pointmark(pts[3]), pointmark(pts[4]), pointmark(pts[5]),
getshellmark(s));
facenormal(pts[3], pts[4], pts[5], n, 1);
printf(" area=%g, lengths: %g, %g, %g\n", 0.5 * sqrt(DOT(n, n)),
DIST(pts[3], pts[4]), DIST(pts[4], pts[5]), DIST(pts[5], pts[3]));
// Print coplanar adjacent subfaces.
s.shver = 0;
for (ii = 0; ii < 3; ii++) {
sspivot(s, s1);
if (s1.sh != NULL) {
printf(" seg x%lx (%d, %d)\n", (unsigned long) s1.sh,
pointmark(sorg(s1)), pointmark(sdest(s1)));
} else {
spivot(s, s1);
if (s1.sh != NULL) {
printf(" sub x%lx (%d, %d, %d)\n", (unsigned long) s1.sh,
pointmark(sorg(s1)), pointmark(sdest(s1)), pointmark(sapex(s1)));
} else {
printf(" No seg and sub at (%d, %d)!\n", pointmark(sorg(s)),
pointmark(sdest(s)));
}
}
senextself(s);
}
stpivot(s, t);
if (t.tet != NULL) {
// Print two adjacent tets.
symedge(t, t1);
// Now t and t1 share the face.
printf(" tet x%lx (%d, %d, %d, %d) %d\n", (unsigned long) t.tet,
pointmark(org(t)), pointmark(dest(t)), pointmark(apex(t)),
pointmark(oppo(t)), t.loc);
printf(" tet x%lx (%d, %d, %d, %d) %d\n", (unsigned long) t1.tet,
pointmark(org(t1)), pointmark(dest(t1)), pointmark(apex(t1)),
pointmark(oppo(t1)), t1.loc);
if (((point) t1.tet[7] != dummypoint) &&
((point) t.tet[7] != dummypoint)) {
pts = (point *) t.tet;
sign = insphere(pts[4], pts[5], pts[6], pts[7], oppo(t1));
printf(" %s (sign = %.g).\n", sign > 0 ? "Delaunay" :
(sign < 0 ? "Non-Delaunay" : "Cosphere"), sign);
if (sign == 0) {
sign = insphere_sos(pts[4], pts[5], pts[6], pts[7], oppo(t1));
printf(" %s (symbolic).\n", sign > 0 ? "Delaunay":"Non-Delaunay");
}
}
}
break;
}
}
s.sh = shellfacetraverse(subfacepool);
}
if (s.sh == NULL) {
printf(" !! Not exist.\n");
}
delete [] marklist;
subfacepool->pathblock = bakpathblock;
subfacepool->pathitem = bakpathitem;
subfacepool->pathitemsleft = bakpathitemsleft;
subfacepool->alignbytes = bakalignbytes;
}
///////////////////////////////////////////////////////////////////////////////
// Print the information of the subsegment (i, j).
// Return 1 if seg-to-tet pointer is broken.
int tetgenmesh::psubseg(int i, int j)
{
triface t;
face s; //, s1;
point forg, fdest;
bool bflag;
bflag = false;
s.shver = 0;
subsegpool->traversalinit();
s.sh = shellfacetraverse(subsegpool);
while (s.sh != NULL) {
if (pointmark(sorg(s)) == i) {
if (pointmark(sdest(s)) == j) {
bflag = true;
}
} else if (pointmark(sorg(s)) == j) {
if (pointmark(sdest(s)) == i) {
sesymself(s);
bflag = true;
}
}
if (bflag) {
// Print the original segment containing [i, j]
forg = farsorg(s);
fdest = farsdest(s);
printf(" seg x%lx (%d, %d) < (%d, %d)\n", (unsigned long) s.sh, i, j,
pointmark(forg), pointmark(fdest));
// Chekc seg-to-tet pointer
stpivot(s, t);
if (t.tet != NULL) {
if (t.tet[4] != NULL) {
forg = org(t);
fdest = dest(t);
if (((pointmark(forg) == i) && (pointmark(fdest) == j)) ||
((pointmark(forg) == j) && (pointmark(fdest) == i))) {
printf(" adj tet x%lx (%d, %d, %d, %d)\n", (unsigned long) t.tet,
pointmark(forg), pointmark(fdest), pointmark(apex(t)),
pointmark(oppo(t)));
} else {
printf(" !! Wrong seg-to-tet pointer.\n");
return 1;
}
} else {
printf(" !! A DEAD seg-to-tet pointer.\n");
return 1;
}
}
/*// Print the adjacent subsegments at i and j.
senext2(s, s1);
spivotself(s1);
if (s1.sh != NULL) {
if (sdest(s1) != i) sesymself(s1);
printf(" [%d] seg x%lx (%d, %d)\n", i, (unsigned long) s1.sh,
pointmark(sorg(s1)), pointmark(sdest(s1)));
} else {
printf(" [%d] NULL", i);
}
senext(s, s1);
spivotself(s1);
if (s1.sh != NULL) {
if (sorg(s1) != j) sesymself(s1);
printf(" [%d] seg x%lx (%d, %d)\n", j, (unsigned long) s1.sh,
pointmark(sorg(s1)), pointmark(sdest(s1)));
} else {
printf(" [%d] NULL", j);
}*/
break;
}
s.sh = shellfacetraverse(subsegpool);
}
if (!bflag) {
printf(" !! Not exist.\n");
}
return 0;
}
///////////////////////////////////////////////////////////////////////////////
// Print the index of the point.
int tetgenmesh::pmark(point p)
{
return pointmark(p);
}
void tetgenmesh::pvert(point pt)
{
triface adjtet;
int idx;
idx = ((int *) (pt))[pointmarkindex];
printf(" vertex %d: x%lx\n", idx, (unsigned long) pt);
idx = ((int *) (pt))[pointmarkindex + 1];
printf(" type: %d (%s infected).\n", idx >> 1, idx & 1 ? " " : "not");
decode(point2tet(pt), adjtet);
if (adjtet.tet != NULL) {
printf(" adjtet: x%lx (%d, %d, %d, %d).\n", (unsigned long) adjtet.tet,
pointmark(adjtet.tet[4]), pointmark(adjtet.tet[5]),
pointmark(adjtet.tet[6]), pointmark(adjtet.tet[7]));
} else {
printf(" No adjacent tet.\n");
}
}
int tetgenmesh::pverti(int idx)
{
triface adjtet;
point pt;
// Search the vertex.
pointpool->traversalinit();
pt = pointtraverse();
while (pt != NULL) {
if (idx == ((int *) (pt))[pointmarkindex]) break;
pt = pointtraverse();
}
if (pt == NULL) {
printf(" Not exist.\n");
return 0;
}
printf(" vertex %d: x%lx\n", idx, (unsigned long) pt);
idx = ((int *) (pt))[pointmarkindex + 1];
printf(" type: %d (%s infected).\n", idx >> 1, idx & 1 ? " " : "not");
decode(point2tet(pt), adjtet);
if (adjtet.tet == NULL) {
printf(" No adjacent tet.\n");
return 0;
}
if (adjtet.tet[4] == NULL) {
printf(" !! A DEAD adjacent tet.\n");
return 0;
}
printf(" adjtet: x%lx (%d, %d, %d, %d).\n", (unsigned long) adjtet.tet,
pointmark(adjtet.tet[4]), pointmark(adjtet.tet[5]),
pointmark(adjtet.tet[6]), pointmark(adjtet.tet[7]));
if (((point) adjtet.tet[4] == pt) || ((point) adjtet.tet[5] == pt) ||
((point) adjtet.tet[6] == pt) || ((point) adjtet.tet[7] == pt)) {
return 0;
} else {
return 1; // Bad point-to-tet map.
}
}
///////////////////////////////////////////////////////////////////////////////
// Geometrical tests.
REAL tetgenmesh::test_orient3d(int i, int j, int k, int l)
{
point *idx2ptmap;
REAL ori;
int idx;
idx = (int) pointpool->items;
if ((i > idx) || (j > idx) || (k > idx) || (l > idx)) {
printf("Input indices are invalid.\n");
return 0;
}
makeindex2pointmap(idx2ptmap);
ori = orient3d(idx2ptmap[i], idx2ptmap[j], idx2ptmap[k], idx2ptmap[l]);
delete [] idx2ptmap;
return ori;
}
REAL tetgenmesh::test_insphere(int i, int j, int k, int l, int m)
{
point *idx2ptmap;
REAL sign;
int idx;
idx = (int) pointpool->items;
if ((i > idx) || (j > idx) || (k > idx) || (l > idx) || (m > idx)) {
printf("Input indices are invalid.\n");
return 0;
}
makeindex2pointmap(idx2ptmap);
sign = insphere(idx2ptmap[i], idx2ptmap[j], idx2ptmap[k], idx2ptmap[l],
idx2ptmap[m]);
if (sign == 0) {
printf(" sign == 0.0! (symbolic perturbed) \n");
sign = insphere_sos(idx2ptmap[i], idx2ptmap[j], idx2ptmap[k], idx2ptmap[l],
idx2ptmap[m]);
}
delete [] idx2ptmap;
return sign;
}
///////////////////////////////////////////////////////////////////////////////
// test_tritri() Test if two triangles are intersecting.
int tetgenmesh::test_tritri(int a, int b, int c, int p, int q, int r)
{
point *idx2ptmap;
point A, B, C, P, Q, R;
enum intersection dir;
int ret, types[2], pos[4];
int idx, i;
idx = (int) pointpool->items;
if ((a > idx) || (b > idx) || (c > idx) ||
(p > idx) || (q > idx) || (r > idx) ||
(a<in->firstnumber) || (b<in->firstnumber) || (c<in->firstnumber) ||
(p<in->firstnumber) || (q<in->firstnumber) || (r<in->firstnumber)) {
printf("Input indices are invalid.\n");
return 0;
}
makeindex2pointmap(idx2ptmap);
A = idx2ptmap[a];
B = idx2ptmap[b];
C = idx2ptmap[c];
P = idx2ptmap[p];
Q = idx2ptmap[q];
R = idx2ptmap[r];
ret = tri_tri_test(A, B, C, P, Q, R, NULL, 1, types, pos);
// Report the intersection types and positions.
for (i = 0; i < 2; i++) {
dir = (enum tetgenmesh::intersection) types[i];
switch (dir) {
case tetgenmesh::DISJOINT:
printf(" DISJOINT\n"); break;
case tetgenmesh::SHAREVERT:
printf(" SHAREVERT %d %d\n", pos[i*2], pos[i*2+1]); break;
case tetgenmesh::SHAREEDGE:
printf(" SHAREEDGE %d %d\n", pos[i*2], pos[i*2+1]); break;
case tetgenmesh::SHAREFACE:
printf(" SHAREFACE\n"); break;
case tetgenmesh::TOUCHEDGE:
printf(" TOUCHEDGE %d %d\n", pos[i*2], pos[i*2+1]); break;
case tetgenmesh::TOUCHFACE:
printf(" TOUCHFACE %d %d\n", pos[i*2], pos[i*2+1]); break;
case tetgenmesh::ACROSSVERT:
printf(" ACROSSVERT %d %d\n", pos[i*2], pos[i*2+1]); break;
case tetgenmesh::ACROSSEDGE:
printf(" ACROSSEDGE %d %d\n", pos[i*2], pos[i*2+1]); break;
case tetgenmesh::ACROSSFACE:
printf(" ACROSSFACE %d %d\n", pos[i*2], pos[i*2+1]); break;
case tetgenmesh::ACROSSTET:
printf(" ACROSSTET\n"); break;
case tetgenmesh::TRIEDGEINT:
printf(" TRIEDGEINT %d %d\n", pos[i*2], pos[i*2+1]); break;
case tetgenmesh::EDGETRIINT:
printf(" EDGETRIINT %d %d\n", pos[i*2], pos[i*2+1]); break;
}
}
delete [] idx2ptmap;
return ret;
}
///////////////////////////////////////////////////////////////////////////////
// Print an array of tetrahedra (in draw command)
void tetgenmesh::print_cavebdrylist()
{
FILE *fout;
triface *cavetet;
int i;
printf(" Dump %ld faces to dump_cavebdry.lua.\n", cavebdrylist->objects);
fout = fopen("dump_cavebdry.lua", "w");
for (i = 0; i < cavebdrylist->objects; i++) {
cavetet = (triface *) fastlookup(cavebdrylist, i);
fprintf(fout, "p:draw_subface(%d, %d, %d) -- %d\n",
pointmark(org(*cavetet)), pointmark(dest(*cavetet)),
pointmark(apex(*cavetet)), i);
}
fclose(fout);
}
///////////////////////////////////////////////////////////////////////////////
// Print current faces in flipstack (in draw command)
void tetgenmesh::print_flipstack()
{
badface *traveface;
int i;
traveface = futureflip;
i = 0;
while (traveface != NULL) {
if (traveface->tt.tet[4] != NULL) {
printf("%2d (%d, %d, %d, %d) - %d\n",i+1,pointmark(org(traveface->tt)),
pointmark(dest(traveface->tt)), pointmark(apex(traveface->tt)),
pointmark(oppo(traveface->tt)), pointmark(traveface->foppo));
}
traveface = traveface->nextitem;
i++;
}
}
///////////////////////////////////////////////////////////////////////////////
// Print an array of tetrahedra, faces, subfaces (in draw command)
// If 'nohulltet' is TRUE, ignore hull tets.
void tetgenmesh::print_tetarray(arraypool *tetarray, bool nohulltet)
{
triface *parytet;
int i;
for (i = 0; i < tetarray->objects; i++) {
parytet = (triface *) fastlookup(tetarray, i);
if (parytet->tet == NULL) {
printf("-- NOT A TET -- %d\n", i + 1); continue;
}
if (nohulltet) {
if ((point) parytet->tet[7] == dummypoint) continue;
}
if (parytet->tet[4] == NULL) {
printf("-- A DEAD TET -- %d\n", i + 1); continue;
}
if ((point) parytet->tet[7] != dummypoint) {
printf("p:draw_tet(%d, %d, %d, %d) -- %d",
pointmark(org(*parytet)), pointmark(dest(*parytet)),
pointmark(apex(*parytet)), pointmark(oppo(*parytet)), i + 1);
} else {
printf("-- p:draw_tet(%d, %d, %d, %d) -- %d (hulltet)",
pointmark(org(*parytet)), pointmark(dest(*parytet)),
pointmark(apex(*parytet)), pointmark(oppo(*parytet)), i + 1);
}
if (marktested(*parytet)) {
printf(" (marked)");
}
if (infected(*parytet)) {
printf(" (infect)");
}
printf("\n");
}
}
void tetgenmesh::print_facearray(arraypool *facearray)
{
triface *parytet;
int i;
for (i = 0; i < facearray->objects; i++) {
parytet = (triface *) fastlookup(facearray, i);
printf("p:draw_subface(%d, %d, %d) -- %d\n",
pointmark(org(*parytet)), pointmark(dest(*parytet)),
pointmark(apex(*parytet)), i + 1);
}
}
void tetgenmesh::print_subfacearray(arraypool *subfacearray)
{
face *parysub;
int i;
for (i = 0; i < subfacearray->objects; i++) {
parysub = (face *) fastlookup(subfacearray, i);
printf("p:draw_subface(%d, %d, %d) -- %d\n",
pointmark(sorg(*parysub)), pointmark(sdest(*parysub)),
pointmark(sapex(*parysub)), i + 1);
}
}
///////////////////////////////////////////////////////////////////////////////
// dump the boundary faces of a cavity into file "cavity.lua"
// 'topfaces' and 'botfaces' are two arrays.
// NOTE: hull tets may be included.
void tetgenmesh::dump_cavity(arraypool *topfaces, arraypool *botfaces = NULL)
{
FILE *fout;
arraypool *cavfaces;
triface *paryface;
int i, k;
printf(" dump %ld topfaces to cavity.lua\n", topfaces->objects);
if (botfaces != NULL) {
printf(" dump %ld botfaces to cavity.lua\n", botfaces->objects);
}
fout = fopen("cavity.lua", "w");
for (k = 0; k < 2; k++) {
cavfaces = (k == 0 ? topfaces : botfaces);
if (cavfaces != NULL) {
for (i = 0; i < cavfaces->objects; i++) {
paryface = (triface *) fastlookup(cavfaces, i);
fprintf(fout, "p:draw_subface(%d, %d, %d) -- %d\n",
pointmark(org(*paryface)), pointmark(dest(*paryface)),
pointmark(apex(*paryface)), i + 1);
}
}
}
fclose(fout);
}
///////////////////////////////////////////////////////////////////////////////
// dump a facet containing a given subface s.
void tetgenmesh::dump_facetof(face *pssub, char *filename)
{
FILE *fout;
char outfilename[256];
arraypool *tmpfaces;
face *parysh, *parysh2, s;
face checkseg;
int ii, jj;
tmpfaces = new arraypool(sizeof(face), 8);
smarktest(*pssub);
tmpfaces->newindex((void **) &parysh);
*parysh = *pssub;
for (ii = 0; ii < tmpfaces->objects; ii++) {
parysh = (face *) fastlookup(tmpfaces, ii);
for (jj = 0; jj < 3; jj++) {
sspivot(*parysh, checkseg);
if (checkseg.sh == NULL) {
spivot(*parysh, s);
if (s.sh != NULL) {
if (!smarktested(s)) {
smarktest(s);
tmpfaces->newindex((void **) &parysh2);
*parysh2 = s;
}
}
}
senextself(*parysh);
}
}
for (ii = 0; ii < tmpfaces->objects; ii++) {
parysh = (face *) fastlookup(tmpfaces, ii);
sunmarktest(*parysh);
}
if (filename != NULL) {
sprintf(outfilename, filename);
} else {
sprintf(outfilename, "facet.lua");
}
printf(" dump %ld subfaces to %s\n", tmpfaces->objects, outfilename);
fout = fopen(outfilename, "w");
for (ii = 0; ii < tmpfaces->objects; ii++) {
parysh = (face *) fastlookup(tmpfaces, ii);
fprintf(fout, "p:draw_subface(%d, %d, %d) -- %d\n",
pointmark(sorg(*parysh)), pointmark(sdest(*parysh)),
pointmark(sapex(*parysh)), ii + 1);
}
fclose(fout);
delete tmpfaces;
}
///////////////////////////////////////////////////////////////////////////////
// Dump the new tets of a cavity (in draw_tet() lua commands)
void tetgenmesh::dump_cavitynewtets()
{
arraypool *newtets;
triface searchtet, neightet, *parytet;
point *ppt;
int i;
newtets = new arraypool(sizeof(triface), 8);
// Collect all tets of the DT.
marktest(recenttet);
newtets->newindex((void **) &parytet);
*parytet = recenttet;
for (i = 0; i < newtets->objects; i++) {
searchtet = * (triface *) fastlookup(newtets, i);
for (searchtet.loc = 0; searchtet.loc < 4; searchtet.loc++) {
sym(searchtet, neightet);
if (!marktested(neightet)) {
marktest(neightet);
newtets->newindex((void **) &parytet);
*parytet = neightet;
}
}
}
// Comment: All new tets are marktested.
// Output the new tets.
for (i = 0; i < newtets->objects; i++) {
parytet = (triface *) fastlookup(newtets, i);
ppt = (point *) parytet->tet;
if (ppt[7] != dummypoint) {
printf("p:draw_tet(%d, %d, %d, %d) -- %i\n", pointmark(ppt[4]),
pointmark(ppt[5]), pointmark(ppt[6]), pointmark(ppt[7]), i);
} else {
printf("-- p:draw_tet(%d, %d, %d, -1) -- %i\n", pointmark(ppt[4]),
pointmark(ppt[5]), pointmark(ppt[6]), i);
}
unmarktest(*parytet); // Unmarktest it.
}
delete newtets;
}
///////////////////////////////////////////////////////////////////////////////
// print the status of the binary tree.
void tetgenmesh::print_btree()
{
point **pptary, *ptary;
long arylen, i, j;
for (i = 0; i < (int) treenode_list->objects; i++) {
pptary = (point **) fastlookup(treenode_list, i);
ptary = *pptary;
arylen = (long) ptary[0];
printf("%4d (%2d)", i + 1, arylen);
for (j = 1; j <= arylen; j++) {
printf(" %d", pointmark(ptary[j]));
}
printf("\n");
} // i
}
void tetgenmesh::print_vertexarray(point* vertexarray, int arraylen)
{
int i;
for (i = 0; i < arraylen; i++) {
printf("%4d: %4d\n", i, pointmark(vertexarray[i]));
}
}
///////////////////////////////////////////////////////////////////////////////
// checkpinfect() Check the pinfect() flags of points
int tetgenmesh::checkpinfect()
{
point pt;
int pinfectcount = 0;
printf("Checking point infections.\n");
pointpool->traversalinit();
pt = pointtraverse();
while (pt != NULL) {
if (pinfected(pt)) {
printf(" !! Point %d is infected.\n", pointmark(pt));
pinfectcount++;
}
pt = pointtraverse();
}
printf(" %d pinfected points.\n", pinfectcount);
return pinfectcount;
}
#endif // #ifndef meshstatCXX | [
"sihang@0234898f-7f2f-0410-b2a0-ad3834006b92"
] | sihang@0234898f-7f2f-0410-b2a0-ad3834006b92 |
57b1d53eb18edb0f7f4f6e127536429d6b7cb5a6 | 51e74c0b7c9e069d5616d59d96e7df7a8a9a1a2a | /apis/Tdx_Trade/SingleUser.cpp | 49b5488c259bfefc773dc446ed1330d22c715c6a | [] | no_license | riverdarda/XAPI2 | 76cb560562069321dacdd49c91b7873c6d6bfcb9 | 3ff2343e3ed295bfffc39bace8db6d310e009d33 | refs/heads/master | 2021-01-18T19:48:57.783468 | 2016-01-28T09:23:29 | 2016-01-28T09:23:29 | 50,707,456 | 2 | 0 | null | 2016-01-30T03:43:24 | 2016-01-30T03:43:24 | null | UTF-8 | C++ | false | false | 24,237 | cpp | #include "stdafx.h"
#include "SingleUser.h"
#include "../../common/Queue/MsgQueue.h"
#include "TypeConvert.h"
#include "TraderApi.h"
#define QUERY_TIME_MIN (3)
#define QUERY_TIME_MAX (60)
int Today(int day)
{
time_t now = time(0);
now += day * 86400;
struct tm *ptmNow = localtime(&now);
return (ptmNow->tm_year + 1900) * 10000
+ (ptmNow->tm_mon + 1) * 100
+ ptmNow->tm_mday;
}
void CreateID(char* pOut, char* pDate, char*pZh, char* wtbh)
{
if (pDate == nullptr || strlen(pDate) == 0)
{
sprintf(pOut, "%d:%s:%s", Today(0), pZh, wtbh);
}
else
{
sprintf(pOut, "%s:%s:%s", pDate, pZh, wtbh);
}
}
CSingleUser::CSingleUser(CTraderApi* pApi)
{
m_pApi = pApi;
m_pClient = nullptr;
memset(m_UserID, 0, sizeof(m_UserID));
}
CSingleUser::~CSingleUser()
{
}
void CSingleUser::OutputQueryTime(time_t t, double db, const char* szSource)
{
LogField* pField = (LogField*)m_msgQueue->new_block(sizeof(LogField));
sprintf(pField->Message, "UserID:%s,Source:%s,Add:%d,Time:%s", m_UserID, szSource, (int)db, ctime(&t));
// 去了最后的回车
int len = strlen(pField->Message);
pField->Message[len - 1] = 0;
m_msgQueue->Input_NoCopy(ResponeType::ResponeType_OnLog, m_msgQueue, m_pClass, true, 0, pField, sizeof(LogField), nullptr, 0, nullptr, 0);
}
void CSingleUser::CheckThenQueryOrder(time_t _now)
{
if (_now > m_QueryOrderTime)
{
double _queryTime = QUERY_TIME_MAX;
m_QueryOrderTime = time(nullptr) + _queryTime;
OutputQueryTime(m_QueryOrderTime, _queryTime, "QueryOrder");
ReqQryOrder();
}
}
void CSingleUser::CheckThenQueryTrade(time_t _now)
{
if (_now > m_QueryTradeTime)
{
double _queryTime = QUERY_TIME_MAX;
m_QueryTradeTime = time(nullptr) + _queryTime;
OutputQueryTime(m_QueryTradeTime, _queryTime, "QueryTrade");
ReqQryTrade();
}
}
void CSingleUser::ReqQryOrder()
{
// 进行查询
ReqQueryData_STRUCT query = { 0 };
query.Client = m_pClient;
strcpy(query.KHH, m_UserID);
query.requestType = REQUEST_DRWT;
query.bAll = false;
m_pApi->ReqQuery(&query);
}
void CSingleUser::ReqQryTrade()
{
// 进行查询
ReqQueryData_STRUCT query = { 0 };
query.Client = m_pClient;
strcpy(query.KHH, m_UserID);
query.requestType = REQUEST_DRCJ;
query.bAll = false;
m_pApi->ReqQuery(&query);
}
int CSingleUser::OnRespone_ReqQryOrder(CTdxApi* pApi, RequestRespone_STRUCT* pRespone)
{
ReqQueryData_STRUCT* pQuery = (ReqQueryData_STRUCT*)pRespone->pContent;
if (pRespone->pErr)
{
ErrorField* pField = (ErrorField*)m_msgQueue->new_block(sizeof(ErrorField));
pField->RawErrorID = pRespone->pErr->ErrCode;
strcpy(pField->Text, pRespone->pErr->ErrInfo);
strcpy(pField->Source, "OnRespone_ReqQryOrder");
m_msgQueue->Input_NoCopy(ResponeType::ResponeType_OnRtnError, m_msgQueue, m_pClass, 0, 0, pField, sizeof(ErrorField), nullptr, 0, nullptr, 0);
}
WTLB_STRUCT** ppRS = nullptr;
CharTable2WTLB(pRespone->ppFieldInfo, pRespone->ppResults, &ppRS, pRespone->Client);
// 操作前清空，按说之前已经清空过一次了
m_NewOrderList.clear();
// 有未完成的，标记为true
bool IsDone = true;
// 有未申报的，标记为true
bool IsNotSent = false;
// 有更新的
bool IsUpdated = false;
if (ppRS)
{
int i = 0;
while (ppRS[i])
{
// 将撤单委托过滤
if (ppRS[i]->MMBZ_ != MMBZ_Cancel && ppRS[i]->MMBZ_ != MMBZ_Buy_Cancel && ppRS[i]->MMBZ_ != MMBZ_Sell_Cancel)
{
// 需要将它输入到一个地方用于计算，这个是临时的，需要删除
OrderField* pField = (OrderField*)m_msgQueue->new_block(sizeof(OrderField));
WTLB_2_OrderField_0(ppRS[i], pField);
CreateID(pField->ID, ppRS[i]->WTRQ, ppRS[i]->GDDM, ppRS[i]->WTBH);
pField->Date = ppRS[i]->WTRQ_ == 0 ? Today(0) : ppRS[i]->WTRQ_;//日期为0，重新赋值
m_NewOrderList.push_back(pField);
if (!ZTSM_IsDone(ppRS[i]->ZTSM_))
{
IsDone = false;
}
if (ZTSM_IsNotSent(ppRS[i]->ZTSM_))
{
IsNotSent = true;
}
// 需要将其保存起来，是只保存一次，还是每次都更新呢？个人认为只保存一次即可，反正是用来撤单的
unordered_map<string, WTLB_STRUCT*>::iterator it = m_pApi->m_id_api_order.find(pField->ID);
if (it == m_pApi->m_id_api_order.end())
{
WTLB_STRUCT* pWTField = (WTLB_STRUCT*)m_msgQueue->new_block(sizeof(WTLB_STRUCT));
memcpy(pWTField, ppRS[i], sizeof(WTLB_STRUCT));
m_pApi->m_id_api_order.insert(pair<string, WTLB_STRUCT*>(pField->ID, pWTField));
}
}
++i;
}
}
// 委托列表
// 1.新增的都需要输出
// 2.老的看是否有变化
++m_OrderNotUpdateCount;
int i = 0;
list<OrderField*>::iterator it2 = m_OldOrderList.begin();
for (list<OrderField*>::iterator it = m_NewOrderList.begin(); it != m_NewOrderList.end(); ++it)
{
OrderField* pField = *it;
bool bUpdate = false;
if (i >= m_OldOrderList.size())
{
bUpdate = true;
}
else
{
// 相同位置的部分
OrderField* pOldField = *it2;
if (pOldField->LeavesQty != pField->LeavesQty || pOldField->Status != pField->Status)
{
bUpdate = true;
}
}
if (bUpdate)
{
IsUpdated = true;
m_OrderNotUpdateCount = 0;
// 如果能找到下单时的委托，就修改后发出来
unordered_map<string, OrderField*>::iterator it = m_pApi->m_id_platform_order.find(pField->ID);
if (it == m_pApi->m_id_platform_order.end())
{
// 因为上次生成的可能在后期删了，所以要复制一份
OrderField* pField_ = (OrderField*)m_msgQueue->new_block(sizeof(OrderField));
memcpy(pField_, pField, sizeof(OrderField));
m_pApi->m_id_platform_order.insert(pair<string, OrderField*>(pField_->ID, pField_));
}
else
{
OrderField* pField_ = it->second;
memcpy(pField_, pField, sizeof(OrderField));
}
m_msgQueue->Input_Copy(ResponeType::ResponeType_OnRtnOrder, m_msgQueue, m_pClass, 0, 0, pField, sizeof(OrderField), nullptr, 0, nullptr, 0);
}
// 前一个可能为空，移动到下一个时需要注意
if (it2 != m_OldOrderList.end())
{
++it2;
}
++i;
}
if (pQuery->bAll)
{
int i = 0;
int count = m_NewOrderList.size();
for (list<OrderField*>::iterator it = m_NewOrderList.begin(); it != m_NewOrderList.end(); ++it)
{
OrderField* pField = *it;
m_msgQueue->Input_Copy(ResponeType::ResponeType_OnRspQryOrder, m_msgQueue, m_pClass, i == count - 1, 0, pField, sizeof(OrderField), nullptr, 0, nullptr, 0);
++i;
}
}
// 将老数据清理，防止内存泄漏
for (list<OrderField*>::iterator it = m_OldOrderList.begin(); it != m_OldOrderList.end(); ++it)
{
OrderField* pField = *it;
m_msgQueue->delete_block(pField);
}
// 做交换
m_OldOrderList.clear();
m_OldOrderList = m_NewOrderList;
m_NewOrderList.clear();
double _queryTime = 0;
if (!IsDone)
{
if (!IsUpdated)
{
// 没有更新，是否要慢点查
_queryTime = 0.5 * QUERY_TIME_MAX + QUERY_TIME_MIN;
}
// 有没有完成的，需要定时查询
if (IsNotSent)
{
// 有没申报的，是否没在交易时间？慢点查
_queryTime = 0.5 * QUERY_TIME_MAX + QUERY_TIME_MIN;
}
else
{
// 可能是交易时间了，是否需要考虑
_queryTime = 2 * QUERY_TIME_MIN;
// 可能有些挂单一天都不会成交，挂在这一直导致查太多，加一下查询计数
if (m_OrderNotUpdateCount >= 3)
{
_queryTime = 0.5 * QUERY_TIME_MAX + QUERY_TIME_MIN;
}
}
}
else
{
// 全完成了，可以不查或慢查
_queryTime = 5 * QUERY_TIME_MAX;
}
m_QueryOrderTime = time(nullptr) + _queryTime;
OutputQueryTime(m_QueryOrderTime, _queryTime, "NextQueryOrder_QueryOrder");
// 决定成交查询间隔
if (IsUpdated)
{
// 委托可能是撤单，也有可能是成交了，赶紧查一下
_queryTime = 0;
m_QueryTradeTime = time(nullptr) + _queryTime;
OutputQueryTime(m_QueryTradeTime, _queryTime, "NextQueryTrade_QueryOrder");
}
else
{
// 委托没有变化，那成交就没有必要查那么快了
_queryTime = 5 * QUERY_TIME_MAX;
m_QueryTradeTime = time(nullptr) + _queryTime;
OutputQueryTime(m_QueryTradeTime, _queryTime, "NextQueryTrade_QueryOrder");
}
return 0;
}
double GetTradeListQty(list<TradeField*> &tradeList, int count)
{
double Qty = 0;
int i = 0;
for (list<TradeField*>::iterator it = tradeList.begin(); it != tradeList.end(); ++it)
{
++i;
if (i > count)
{
break;
}
TradeField* pField = *it;
Qty += pField->Qty;
}
return Qty;
}
void TradeList2TradeMap(list<TradeField*> &tradeList, unordered_map<string, TradeField*> &tradeMap)
{
// 只在这个函数中new和delete应当没有问题
for (unordered_map<string, TradeField*>::iterator it = tradeMap.begin(); it != tradeMap.end(); ++it)
{
TradeField* pNewField = it->second;
delete[] pNewField;
}
tradeMap.clear();
// 将多个合约拼接成
for (list<TradeField*>::iterator it = tradeList.begin(); it != tradeList.end(); ++it)
{
TradeField* pField = *it;
unordered_map<string, TradeField*>::iterator it2 = tradeMap.find(pField->ID);
if (it2 == tradeMap.end())
{
TradeField* pNewField = new TradeField;
memcpy(pNewField, pField, sizeof(TradeField));
tradeMap[pField->ID] = pNewField;
}
else
{
TradeField* pNewField = it2->second;
pNewField->Price = pField->Price;
pNewField->Qty += pField->Qty;
}
}
}
int CSingleUser::OnRespone_ReqQryTrade(CTdxApi* pApi, RequestRespone_STRUCT* pRespone)
{
ReqQueryData_STRUCT* pQuery = (ReqQueryData_STRUCT*)pRespone->pContent;
if (pRespone->pErr)
{
ErrorField* pField = (ErrorField*)m_msgQueue->new_block(sizeof(ErrorField));
pField->RawErrorID = pRespone->pErr->ErrCode;
strcpy(pField->Text, pRespone->pErr->ErrInfo);
strcpy(pField->Source, "OnRespone_ReqQryTrade");
m_msgQueue->Input_NoCopy(ResponeType::ResponeType_OnRtnError, m_msgQueue, m_pClass, 0, 0, pField, sizeof(ErrorField), nullptr, 0, nullptr, 0);
}
CJLB_STRUCT** ppRS = nullptr;
CharTable2CJLB(pRespone->ppFieldInfo, pRespone->ppResults, &ppRS, pRespone->Client);
// 操作前清空，按说之前已经清空过一次了
m_NewTradeList.clear();
if (ppRS)
{
// 利用成交编号的大小来判断正反序
if (!m_TradeListReverse)
{
int count = GetCountStructs((void**)ppRS);
if (count > 1)
{
// 转成数字的比较，是否会有非数字的情况出现？
long CJBH0 = atol(ppRS[0]->CJBH);
long CJBH1 = atol(ppRS[count - 1]->CJBH);
if (CJBH0 > CJBH1)
{
m_TradeListReverse = true;
}
}
}
int i = 0;
while (ppRS[i])
{
// 有部分券商，撤单也计成交了，真无语了，需要过滤
if (ppRS[i]->CJSL_ <= 0)
{
++i;
continue;
}
TradeField* pField = (TradeField*)m_msgQueue->new_block(sizeof(TradeField));
CJLB_2_TradeField(ppRS[i], pField);
pField->Date = ppRS[i]->CJRQ_ == 0 ? Today(0) : ppRS[i]->CJRQ_;//日期为0，重新赋值
if (m_TradeListReverse)
{
// 华泰查出来的表后生成的排第一，所以要处理一下
m_NewTradeList.push_front(pField);
}
else
{
m_NewTradeList.push_back(pField);
}
++i;
}
}
// 新查出来的反而少了，华泰有合并成交的情况，这种如何处理？
// 对同ID的需要累加，有发现累加不对应的，应当处理
// 同样条数的，也有可能其中的有变化，如何处理？
bool bTryMerge = false;
int OldTradeListCount = m_OldTradeList.size();
int NewTradeListCount = m_NewTradeList.size();
if (NewTradeListCount < OldTradeListCount)
{
// 行数变少了，应当是合并了
bTryMerge = true;
}
else if (OldTradeListCount == 0)
{
// 如果上一次的为空，不管这次查出来的是合并还是没有合并，都没有关系，当成没合并处理即可
}
else if (NewTradeListCount == OldTradeListCount)
{
// 行数不变，但有可能是其中的一条部分成交的更新，所以检查一下
double OldQty = GetTradeListQty(m_OldTradeList, m_OldTradeList.size());
double NewQty = GetTradeListQty(m_NewTradeList, m_NewTradeList.size());
if (NewQty != OldQty)
{
// 同样长度成交量发生了变化，可能是合并的列表其中一个新成交了
bTryMerge = true;
}
}
else
{
// 行数变多了，只要其中上次的部分有变化就需要检查一下
double OldQty = GetTradeListQty(m_OldTradeList, m_OldTradeList.size());
double NewQty = GetTradeListQty(m_NewTradeList, m_NewTradeList.size());
if (NewQty != OldQty)
{
bTryMerge = true;
}
}
if (bTryMerge)
{
// 合并列表的处理方法
// 如果上次是合并，这次就没有必要再生成一次了
if (m_OldTradeMap.size() == 0 || !m_LastIsMerge)
{
for (unordered_map<string, TradeField*>::iterator it = m_OldTradeMap.begin(); it != m_OldTradeMap.end(); ++it)
{
TradeField* pField = it->second;
delete[] pField;
}
m_OldTradeMap.clear();
TradeList2TradeMap(m_OldTradeList, m_OldTradeMap);
}
TradeList2TradeMap(m_NewTradeList, m_NewTradeMap);
CompareTradeMapAndEmit(m_OldTradeMap, m_NewTradeMap);
// 交换
for (unordered_map<string, TradeField*>::iterator it = m_OldTradeMap.begin(); it != m_OldTradeMap.end(); ++it)
{
TradeField* pField = it->second;
delete[] pField;
}
m_OldTradeMap.clear();
m_OldTradeMap = m_NewTradeMap;
m_NewTradeMap.clear();
m_LastIsMerge = true;
}
else
{
// 普通的处理方法
CompareTradeListAndEmit(m_OldTradeList, m_NewTradeList);
m_LastIsMerge = false;
}
if (pQuery->bAll)
{
int i = 0;
int count = m_NewTradeList.size();
for (list<TradeField*>::iterator it = m_NewTradeList.begin(); it != m_NewTradeList.end(); ++it)
{
TradeField* pField = *it;
m_msgQueue->Input_Copy(ResponeType::ResponeType_OnRspQryTrade, m_msgQueue, m_pClass, i == count - 1, 0, pField, sizeof(TradeField), nullptr, 0, nullptr, 0);
++i;
}
}
// 将老数据清理，防止内存泄漏
for (list<TradeField*>::iterator it = m_OldTradeList.begin(); it != m_OldTradeList.end(); ++it)
{
TradeField* pField = *it;
m_msgQueue->delete_block(pField);
}
// 做交换
m_OldTradeList.clear();
m_OldTradeList = m_NewTradeList;
m_NewTradeList.clear();
return 0;
}
void CSingleUser::CompareTradeMapAndEmit(unordered_map<string, TradeField*> &oldMap, unordered_map<string, TradeField*> &newMap)
{
for (unordered_map<string, TradeField*>::iterator it = newMap.begin(); it != newMap.end(); ++it)
{
TradeField* pNewField = it->second;
unordered_map<string, TradeField*>::iterator it2 = oldMap.find(pNewField->ID);
if (it2 == oldMap.end())
{
// 没找到,是新单
m_msgQueue->Input_Copy(ResponeType::ResponeType_OnRtnTrade, m_msgQueue, m_pClass, 0, 0, pNewField, sizeof(TradeField), nullptr, 0, nullptr, 0);
}
else
{
TradeField* pOldField = it2->second;
int Qty = pNewField->Qty - pOldField->Qty;
if (Qty > 0)
{
// 有变化的单
TradeField* pField = new TradeField;
memcpy(pField, pNewField, sizeof(TradeField));
pField->Qty = Qty;
m_msgQueue->Input_Copy(ResponeType::ResponeType_OnRtnTrade, m_msgQueue, m_pClass, 0, 0, pNewField, sizeof(TradeField), nullptr, 0, nullptr, 0);
delete[] pField;
}
}
}
}
void CSingleUser::CompareTradeListAndEmit(list<TradeField*> &oldList, list<TradeField*> &newList)
{
int i = 0;
list<TradeField*>::iterator it2 = oldList.begin();
for (list<TradeField*>::iterator it = newList.begin(); it != newList.end(); ++it)
{
TradeField* pField = *it;
bool bUpdate = false;
if (i >= oldList.size())
{
bUpdate = true;
}
//else
//{
// // 相同位置的部分
// TradeField* pOldField = *it2;
// if (pOldField->Qty != pField->Qty)
// {
// bUpdate = true;
// }
//}
if (bUpdate)
{
m_msgQueue->Input_Copy(ResponeType::ResponeType_OnRtnTrade, m_msgQueue, m_pClass, 0, 0, pField, sizeof(TradeField), nullptr, 0, nullptr, 0);
}
// 前一个可能为空，移动到下一个时需要注意
if (it2 != oldList.end())
{
++it2;
}
++i;
}
}
int CSingleUser::OnRespone_ReqUserLogin(CTdxApi* pApi, RequestRespone_STRUCT* pRespone)
{
if (pRespone->pErr)
{
RspUserLoginField* pField = (RspUserLoginField*)m_msgQueue->new_block(sizeof(RspUserLoginField));
pField->RawErrorID = pRespone->pErr->ErrCode;
strcpy(pField->Text, pRespone->pErr->ErrInfo);
m_msgQueue->Input_NoCopy(ResponeType::ResponeType_OnConnectionStatus, m_msgQueue, m_pClass, ConnectionStatus::ConnectionStatus_Disconnected, 0, pField, sizeof(RspUserLoginField), nullptr, 0, nullptr, 0);
m_pApi->RemoveUser((CSingleUser*)pRespone->pUserData_Public);
}
else
{
m_msgQueue->Input_NoCopy(ResponeType::ResponeType_OnConnectionStatus, m_msgQueue, m_pClass, ConnectionStatus::ConnectionStatus_Logined, 0, nullptr, 0, nullptr, 0, nullptr, 0);
m_pApi->StartQueryThread();
}
// 查询股东列表，华泰证券可能一开始查会返回非知请求[1122]
GDLB_STRUCT** ppRS = nullptr;
CharTable2Login(pRespone->ppResults, &ppRS, pRespone->Client);
int count = GetCountStructs((void**)ppRS);
if (count > 0)
{
for (int i = 0; i < count; ++i)
{
InvestorField* pField = (InvestorField*)m_msgQueue->new_block(sizeof(InvestorField));
GDLB_2_InvestorField(ppRS[i], pField);
m_msgQueue->Input_NoCopy(ResponeType::ResponeType_OnRspQryInvestor, m_msgQueue, m_pClass, i == count - 1, 0, pField, sizeof(InvestorField), nullptr, 0, nullptr, 0);
}
m_msgQueue->Input_NoCopy(ResponeType::ResponeType_OnConnectionStatus, m_msgQueue, m_pClass, ConnectionStatus::ConnectionStatus_Done, 0, nullptr, 0, nullptr, 0, nullptr, 0);
}
return 0;
}
int CSingleUser::OnRespone_ReqQryInvestor(CTdxApi* pApi, RequestRespone_STRUCT* pRespone)
{
if (pRespone->pErr)
{
ErrorField* pField = (ErrorField*)m_msgQueue->new_block(sizeof(ErrorField));
pField->RawErrorID = pRespone->pErr->ErrCode;
strcpy(pField->Text, pRespone->pErr->ErrInfo);
strcpy(pField->Source, "OnRespone_ReqQryInvestor");
m_msgQueue->Input_NoCopy(ResponeType::ResponeType_OnRtnError, m_msgQueue, m_pClass, 0, 0, pField, sizeof(ErrorField), nullptr, 0, nullptr, 0);
}
GDLB_STRUCT** ppRS = nullptr;
CharTable2GDLB(pRespone->ppFieldInfo, pRespone->ppResults, &ppRS, pRespone->Client);
int count = GetCountStructs((void**)ppRS);
if (count>0)
{
for (int i = 0; i < count; ++i)
{
InvestorField* pField = (InvestorField*)m_msgQueue->new_block(sizeof(InvestorField));
GDLB_2_InvestorField(ppRS[i], pField);
m_msgQueue->Input_NoCopy(ResponeType::ResponeType_OnRspQryInvestor, m_msgQueue, m_pClass, i == count - 1, 0, pField, sizeof(InvestorField), nullptr, 0, nullptr, 0);
}
m_msgQueue->Input_NoCopy(ResponeType::ResponeType_OnConnectionStatus, m_msgQueue, m_pClass, ConnectionStatus::ConnectionStatus_Done, 0, nullptr, 0, nullptr, 0, nullptr, 0);
}
return 0;
}
int CSingleUser::OnRespone_ReqQryTradingAccount(CTdxApi* pApi, RequestRespone_STRUCT* pRespone)
{
if (pRespone->pErr)
{
ErrorField* pField = (ErrorField*)m_msgQueue->new_block(sizeof(ErrorField));
pField->RawErrorID = pRespone->pErr->ErrCode;
strcpy(pField->Text, pRespone->pErr->ErrInfo);
strcpy(pField->Source, "OnRespone_ReqQryTradingAccount");
m_msgQueue->Input_NoCopy(ResponeType::ResponeType_OnRtnError, m_msgQueue, m_pClass, 0, 0, pField, sizeof(ErrorField), nullptr, 0, nullptr, 0);
}
//if (pRespone->ppResults == nullptr)
//{
// return;
//}
ZJYE_STRUCT** ppRS = nullptr;
CharTable2ZJYE(pRespone->ppFieldInfo, pRespone->ppResults, &ppRS, pRespone->Client);
int count = GetCountStructs((void**)ppRS);
for (int i = 0; i < count; ++i)
{
AccountField* pField = (AccountField*)m_msgQueue->new_block(sizeof(AccountField));
ZJYE_2_AccountField(ppRS[i], pField);
//// 可能资金账号查不出来，手工填上
//if (strlen(pField->AccountID) <= 0)
//{
// // 多账户会有问题
// strcpy(pField->AccountID, m_pApi->GetAccount());
//}
m_msgQueue->Input_NoCopy(ResponeType::ResponeType_OnRspQryTradingAccount, m_msgQueue, m_pClass, i == count - 1, 0, pField, sizeof(AccountField), nullptr, 0, nullptr, 0);
}
return 0;
}
int CSingleUser::OnRespone_ReqQryInvestorPosition(CTdxApi* pApi, RequestRespone_STRUCT* pRespone)
{
if (pRespone->pErr)
{
ErrorField* pField = (ErrorField*)m_msgQueue->new_block(sizeof(ErrorField));
pField->RawErrorID = pRespone->pErr->ErrCode;
strcpy(pField->Text, pRespone->pErr->ErrInfo);
strcpy(pField->Source, "OnRespone_ReqQryInvestorPosition");
m_msgQueue->Input_NoCopy(ResponeType::ResponeType_OnRtnError, m_msgQueue, m_pClass, 0, 0, pField, sizeof(ErrorField), nullptr, 0, nullptr, 0);
}
GFLB_STRUCT** ppRS = nullptr;
CharTable2GFLB(pRespone->ppFieldInfo, pRespone->ppResults, &ppRS, pRespone->Client);
int count = GetCountStructs((void**)ppRS);
for (int i = 0; i < count; ++i)
{
PositionField* pField = (PositionField*)m_msgQueue->new_block(sizeof(PositionField));
// 应当处理一下，可能一个账号对应的有多个，如信用账户
GFLB_2_PositionField(ppRS[i], pField);
m_msgQueue->Input_NoCopy(ResponeType::ResponeType_OnRspQryInvestorPosition, m_msgQueue, m_pClass, i == count - 1, 0, pField, sizeof(PositionField), nullptr, 0, nullptr, 0);
}
return 0;
}
int CSingleUser::OnRespone_ReqOrderInsert(CTdxApi* pApi, RequestRespone_STRUCT* pRespone)
{
Order_STRUCT* pTdxOrder = (Order_STRUCT*)pRespone->pContent;
OrderField* pOrder = (OrderField*)pRespone->pUserData_Public2;
WTLB_STRUCT* pWTOrders = (WTLB_STRUCT*)m_msgQueue->new_block(sizeof(WTLB_STRUCT));
strcpy(pWTOrders->ZJZH, pTdxOrder->ZJZH);
strcpy(pWTOrders->GDDM, pTdxOrder->GDDM);
strcpy(pWTOrders->WTBH, pTdxOrder->WTBH);
strcpy(pWTOrders->JYSDM, pTdxOrder->ZHLB_);
pWTOrders->Client = m_pClient;
m_pApi->m_id_api_order.insert(pair<string, WTLB_STRUCT*>(pOrder->LocalID, pWTOrders));
// 处理错误
if (pRespone->pErr)
{
pOrder->RawErrorID = pRespone->pErr->ErrCode;
strcpy(pOrder->Text, pRespone->pErr->ErrInfo);
}
// 处理结果
if (pRespone->ppResults&&pRespone->ppResults[0 * COL_EACH_ROW + 0])
{
// 写上柜台的ID，以后将基于此进行定位
strcpy(pOrder->OrderID, pRespone->ppResults[0 * COL_EACH_ROW + 0]);//订单号
strcpy(pWTOrders->WTBH, pOrder->OrderID);
CreateID(pOrder->ID, nullptr, pTdxOrder->GDDM, pOrder->OrderID);
m_pApi->m_id_api_order.erase(pOrder->LocalID);
m_pApi->m_id_api_order.insert(pair<string, WTLB_STRUCT*>(pOrder->ID, pWTOrders));
m_pApi->m_id_platform_order.erase(pOrder->LocalID);
m_pApi->m_id_platform_order.insert(pair<string, OrderField*>(pOrder->ID, pOrder));
// 有挂单的，需要进行查询了
double _queryTime = QUERY_TIME_MIN;
m_QueryOrderTime = time(nullptr) + _queryTime;
OutputQueryTime(m_QueryOrderTime, _queryTime, "NextQueryOrder_Send");
}
// 现在有两个结构体，需要进行操作了
// 1.通知下单的结果
// 2.记录下单
OrderField* pField = pOrder;
if (pField->RawErrorID != 0)
{
pField->ExecType = ExecType::ExecType_Rejected;
pField->Status = OrderStatus::OrderStatus_Rejected;
}
else
{
pField->ExecType = ExecType::ExecType_New;
pField->Status = OrderStatus::OrderStatus_New;
}
m_msgQueue->Input_Copy(ResponeType::ResponeType_OnRtnOrder, m_msgQueue, m_pClass, 0, 0, pField, sizeof(OrderField), nullptr, 0, nullptr, 0);
return 0;
}
int CSingleUser::OnRespone_ReqOrderAction(CTdxApi* pApi, RequestRespone_STRUCT* pRespone)
{
WTLB_STRUCT* pTdxOrder = (WTLB_STRUCT*)pRespone->pContent;
OrderField* pOrder = (OrderField*)pRespone->pUserData_Public2;
if (pRespone->pErr)
{
pOrder->RawErrorID = pRespone->pErr->ErrCode;
strcpy(pOrder->Text, pRespone->pErr->ErrInfo);
pOrder->ExecType = ExecType::ExecType_CancelReject;
// 注意报单状态问题，交给报单查询来处理
}
else
{
double _queryTime = QUERY_TIME_MIN;
m_QueryOrderTime = time(nullptr) + _queryTime;
OutputQueryTime(m_QueryOrderTime, _queryTime, "NextQueryOrder_Cancel");
// 会不会出现撤单时，当时不知道是否成功撤单，查询才得知没有撤成功？
//ppOrders[i]->ExecType = ExecType::ExecCancelled;
//ppOrders[i]->Status = OrderStatus::Cancelled;
}
m_msgQueue->Input_Copy(ResponeType::ResponeType_OnRtnOrder, m_msgQueue, m_pClass, 0, 0, pOrder, sizeof(OrderField), nullptr, 0, nullptr, 0);
return 0;
} | [
"[email protected]"
] | |
0f1b5108f93574bc60f0f47a1d90719846f9df81 | 5acf251ef1b0b3fc7e6da3de4b336c8a5b71a2ee | /bag_stack/stackbag.h | efd412242a85a277ab8b1c6095446c82fe86b8fb | [] | no_license | frankyyyt/DataStructure-Algorithm | 0c023cfffe6a089a15a2f5101a04fad6f02a4db3 | af4b2e3c3f36f1fcea33ce3f09c11cdbcd1e008c | refs/heads/master | 2021-01-25T09:26:28.490390 | 2016-09-19T13:08:49 | 2016-09-19T13:08:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,318 | h | #ifndef _STACKBAG_H
#define _STACKBAG_H
#include<iostream>
#include<map>
class stone{
public:
int volume;
int value;
stone(){};
void setparams(int vo,int va){volume=vo;value=va;};
};
class mystack{
private:
std::map<int,int> valuesmap;
enum{max=20};
stone items[max];
int numofsolution;
int t;
int top;
public:
mystack(int T):top(0){t=T;numofsolution=0;};
bool isempty() const{return top==0;};
bool isfull() const{return top==max;};
bool pop(stone&);
bool push(stone);
void solution(stone* a,int n);
int sum();
void clearstack() {top=0;};
void print();
void bestsolution();
};
int mystack::sum()
{
int s=0,n=top;
while(n--) s+=items[n].volume;
return s;
}
bool mystack::pop(stone& it)
{
if(!isempty())
{
it=items[--top];
return true;
}
std::cout<<"stack is full\n";
return false;
}
bool mystack::push(stone it)
{
if(!isfull())
{
items[top++]=it;
return true;
}
return false;
}
void mystack::print()
{
int allvalue=0;
std::cout<<"get an answer:";
for(int i=0;i<top;i++)
{
std::cout<<items[i].volume<<" ";
allvalue+=items[i].value;
}
std::cout<<std::endl<<"sum of the value is:"<<allvalue<<std::endl;
numofsolution++;
valuesmap.insert(std::pair<int,int>(allvalue,numofsolution));
}
void mystack::solution(stone* b,int n)
{
stone it;
int j;
for(int i=0;i<n;i++)
{
push(b[i]);
j=i+1;
while(top<n+1&&top>0)
{
if(j<n)
{
if(sum()+b[j].volume<t) push(b[j]);
else if(sum()+b[j].volume==t)
{
push(b[j]);
print();
pop(it);
}
j++;
}
else
{
pop(it);
for(j=i+1;j<n;j++)
{
if(b[j].value!=it.value||b[j].volume!=it.volume)
{
j++;
}
else break;
}
j++;
}
}
clearstack();
}
}
void mystack::bestsolution()
{
std::cout<<"the best solution is number "<<valuesmap.rbegin()->second<<"\nthe max value is:"<<valuesmap.rbegin()->first;
}
#endif // _STACKBAG_H
| [
"[email protected]"
] | |
adccdb0345eb1ce119ef170f8c328d96099b6920 | 1d9df1156e49f768ed2633641075f4c307d24ad2 | /third_party/WebKit/Source/core/events/EventUtil.cpp | 1b2df29ed6f5ab0a61a8d09a70e119c14165fa1e | [
"LGPL-2.0-or-later",
"LicenseRef-scancode-warranty-disclaimer",
"LGPL-2.1-only",
"GPL-1.0-or-later",
"GPL-2.0-only",
"LGPL-2.0-only",
"BSD-2-Clause",
"LicenseRef-scancode-other-copyleft",
"MIT",
"Apache-2.0",
"BSD-3-Clause"
] | permissive | GSIL-Monitor/platform.framework.web.chromium-efl | 8056d94301c67a8524f6106482087fd683c889ce | e156100b0c5cfc84c19de612dbdb0987cddf8867 | refs/heads/master | 2022-10-26T00:23:44.061873 | 2018-10-30T03:41:51 | 2018-10-30T03:41:51 | 161,171,104 | 0 | 1 | BSD-3-Clause | 2022-10-20T23:50:20 | 2018-12-10T12:24:06 | C++ | UTF-8 | C++ | false | false | 1,385 | cpp | // Copyright 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "core/events/EventUtil.h"
#include "core/EventTypeNames.h"
namespace blink {
namespace EventUtil {
bool IsPointerEventType(const AtomicString& event_type) {
return event_type == EventTypeNames::gotpointercapture ||
event_type == EventTypeNames::lostpointercapture ||
event_type == EventTypeNames::pointercancel ||
event_type == EventTypeNames::pointerdown ||
event_type == EventTypeNames::pointerenter ||
event_type == EventTypeNames::pointerleave ||
event_type == EventTypeNames::pointermove ||
event_type == EventTypeNames::pointerout ||
event_type == EventTypeNames::pointerover ||
event_type == EventTypeNames::pointerup;
}
bool IsDOMMutationEventType(const AtomicString& event_type) {
return event_type == EventTypeNames::DOMCharacterDataModified ||
event_type == EventTypeNames::DOMNodeInserted ||
event_type == EventTypeNames::DOMNodeInsertedIntoDocument ||
event_type == EventTypeNames::DOMNodeRemoved ||
event_type == EventTypeNames::DOMNodeRemovedFromDocument ||
event_type == EventTypeNames::DOMSubtreeModified;
}
} // namespace eventUtil
} // namespace blink
| [
"RetZero@desktop"
] | RetZero@desktop |
ff11a84b93405ff846d90d688fda55e9c9a84a34 | 5e20a9e14bab17c972cf2bef18edd1c795d1f14c | /tetra.cpp | 83a15ca96d74c51aba4a5a29da0797886b087185 | [
"MIT"
] | permissive | JorenB/3d-cdt | 7a1c7f0453f355a3403a26792b7cc829cd3a59e6 | 4c8fd2292840fde9a9e31e1986d152b19e80bf75 | refs/heads/main | 2023-04-09T12:55:40.987634 | 2023-03-01T08:49:51 | 2023-03-01T08:49:51 | 335,322,729 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 92 | cpp | // Copyright 2021 Joren Brunekreef, Daniel Nemeth and Andrzej Görlich
#include "tetra.hpp"
| [
"[email protected]"
] | |
28d2d79a0882ce3c588a70c1125614f42ee70438 | 4d4e21a5d850560049ca638b0224a6a483d5b9cd | /C++/405_Submatrix Sum.cpp | c73bf05fcee01a7dd03c9b505c7811ceb939ff49 | [] | no_license | gky2009514/lintcode | 08fec3baa5b3cb9547d72fc78d16fea348fa55a5 | 050bbb80de079a923d4435e84964d7022196f642 | refs/heads/master | 2020-05-17T21:45:52.468525 | 2015-09-07T03:09:56 | 2015-09-07T03:09:56 | 35,482,338 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,547 | cpp | class Solution {
public:
/**
* @param matrix an integer matrix
* @return the coordinate of the left-up and right-down number
*/
vector<vector<int>> submatrixSum(vector<vector<int>>& matrix) {
if (matrix.size() == 0 || matrix[0].size() == 0)
return vector<vector<int> >();
int n = static_cast<int>(matrix.size());
int m = static_cast<int>(matrix[0].size());
vector<vector<int> >sum(n + 1, vector<int>(m + 1, 0));
for (int i = 1; i <= n; i++) {
for (int j = 1; j <= m; j++)
sum[i][j] = sum[i][j - 1] + sum[i - 1][j] -
sum[i - 1][j - 1] + matrix[i - 1][j - 1];
}
vector<vector<int> > res;
map<int, int> mp;
for (int i = 1; i <= n; i++) {
for (int j = i; j <= n; j++) {
mp.clear();
for (int k = 1; k <= m; k++) {
int s = sum[j][k] - sum[i - 1][k];
if (s == 0) {
res.push_back({i - 1, 0});
res.push_back({j - 1, k - 1});
return res;
}
if (mp.find(s) != mp.end()) {
res.push_back({i - 1, mp[s]});
res.push_back({j - 1, k - 1});
return res;
}
mp[s] = k;
}
}
}
res.push_back({0, 0});
res.push_back({0, 0});
return res;
}
}; | [
"[email protected]"
] | |
d8d129b63c76e62cd403914e16f662e584130b7f | 2f10f807d3307b83293a521da600c02623cdda82 | /deps/boost/win/debug/include/boost/range/algorithm_ext/erase.hpp | 21811038d9cd1ff2f10c423f95490c003bfeb77c | [] | no_license | xpierrohk/dpt-rp1-cpp | 2ca4e377628363c3e9d41f88c8cbccc0fc2f1a1e | 643d053983fce3e6b099e2d3c9ab8387d0ea5a75 | refs/heads/master | 2021-05-23T08:19:48.823198 | 2019-07-26T17:35:28 | 2019-07-26T17:35:28 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 129 | hpp | version https://git-lfs.github.com/spec/v1
oid sha256:17f8c8f30dbeb53d93e5033251d46df4cff0ae95b80e228af445164454188a64
size 1754
| [
"[email protected]"
] | |
6355f99e5235270a55fd87d97201a12038f5bb94 | 9c44e8b58f7296a9fdda460042603d7700dd6640 | /NetRep/Source/NetRep/NetRepGameMode.h | 94800598e10fbf57c69f23aff2704755ec5f7acb | [] | no_license | IsakWong/real-time-replication | 0321144199f72b1f2a429d225430aa486d2d7d4d | 29c977603c077ff834bc3a1787761dd9434a984e | refs/heads/master | 2020-04-29T22:13:59.722658 | 2019-04-01T14:26:19 | 2019-04-01T14:26:19 | 176,439,571 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 299 | h | // Copyright 1998-2018 Epic Games, Inc. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/GameModeBase.h"
#include "NetRepGameMode.generated.h"
UCLASS(minimalapi)
class ANetRepGameMode : public AGameModeBase
{
GENERATED_BODY()
public:
ANetRepGameMode();
};
| [
"[email protected]"
] | |
c7e25ba1f879e40c3bd7c83445c6cdea5007cc3c | 6c8e69b8efc43db893a1e546ddddb830938212ee | /infrastructure/timerecords.cpp | 9ce4f808abdae791f9bb4532b9eb3923b4f6d029 | [] | no_license | Zhongkangfa/time_statistics | f39e54e6d2c9e944431011cdb9a829bd7a724c5c | f34b8bbd2493ee97cd7e191a63c8de4a8e7cddde | refs/heads/master | 2023-04-15T07:54:58.477319 | 2021-04-23T12:30:03 | 2021-04-23T12:30:03 | 358,810,126 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 58 | cpp | #include "timerecords.h"
TimeRecords::TimeRecords()
{
}
| [
"[email protected]"
] | |
b2d0cef7142276848e997ed17dad2fb08fcb5563 | b2ac2cc956c5b7dc8a38e7a44364d0282241ed8e | /tags/release-0.9.6/Sources/MFindAndOpenDialog.cpp | ca26020d12d56faff017aa2e47841dec26cd1231 | [] | no_license | BackupTheBerlios/japi-svn | b2a9971644a4740d10aef614e09f3fdd49e8460d | f9a5b284e285442b485ef05824ed8e55499c8d61 | refs/heads/master | 2016-09-15T17:14:35.504291 | 2010-12-03T11:39:25 | 2010-12-03T11:39:25 | 40,801,061 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,144 | cpp | /*
Copyright (c) 2006, Maarten L. Hekkelman
All rights reserved.
Redistribution and use in source and binary forms, with or without
modification, are permitted provided that the following conditions
are met:
* Redistributions of source code must retain the above copyright
notice, this list of conditions and the following disclaimer.
* Redistributions in binary form must reproduce the above copyright
notice, this list of conditions and the following disclaimer in
the documentation and/or other materials provided with the
distribution.
* Neither the name of the Maarten L. Hekkelman nor the names of its
contributors may be used to endorse or promote products derived
from this software without specific prior written permission.
THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
"AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
(INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR
SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT,
STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED
OF THE POSSIBILITY OF SUCH DAMAGE.
*/
/* $Id: MFindAndOpenDialog.cpp 158 2007-05-28 10:08:18Z maarten $
Copyright Maarten L. Hekkelman
Created Sunday August 15 2004 20:47:19
*/
#include "MJapi.h"
#include "MFindAndOpenDialog.h"
#include "MTextController.h"
#include "MProjectWindow.h"
#include "MProject.h"
#include "MPreferences.h"
#include "MView.h"
#include "MUnicode.h"
#include "MUtils.h"
#include "MUrl.h"
#include "MSound.h"
#include "MJapiApp.h"
using namespace std;
namespace {
enum {
kTextBoxControlID = 'edit'
};
}
MFindAndOpenDialog::MFindAndOpenDialog(
MTextController* inController,
MWindow* inWindow)
: MDialog("find-and-open-dialog")
, mController(inController)
, mProject(nil)
{
SetText(kTextBoxControlID,
Preferences::GetString("last open include", ""));
Show(inWindow);
SetFocus(kTextBoxControlID);
}
MFindAndOpenDialog::MFindAndOpenDialog(
MProject* inProject,
MWindow* inWindow)
: MDialog("find-and-open-dialog")
, mController(nil)
, mProject(inProject)
{
SetText(kTextBoxControlID,
Preferences::GetString("last open include", ""));
Show(inWindow);
SetFocus(kTextBoxControlID);
}
bool MFindAndOpenDialog::OKClicked()
{
string s;
GetText(kTextBoxControlID, s);
Preferences::SetString("last open include", s);
if (mController != nil)
{
if (not mController->OpenInclude(s))
PlaySound("warning");
}
else
{
MProject* project = mProject;
if (project == nil)
project = MProject::Instance();
fs::path p(s);
if (exists(p) or (project != nil and project->LocateFile(s, true, p)))
gApp->OpenOneDocument(MUrl(p));
}
return true;
}
| [
"hekkel@6969af58-1542-49b8-b3af-dcaebf5f4018"
] | hekkel@6969af58-1542-49b8-b3af-dcaebf5f4018 |
8483baed97b00ec0e59f56d83d8bcfe4423fe7f6 | 88af5d632057a5aa03fa968eee7c5848f0c36f0b | /Console/InsertEx1.h | fa2179d71bef4404328cfb3ffd470b6ef95a5125 | [] | no_license | pawelak/CPPAll | a75b4ad47b8e66c1d9675bf03c4c06a76c188976 | 5b51458af4b456b0d2d3329054f2751c56204470 | refs/heads/master | 2021-04-12T04:26:09.926368 | 2018-04-11T19:29:48 | 2018-04-11T19:29:48 | 125,902,878 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 110 | h | #pragma once
class InsertEx1
{
public:
InsertEx1();
~InsertEx1();
int solution(int M, int A[], int N);
};
| [
"[email protected]"
] | |
b8ba35e6b8008e2c8702348368c75ceec208177a | 2c8c76c3ad0d39e901cb7264d5738102de44047e | /Test/Common/TestMain.cpp | 945f808887eeef9a07142c86a26901d01cac277e | [
"MIT"
] | permissive | jjzhang166/CodeCoop | 87d4404f2dab5676915f0a72fc82869199b306c9 | 7d29f53ccf65b0d29ea7d6781a74507b52c08d0d | refs/heads/master | 2023-07-11T07:01:22.342089 | 2018-03-01T15:24:01 | 2018-03-01T15:24:01 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 743 | cpp | //-------------------------------------------------
// (c) Reliable Software 2003
//-------------------------------------------------
#include "precompiled.h"
#include "TestController.h"
#include <Win/WinMain.h>
#include <Win/WinClass.h>
#include <Win/WinMaker.h>
#include <Win/MsgLoop.h>
#include <Ex/WinEx.h>
#include <Dbg/Memory.h>
int Win::Main (Win::Instance hInst, char const * cmdParam, int cmdShow)
{
TheOutput.Init ("Test");
Win::Class::Maker winClass ("testwin", hInst);
winClass.Register ();
Win::TopMaker winMaker ("Test Window", "testwin", hInst);
TestController testCtrl;
Win::Dow::Handle win = winMaker.Create (&testCtrl, "Test App");
win.Show (cmdShow);
Win::MessagePrepro msgPrepro;
msgPrepro.Pump ();
return 0;
} | [
"[email protected]"
] | |
7ccd012e8a61e7119a8d45ba96eae29cfa86edc6 | a2dc62d5cfca4327b038e50aeaa268812b20dde9 | /tracking_person/tracking_person/stdafx.cpp | 333fc46c9a3fcdd6adbe6b9a292ac7c5b9181e7f | [] | no_license | beetecu/people_tracking_cuda_hog_v1 | 062a7cd13f92d68ebb246d80ce6080f48e30e9dd | c3921c01bf43db544a6b6ce859926453b826398c | refs/heads/master | 2016-09-14T04:12:37.371597 | 2016-05-24T16:26:41 | 2016-05-24T16:26:41 | 59,588,813 | 0 | 0 | null | null | null | null | ISO-8859-1 | C++ | false | false | 336 | cpp | // stdafx.cpp: archivo de código fuente que contiene sólo las inclusiones estándar
// tracking_person.pch será el encabezado precompilado
// stdafx.obj contiene la información de tipos precompilada
#include "stdafx.h"
// TODO: mencionar los encabezados adicionales que se necesitan en STDAFX.H
// pero no en este archivo
| [
"[email protected]"
] | |
69a1d1524ded1c128931b433daac71a1f2b87531 | 1af324248fb1b707c876c0b748366be82022d291 | /WebServer.h | 2897374b085c9cc7f6c4fe24c0340950b55cf501 | [] | no_license | Hornwall/network_ir_remote | 0c208ba8bf6a37bc48a95481f0c37c38c1247055 | 4f90f1fdf7bb011bc6052ba29112511bca0d7a04 | refs/heads/main | 2023-06-17T00:41:33.519062 | 2021-07-07T16:35:17 | 2021-07-07T16:35:17 | 383,859,631 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 357 | h | #ifndef WebServer_h
#define WebServer_h
#include "Arduino.h"
#include <ESPAsyncTCP.h>
#include <ESPAsyncWebServer.h>
class WebServer
{
public:
WebServer(int port);
virtual void startServer();
virtual void receivedData(uint16_t length, uint16_t *rawData);
virtual boolean readerActive();
protected:
AsyncWebServer server;
};
#endif
| [
"[email protected]"
] | |
3b960163014791cf05da266293b4e42a20266882 | d071e6156cf23ddee37a612f71d71a650c27fcfe | /contest/c0408/F.cpp | bbfc0087c6f2b24e9c57f017d38c74c6f64865df | [] | no_license | tsstss123/code | 57f1f7d1a1bf68c47712897e2d8945a28e3e9862 | e10795c35aac442345f84a58845ada9544a9c748 | refs/heads/master | 2021-01-24T23:00:08.749712 | 2013-04-30T12:33:24 | 2013-04-30T12:33:24 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 537 | cpp | #include <cstdio>
#include <cstring>
#include <algorithm>
#include <iostream>
#define N 35
using namespace std;
int n;
char str[N];
char result[N];
int main()
{
int ca = 1;
while(~scanf("%d",&n)){
memset(result,'\0',sizeof(result));
for(int i = 0; i < 2 * n - 1; i++){
scanf("%s",str);
for(int i = 0; i <strlen(str);i++){
result[i] ^= str[i];
}
}
printf("Scenario #%d\n",ca++);
printf("%s\n\n",result);
}
}
| [
"[email protected]"
] | |
86ea564cabc68325fa25099572b2338c4bdd21b0 | ad273708d98b1f73b3855cc4317bca2e56456d15 | /aws-cpp-sdk-lakeformation/source/model/GetDataLakeSettingsRequest.cpp | 9a5cabbeb55145fd453a652774ed971a80d83cd1 | [
"MIT",
"Apache-2.0",
"JSON"
] | permissive | novaquark/aws-sdk-cpp | b390f2e29f86f629f9efcf41c4990169b91f4f47 | a0969508545bec9ae2864c9e1e2bb9aff109f90c | refs/heads/master | 2022-08-28T18:28:12.742810 | 2020-05-27T15:46:18 | 2020-05-27T15:46:18 | 267,351,721 | 1 | 0 | Apache-2.0 | 2020-05-27T15:08:16 | 2020-05-27T15:08:15 | null | UTF-8 | C++ | false | false | 1,401 | cpp | /*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#include <aws/lakeformation/model/GetDataLakeSettingsRequest.h>
#include <aws/core/utils/json/JsonSerializer.h>
#include <utility>
using namespace Aws::LakeFormation::Model;
using namespace Aws::Utils::Json;
using namespace Aws::Utils;
GetDataLakeSettingsRequest::GetDataLakeSettingsRequest() :
m_catalogIdHasBeenSet(false)
{
}
Aws::String GetDataLakeSettingsRequest::SerializePayload() const
{
JsonValue payload;
if(m_catalogIdHasBeenSet)
{
payload.WithString("CatalogId", m_catalogId);
}
return payload.View().WriteReadable();
}
Aws::Http::HeaderValueCollection GetDataLakeSettingsRequest::GetRequestSpecificHeaders() const
{
Aws::Http::HeaderValueCollection headers;
headers.insert(Aws::Http::HeaderValuePair("X-Amz-Target", "AWSLakeFormation.GetDataLakeSettings"));
return headers;
}
| [
"[email protected]"
] | |
bc2e01e80dd0987cc96645ca3675dd0115dd7d96 | 9a4dd5d88e8ef0726eb8e7b3897d72b21c18933e | /main.cpp | 47c67703b4acafaead421b42e2a948d12c43bbcf | [] | no_license | marlonsecundo/animals | bd365d03b077af10b9ea96c01ee9b3b9b60d8d00 | 2f6fa14237099fa15a70937a13f70d59b1bd9642 | refs/heads/master | 2020-05-31T09:23:01.523614 | 2019-06-26T02:30:08 | 2019-06-26T02:30:08 | 190,210,435 | 1 | 0 | null | 2019-06-26T02:05:17 | 2019-06-04T13:46:05 | C++ | UTF-8 | C++ | false | false | 343 | cpp |
/**
* @file main.cpp
* @brief Arquivo da classe principal - PetFera.
* @author Davi César, Emanuel Felipe, João Paulo Carneiro, Lucas Vinicius, Marlon Secundo
* @since 28/05/2019
* @date 25/06/2019
* @version 1.0
*/
#include "entrada.h"
int main(int argc, char const *argv[])
{
Entrada entrada;
entrada.iniciar();
return 0;
}
| [
"[email protected]"
] | |
e4af465a32607e3b51c6f663b739ef4705d5ac8f | 0f050f4bd9321a76d0dbda8fce5ae678796027b8 | /src/editor/private/graph/interfaces/QNodePinValue.h | 9404037c1483bb4968e0550b58e3a6bee4ba8c94 | [
"MIT"
] | permissive | Dandielo/mooned-editor | 0c215fc3a2d1d24edaf8eedf11a0211c574d6772 | 72f9068e3d6daaf42c1bc4be23dce2c5a260a6e8 | refs/heads/master | 2021-05-06T14:23:11.056001 | 2019-01-21T23:15:09 | 2019-01-21T23:15:09 | 113,358,088 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 852 | h | #pragma once
#include <QGraphicsObject>
namespace editor
{
class QGraphicsEditableItem;
class QNodePin;
class QNodePinValue : public QGraphicsItem
{
public:
QNodePinValue();
virtual ~QNodePinValue() override;
virtual void setBoundingRect(QRectF rect) = 0;
virtual QColor color() const = 0;
virtual uint typeId() const = 0;
virtual QVariant value() const = 0;
virtual QVariant resolvedValue() const = 0;
virtual void setValue(QVariant val) = 0;
virtual void beginEdit() = 0;
virtual void endEdit() = 0;
protected:
virtual void mousePressEvent(QGraphicsSceneMouseEvent* ev) override;
virtual void mouseDoubleClickEvent(QGraphicsSceneMouseEvent* ev) override;
protected:
QGraphicsEditableItem* _edit_item;
};
}
| [
"[email protected]"
] | |
f32daf7b49031ecbd9784a4a770aea9133a72bc4 | c5349305b993b78e27e618cbaf9dede40ec2e328 | /cache_dir.cpp | 3f16a21eb13243cbedb60997d6c3fa4c99b97676 | [] | no_license | josefallas0302/Cache_Estructuras | f87bbd0aa531c0bbf32e6394d507647e7334d1bd | 7878f1a61729741320b9993678e70ff2e11f6b8a | refs/heads/master | 2021-01-19T13:41:51.218520 | 2017-05-01T05:40:40 | 2017-05-01T05:40:40 | 88,101,373 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,924 | cpp | #include "cache_dir.h"
Cache_dir::Cache_dir (int blocks) : num_block(blocks){
Block newblock = Block(0, 'i', 0, 0, 'v');
for(int i=0; i<blocks; i++){
c_block.insert( c_block.begin(), newblock);
}
return;
}
//Escribe en el cache, recibe la direccion de memoria y el dato
void Cache_dir :: write_dir (vector <int> binario, int new_data, memory CPU_mem){
int iterator = binario.size(); //Tamano de la direccion en binario
int index = 0;
int parameter1 = 0;
for(int i=iterator-1; i>iterator-13; i--){
index = index + binario[i]*pow(2,parameter1);
parameter1 = parameter1 + 1;
} // Convierte el index de binario a decimal (12 bits para el index)
int tag = 0;
int parameter2 = 0;
for(int i=iterator-13; i>=0; i--){
tag = tag + binario[i]*pow(2,parameter2);
parameter2 = parameter2 + 1;
} //Convierte el tag de binario a decimal (iterator-index = bits de tag)
// Sobreescribe el tag y el dato en el cache
c_block[index].set_tag(tag);
c_block[index].set_data(new_data);
c_block[index].set_valid(1);
CPU_mem.set_dir(binario, new_data);
cout << "" << endl;
cout << " Bloque del cache L2 despues de escritura" << endl;
this->c_block[index].block_info();
cout << "" << endl;
return;
}
//Lee del cache, recibe la direccion de memoria proveniente del cache L1
int Cache_dir :: read_dir(vector <int> binario, memory CPU_mem){
int iterator = binario.size(); //Tamano de la direccion en binario
int index = 0;
int parameter1 = 0;
for(int i=iterator-1; i>iterator-13; i--){
index = index + binario[i]*pow(2,parameter1);
parameter1 = parameter1 + 1;
} // Convierte el index de binario a decimal (12 bits para el index)
int tag = 0;
int parameter2 = 0;
for(int i=iterator-13; i>=0; i--){
tag = tag + binario[i]*pow(2,parameter2);
parameter2 = parameter2 + 1;
} //Convierte el tag de binario a decimal (iterator-index = bits de tag)
//cout << "index: "<< index << "tag: " << tag << endl;
if ( c_block[index].get_tag() == tag && c_block[index].get_valid()== 1){
cout << "hit L2" << endl;
cout << "" << endl;
cout << " Bloque del cache L2 despues de lectura" << endl;
this->c_block[index].block_info();
cout << "" << endl;
return c_block[index].get_data();
}else {
cout << "miss L2" << endl;
int info = CPU_mem.find_dir(binario);
c_block[index].set_tag(tag);
c_block[index].set_data(info);
c_block[index].set_valid(1);
//cout << "dato en L2: " << CPU_mem.find_dir(binario)<< endl;
cout << "" << endl;
cout << " Bloque del cache L2 despues de lectura " << endl;
this->c_block[index].block_info();
cout << "" << endl;
return info;
} // Busca el dato en el cache o en la memoria
}
void Cache_dir :: set_valid_dir(int index, int valid){
c_block[index].set_valid(valid);
}
| [
"[email protected]"
] | |
149601da7c9c270012dc83276acdc191d9979720 | b20e9467942ab7c5cc13dfbaf08e924448569b90 | /TeamPortPolio/TeamPortPolio/Melee_Battle.cpp | a245f92643cb82191751faa97665bdfdacd2af89 | [] | no_license | dlwlgus9125/NTCoffeeTeamPortPolio | 9a5adbd05d43e7b8eb0a7899de29c6697a989057 | cb7a37eebe1b31cb8b3394cc0104605908dc1e4f | refs/heads/master | 2021-01-25T06:56:02.239558 | 2017-06-16T04:30:00 | 2017-06-16T04:30:00 | 93,626,889 | 2 | 0 | null | null | null | null | UHC | C++ | false | false | 4,599 | cpp | #include "stdafx.h"
#include "Melee_State.h"
#include "cLeader.h"
void Melee_Battle::OnBegin(cUnit * pUnit)
{
//FindTarget(pUnit);
pUnit->GetMesh()->SetAnimationIndexBlend(FG_BATTLERUN);
}
void Melee_Battle::OnUpdate(cUnit * pUnit, float deltaTime)
{
if (BattleTarget == NULL)
{
Charge(pUnit);
}
else
{
D3DXVECTOR3 thisPos = pUnit->GetCharacterEntity()->Pos();
D3DXVECTOR3 targetPos = BattleTarget->GetCharacterEntity()->Pos();
float distance = MATH->Distance(thisPos, targetPos);
if (distance > 1.0f)
{
pUnit->GetCharacterEntity()->Steering()->UnitArrive(targetPos);
pUnit->GetCharacterEntity()->Steering()->ConstrainOverlap(OBJECT->GetEntities());
FindNearTarget(pUnit);
if (TIME->UpdateOneSecond())FindTarget(pUnit);
}
else
{
if (((cCharacter*)BattleTarget)->IsDeath() == true)
{
if (pUnit->GetMesh()->GetPassedTime() > pUnit->GetMesh()->GetCurrentAnim()->GetPeriod() - 0.3f)
{
pUnit->GetMesh()->SetAnimationIndexBlend(FG_BATTLEWALK);
}
BattleTarget = NULL;
FindNearTarget(pUnit);
if(TIME->UpdateOneSecond())FindTarget(pUnit);
}
else if (((cCharacter*)BattleTarget)->GetMesh()->GetIndex() != FG_DEATH)
{
BattleWithTarget(pUnit);
}
}
pUnit->GetCharacterEntity()->Steering()->ConstrainOverlap(OBJECT->GetEntities());
}
}
void Melee_Battle::OnEnd(cUnit * pUnit)
{
pUnit->SetTargetObject(NULL);
}
void Melee_Battle::StateChanger(cUnit * pUnit)
{
FG_STATE state;
}
//자신과 충돌한 적을 찾는 함수
void Melee_Battle::FindTarget(cUnit * pUnit)
{
for (int i = 0; i < ((cLeader*)pUnit->GetTargetObject())->GetUnits().size(); i++)
{
if (((cLeader*)pUnit->GetTargetObject())->GetUnits()[i]->IsDeath() == false)
{
if (MATH->IsCollided(((cLeader*)pUnit->GetTargetObject())->GetUnits()[i]->GetArrangeSphere(), pUnit->GetArrangeSphere()))
{
BattleTarget = ((cLeader*)pUnit->GetTargetObject())->GetUnits()[i];
}
}
}
}
//자신과 제일 가까운 적을 찾는 함수
void Melee_Battle::FindNearTarget(cUnit * pUnit)
{
if (TIME->UpdateOneSecond())
{
D3DXVECTOR3 nextTargetPos, prevTargetPos;
D3DXVECTOR3 pos = pUnit->GetCharacterEntity()->Pos();
for (int i = 1; i < ((cLeader*)pUnit->GetTargetObject())->GetUnits().size(); i++)
{
if (((cLeader*)pUnit->GetTargetObject())->GetUnits()[i]->IsDeath() == false)
{
prevTargetPos = ((cLeader*)pUnit->GetTargetObject())->GetUnits()[i - 1]->GetCharacterEntity()->Pos();
nextTargetPos = ((cLeader*)pUnit->GetTargetObject())->GetUnits()[i]->GetCharacterEntity()->Pos();
if (MATH->Distance(pos, prevTargetPos) > MATH->Distance(pos, nextTargetPos))
{
BattleTarget = ((cLeader*)pUnit->GetTargetObject())->GetUnits()[i];
}
else
{
BattleTarget = ((cLeader*)pUnit->GetTargetObject())->GetUnits()[i - 1];
}
}
}
}
}
void Melee_Battle::Charge(cUnit * pUnit)
{
D3DXVECTOR3 worldOffset = MATH->LocalToWorld(D3DXVECTOR3((pUnit->GetOffset().x + (pUnit->GetOffset().z*0.5F)), 0, 0), pUnit->GetLeader()->Forward());
D3DXVECTOR3 thisPos = pUnit->GetCharacterEntity()->Pos();
D3DXVECTOR3 targetPos = worldOffset + pUnit->GetTargetObject()->GetCharacterEntity()->Pos() - (pUnit->GetLeader()->Forward());
float distance = MATH->Distance(thisPos, targetPos);
if (distance > 1.0f)
{
pUnit->GetCharacterEntity()->Steering()->UnitArrive(targetPos);
pUnit->GetCharacterEntity()->Steering()->ConstrainOverlap(OBJECT->GetEntities());
FindTarget(pUnit);
}
else
{
FindNearTarget(pUnit);
}
}
void Melee_Battle::Battle(cUnit * pUnit)
{
}
void Melee_Battle::BattleWithTarget(cUnit * pUnit)
{
if (pUnit->GetMesh()->GetPassedTime() > pUnit->GetMesh()->GetCurrentAnim()->GetPeriod() - 0.3f)
{
D3DXVECTOR3 dir = BattleTarget->GetCharacterEntity()->Pos() - pUnit->GetCharacterEntity()->Pos();
D3DXVec3Normalize(&dir, &dir);
pUnit->GetCharacterEntity()->SetForward(dir);
switch (pUnit->GetMesh()->GetIndex())
{
case FG_ATTACK1:
pUnit->GetMesh()->SetAnimationIndexBlend(FG_ATTACK2);
break;
default:
pUnit->GetMesh()->SetAnimationIndexBlend(FG_ATTACK1);
break;
}
if (MATH->IsCollided(pUnit->GetAttackCollider(), ((cCharacter*)BattleTarget)->GetSphere()))
{
switch (pUnit->Fight(pUnit, (cCharacter*)BattleTarget))
{
case FIGHT_AVOID:((cCharacter*)BattleTarget)->GetMesh()->SetAnimationIndexBlend(FG_SHEILDBLOCK); break;
case FIGHT_BLOCK:((cCharacter*)BattleTarget)->GetMesh()->SetAnimationIndexBlend(FG_SHEILDBLOCK); break;
case FIGHT_HIT:((cCharacter*)BattleTarget)->GetMesh()->SetAnimationIndexBlend(FG_HIT); break;
}
}
}
}
| [
"[email protected]"
] | |
d331ba4914390e2aef5ef5296e12aa0f20324dbf | 71a6f81e6480d26b9d83255883e023f10fb47e7d | /server/Client.hh | 6709c14d0302a4bce9bf6184f6c61bfd36180bd5 | [] | no_license | athomaj/Babel | 98983d141581fecd297495f3d60c16ba1a9fe098 | 92145f73094b8e3b6fda7f3b02358fef594621c9 | refs/heads/master | 2021-01-10T14:00:51.270528 | 2016-01-22T20:49:56 | 2016-01-22T20:49:56 | 50,014,950 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 767 | hh | #ifndef CLIENT_HH_
# define CLIENT_HH_
# include "../Client/Identity.hpp"
# include "Server.hh"
# include "ManageCommand.hh"
class Client
{
public:
Client(int const fd, Server *serv);
~Client();
int getFd() const;
bool receiveData();
void sendData();
void addPacketToSend(Packet *);
Packet *getPacketToSend();
bool isToSendEmpty() const;
void setIp(char const *ip);
void setUsername(char const *ip);
void setPort(int const port);
Server* getServer() const;
std::string &getUsername();
std::string &getIp();
int getPort() const;
private:
int fd;
Server *_serv;
std::string ip;
int port;
std::string username;
ManageCommand comManager;
std::vector<Packet *> toSend;
};
#endif
| [
"[email protected]"
] | |
a3012ee88bae72f752514a8ba2a1d8195eaf5f95 | fcd145b1a12edea260d482583f88311e18b05030 | /Prefix tree/prefix.cpp | a32429a7cf5d1c46d3ab3939d3dd789fd57050ac | [] | no_license | triplemzim/competitive_programming | f7e7cf098b19c3abbf2b3ff6bb6e237122deaaf0 | 3da9560d021b743dd55f5165c0c0bb7e9adbf828 | refs/heads/master | 2021-01-22T23:21:29.082154 | 2017-03-20T22:23:11 | 2017-03-20T22:23:11 | 85,630,988 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,376 | cpp | #include<iostream>
#include<cstdio>
#include<cmath>
#include<cstring>
#include<vector>
#include<map>
#include<queue>
#include<stack>
#include<cstdlib>
#include<algorithm>
#include<set>
#include<iterator>
#define ms(x,val) memset(x,val,sizeof(x))
#define ull unsigned long long
#define iii long long
using namespace std;
struct node
{
public:
bool endmark;
node *next[27];
node()
{
endmark=false;
for(int i=0;i<27;i++) next[i]=NULL;
}
}*root;
void insrt(char str[],int len)
{
node *curr=root;
for(int i=0;i<len;i++)
{
if(curr->next[str[i]-'a']==NULL)
{
curr->next[str[i]-'a']=new node();
}
curr=curr->next[str[i]-'a'];
}
curr->endmark=true;
return ;
}
bool srch(char str[],int len)
{
node *cur=root;
for(int i=0;i<len;i++)
{
int id=str[i]-'a';
if(cur->next[id]==NULL) return false;
else
{
cur=cur->next[id];
}
}
return cur->endmark;
}
int main()
{
return 0;
}
//#define sets(n,pos) (n|(1<<pos))
//#define check(n,pos) (bool(n&(1<<pos)))
//#define mx 100000000
//#define lim 10000
//unsigned prime[mx>>6];
//void seive()
//{
// unsigned k,i,j;
// prime[2>>6]=sets(prime[2>>6],0);
// for(i=3;i<lim;i+=2)
// {
// if(check(prime[i>>6],((i>>1)&31))==0)
// {
// if(i<100) cout<<i<<" ";
// k=i<<1;
// for(j=i*i;j<=mx;j+=k)
// {
// prime[j>>6]=sets(prime[j>>6],((j>>1)&31));
// }
// }
// }
// return;
//}
| [
"Muhim Muktadir Khan"
] | Muhim Muktadir Khan |
bf070adb4d885b174e989b89ac6c3a935be337b7 | 706aede0061ad351eb3393eda17c09c9eb5187c2 | /C++ ASP Lib/DFT.h | 5259f1c3f619c362fe51c44065dff93946d583c4 | [] | no_license | dogjin/Audio-Signal-Processing | 432ede04db30ba6065d3fe87516633c958877e2c | 0d40bbc6f93320a7bb9b1269a4fd824ac1602a2c | refs/heads/master | 2021-05-02T06:52:57.492859 | 2017-10-02T22:49:59 | 2017-10-02T22:49:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 397 | h | /*============================================================
Project: Discrete Fourier Transform
Author: Anthony Reid
============================================================*/
#include <complex>
// define variable
#define PI 3.141695
class DFT
{
public:
DFT(int[]);
DFT(std::complex<int>[]);
std::complex<float>* get_Xk();
protected:
private:
std::complex<float>[] X = NULL;
}
| [
"[email protected]"
] | |
2d5f8cbf3f039b171b9f0ef00ac5aa1c74f53f7a | 40b68364f9637366e4b7816eb172e94965bfb9c3 | /053_ModelInstancing/Framework/Environment/Terrain.h | d8095347863ea68e54bffb1eaef54f024b93b0ee | [] | no_license | utm9705/DirectX_Class | 7009cab8fb581b61bd6f87681ae2b09ab2e700b0 | 37220dbc642ee601541f49ca30fa857ad92d681b | refs/heads/master | 2021-10-25T06:28:04.345435 | 2019-04-02T07:06:50 | 2019-04-02T07:06:50 | 170,453,891 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 480 | h | #pragma once
class Terrain
{
public:
Terrain(Material* material, wstring heightMap);
~Terrain();
void Update();
void Render();
float GetHeight(float positionX, float positionZ);
private:
void CreateData();
void CreateNormalData();
void CreateBuffer();
private:
Shader* shader;
Material* material;
Texture* heightMap;
UINT width, height;
VertexTextureNormal* vertices;
UINT* indices;
UINT vertexCount, indexCount;
ID3D11Buffer* vertexBuffer, *indexBuffer;
}; | [
"[email protected]"
] | |
75094c14a6de9ea5d95c973f886dac9d4e2833a5 | 807c766a846c09547a57df9cd4b2f01b530b6345 | /projects/msvc10/utils/DLL.cpp | 0144346c05b1f9f0ccc3af9e71f741435d8f3343 | [
"BSL-1.0"
] | permissive | PubFork/KTL | 8b11edf83bc3346f1eb26100274ccf9a1579cab2 | 8314bf574f48e78ed90c10cdb34c5dd5e95a0211 | refs/heads/master | 2021-05-30T22:03:05.578003 | 2015-09-06T13:29:59 | 2015-09-06T13:29:59 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 488 | cpp | /*=============================================================================
Copyright (c) 2010-2015 Bolero MURAKAMI
https://github.com/bolero-MURAKAMI/KTL
Distributed under the Boost Software License, Version 1.0. (See accompanying
file LICENSE_1_0.txt or copy at http://www.boost.org/LICENSE_1_0.txt)
=============================================================================*/
#include "../../../src/utils/Config.hpp"
#include "ktl_rc_version.h"
#include <ktl/dll.hpp>
| [
"[email protected]"
] | |
81490138639489f9bcc71a45444601c7d0b32378 | 7452457bf715cf50f251d086c5c9bfe0821b1538 | /include/Furrovine++/Vendor/fbxsdk/scene/shading/fbxproceduraltexture.h | d753b896b60d7fbb0d82727f2909fc6082faef43 | [
"MIT"
] | permissive | bananu7/Furropen | 3d91c49b5b833f5f269cf5516a8f8c7cf1385cdc | 968351c1268d8994116cd8312f067dd2cacdbf5b | refs/heads/master | 2021-01-10T20:44:17.606000 | 2014-02-13T22:28:09 | 2014-02-13T22:28:09 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,588 | h | /****************************************************************************************
Copyright (C) 2013 Autodesk, Inc.
All rights reserved.
Use of this software is subject to the terms of the Autodesk license agreement
provided at the time of installation or download, or which otherwise accompanies
this software in either electronic or hard copy form.
****************************************************************************************/
//! \file fbxproceduraltexture.h
#ifndef _FBXSDK_SCENE_SHADING_TEXTURE_PROCEDURAL_H_
#define _FBXSDK_SCENE_SHADING_TEXTURE_PROCEDURAL_H_
#include <fbxsdk/fbxsdk_def.h>
#include <fbxsdk/scene/shading/fbxtexture.h>
#include <fbxsdk/fbxsdk_nsbegin.h>
/** Contains the information to generate a texture procedurally. Data information for the texture
* generation is contained in a blob property.
* \see FbxTexture
* \nosubgrouping
*/
class FBXSDK_DLL FbxProceduralTexture : public FbxTexture
{
FBXSDK_OBJECT_DECLARE(FbxProceduralTexture, FbxTexture);
public:
/**
* \name Procedural Texture Properties
*/
//@{
/** This property handles the raw data for generating procedural texture.
*/
FbxPropertyT<FbxBlob> BlobProp;
/** Resets the default procedural texture values.
*/
void Reset();
//@}
/**
* \name Property Access Methods
*/
//@{
/** Sets the blob.
* \param pBlob Blob containing information for the procedural texture
*/
void SetBlob(FbxBlob& pBlob);
/** Get the blob.
* \return Blob containing information for the procedural texture
*/
FbxBlob GetBlob() const;
//@}
/*****************************************************************************************************************************
** WARNING! Anything beyond these lines is for internal use, may not be documented and is subject to change without notice! **
*****************************************************************************************************************************/
#ifndef DOXYGEN_SHOULD_SKIP_THIS
virtual FbxObject& Copy(const FbxObject& pObject);
bool operator==(FbxProceduralTexture const& pTexture) const;
protected:
virtual void Construct(const FbxProceduralTexture* pFrom);
virtual void ConstructProperties(bool pForceSet);
void Init();
#endif /* !DOXYGEN_SHOULD_SKIP_THIS *****************************************************************************************/
};
#include <fbxsdk/fbxsdk_nsend.h>
#endif /* _FBXSDK_SCENE_SHADING_TEXTURE_PROCEDURAL_H_ */
| [
"[email protected]"
] | |
ea54bb84e3e11cb93a3d34e0e71b375c906a24a7 | 5ea33d3e72fb94d9b27404973aabbad0274f0d08 | /oactobjs/LawChangeAGE65COMP.h | f15c9b2fa668fe883ed9ebfeea2a9eeff46db992 | [
"LicenseRef-scancode-warranty-disclaimer",
"LicenseRef-scancode-public-domain"
] | permissive | bslabs/anypiamac | d99538ea35732dc6804a4f1d231d6034bb8f68c1 | 199a118e4feffbafde2007c326d9b1c774e9c4ff | refs/heads/master | 2021-06-24T08:21:34.583844 | 2020-11-21T07:37:01 | 2020-11-21T07:37:01 | 36,282,920 | 5 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,611 | h | // Declarations for the <see cref="LawChangeAGE65COMP"/> class to manage
// parameters for a proposal to increase the number of elapsed years in a pia
// calculation.
//
// $Id: LawChangeAGE65COMP.h 1.6 2011/07/29 16:27:32EDT 044579 Development $
#pragma once
#include "LawChange.h"
/// <summary>Parameters for a proposal to increase the number of elapsed
/// years in a pia calculation.</summary>
///
/// <remarks>There is one additional data field compared to the base class.
///
/// If the indicator is greater than zero, its value of n is the number of
/// years of increase in the elapsed years, so that the computation period is
/// measured to age 62 + n. The change is phased in over a period of years
/// according to the step size. (The computation increases by 1 year every
/// step years.)</remarks>
class LawChangeAGE65COMP : public LawChange
{
private:
/// <summary>Step size for increase in number of computation years.
/// </summary>
int step;
public:
LawChangeAGE65COMP();
/// <summary>Returns step size when increasing computation period.</summary>
///
/// <returns>Step size when increasing computation period.</returns>
int getStep() const { return step; }
void prepareStrings( std::vector< std::string >& outputString );
void read( std::istream& infile );
/// <summary>Sets step size when increasing computation period.</summary>
///
/// <param name="newStep">New step size when increasing computation period.
/// </param>
void setStep( int newStep ) { step = newStep; }
void write( std::ostream& out ) const;
};
| [
"[email protected]"
] | |
aa312919cb3ddcde378b93a41a81b89625e25956 | 184bcf7925e6718b3021946581576f8cae80526b | /CF/zDiv2/998/B2.cpp | 5ca080e314b579f40bad71919f1590b9aefba870 | [] | no_license | iPhreetom/ACM | a99be74de61df37c427ffb685b375febad74ed9a | f3e639172be326846fe1f70437dcf98c90241aa0 | refs/heads/master | 2021-06-14T08:11:24.003465 | 2019-09-13T22:54:34 | 2019-09-13T22:54:34 | 142,748,718 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 620 | cpp | #include<bits/stdc++.h>
using namespace std;
typedef long long ll;
priority_queue<ll,vector<ll>,greater<ll> > que;
ll a[105];
ll even,odd;
int main(){
ios::sync_with_stdio(false),cin.tie(0),cout.tie(0);
ll n,b;
cin>>n>>b;
for(int i=0;i<n;i++){
cin>>a[i];
}
for(int i=0;i<n;i++){
if(a[i]%2==1)odd++;
else even++;
if(odd==even && i!=n-1){
que.push(abs(a[i+1]-a[i]));
}
}
ll ans = 0;
while(!que.empty()){
if(b >= que.top()){
ans++;
// cout<<que.top()<<endl;
b-=que.top();
que.pop();
}
else{
// cout<<ans<<endl;
// return 0;
break;
}
}
cout<<ans<<endl;
return 0;
}
| [
"[email protected]"
] | |
d2d9c643a88c0dbe89b531749147fc59f19efd11 | 0eb55f3b59a9ae718c49ccf404c593f213b085e9 | /Cora/sys/dsp_crc.h | 445ef3863f4cea8a4f2081ca21e6f5ed30c3395e | [] | no_license | wwwgitcom/CORA | 048133af0659c12aa1290a8098074f27ad4f094a | 089629cadc574bb167e042c598c0ae16cad034dd | refs/heads/master | 2021-01-01T05:33:30.499104 | 2013-07-09T14:05:10 | 2013-07-09T14:05:10 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,156 | h | #pragma once
namespace crc
{
//////////////////////////////////////////////////////////////////////////
//unsigned char testinput[] = {0x8f, 0x64, 0x00, 0x07, 0x00};
// total 34 bits for 802.11n test, crc=0x15
struct crc8
{
static const int lut_size = 256;
static const unsigned char poly = 0xE0;
unsigned __int8 _crc_register;
crc8() : _crc_register(0xFF){}
void reset(){_crc_register = 0xFF;}
__forceinline void operator()(unsigned __int8 &ubInput)
{
_crc_register = lookup_table[ubInput ^ _crc_register];
}
__forceinline unsigned __int8 value(){ return ~ _crc_register; }
__forceinline unsigned __int8 operator()(unsigned __int8 *pubInput, int nInputBytes)
{
int i = 0;
for ( ; i < nInputBytes; i += 4)
{
this->operator()(pubInput[i + 0]);
this->operator()(pubInput[i + 1]);
this->operator()(pubInput[i + 2]);
this->operator()(pubInput[i + 3]);
}
for (int j = 0; j < (nInputBytes & 0x3); j++)
{
this->operator()(pubInput[i + j]);
}
return this->value();
}
__forceinline void operator()(unsigned __int8 ubInput, int nBits)
{
_crc_register ^= ubInput;
for(int i = 0; i< nBits; i++)
{
if(_crc_register & 1 )
_crc_register = (_crc_register >> 1) ^ poly;
else
_crc_register >>= 1;
}
}
private:
static const unsigned __int8 lookup_table[lut_size];
unsigned char calc(unsigned char *pInput, int nInput)
{
unsigned char tempcrc=0xFF;
unsigned char genPoly = 0xE0;
for (int j = 0; j < nInput; j++)
{
unsigned char c = pInput[j];
tempcrc ^= c;
// the for-loop can be optimized by lookup table
for(int i = 0; i<8; i++)
{
if(tempcrc & 1 )
tempcrc = (tempcrc >> 1) ^ genPoly;
else
tempcrc >>= 1;
}
tempcrc &= 0xff;
}
return ~tempcrc;
}
};
//////////////////////////////////////////////////////////////////////////
struct crc16
{
static const int lut_size = 256;
unsigned __int16 _crc_register;
crc16() : _crc_register(0xFFFF){}
__forceinline void operator()(unsigned __int8 &ubInput)
{
_crc_register = ((_crc_register >> 8) & 0x00FF) ^ lookup_table[(_crc_register & 0x00FF) ^ (ubInput & 0x00FF)];;
}
__forceinline unsigned __int16 value(){ return ~ _crc_register; }
__forceinline unsigned __int16 operator()(unsigned __int8 *pubInput, int nInputBytes)
{
int i = 0;
for ( ; i < nInputBytes; i += 4)
{
this->operator()(pubInput[i + 0]);
this->operator()(pubInput[i + 1]);
this->operator()(pubInput[i + 2]);
this->operator()(pubInput[i + 3]);
}
for (int j = 0; j < (nInputBytes & 0x3); j++)
{
this->operator()(pubInput[i + j]);
}
return this->value();
}
private:
static const unsigned __int16 lookup_table[lut_size];
};
//////////////////////////////////////////////////////////////////////////
struct crc32
{
static const int lut_size = 256;
unsigned __int32 _crc_register;
crc32() : _crc_register(0xFFFFFFFF){}
__forceinline void reset(){_crc_register = 0xFFFFFFFF;}
__forceinline unsigned __int32 value(){ return ~ _crc_register; }
__forceinline void operator()(unsigned __int8 &ubInput)
{
_crc_register = ((_crc_register ) >> 8 ) ^ lookup_table[ubInput ^ (_crc_register & 0x000000FF )];
}
__forceinline unsigned __int32 operator()(unsigned __int8 *pubInput, int nInputBytes)
{
int i = 0;
for ( ; i < nInputBytes; i += 4)
{
this->operator()(pubInput[i + 0]);
this->operator()(pubInput[i + 1]);
this->operator()(pubInput[i + 2]);
this->operator()(pubInput[i + 3]);
}
for (int j = 0; j < (nInputBytes & 0x3); j++)
{
this->operator()(pubInput[i + j]);
}
return this->value();
}
private:
static const unsigned __int32 lookup_table[lut_size];
};
} | [
"[email protected]"
] | |
0f5ba423061a0a4cee8dfaaccf8f01d4de21174a | 962da7e6864deef165217c8156b1e2138925223a | /src/clientApp/include/clientApp/darkStyle.h | 40d01f06081d3cb6e2e4712a8ca4565afa7fcbdd | [] | no_license | EchoPixel-Inc/NetworkingPrototype | 06ff6a7e9fea50e490bb0f0a54ef703240a33af1 | 0a13194fd89394380e3c35c79ac33687a664075a | refs/heads/master | 2023-07-27T13:12:17.547918 | 2021-09-07T23:34:14 | 2021-09-07T23:34:14 | 350,517,135 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 443 | h | #ifndef darkStyle_h
#define darkStyle_h
#include <QApplication>
#include <QFile>
#include <QFont>
#include <QProxyStyle>
#include <QStyleFactory>
class DarkStyle : public QProxyStyle {
Q_OBJECT
public:
DarkStyle();
explicit DarkStyle(QStyle* style);
QStyle* baseStyle() const;
void polish(QPalette& palette) override;
void polish(QApplication* app) override;
private:
QStyle* styleBase(QStyle* style = Q_NULLPTR) const;
};
#endif | [
"[email protected]"
] | |
a9f2aa1e1525a07eb2d15977176539095506e011 | 0d4f1eeb722b0e49b00142fa56a047610dc4f670 | /C++/200513/SingleTon_Design/SingleTon_Design/Singleton.cpp | 05d3189adc1545cd6d6d7aeceed4157a18a85593 | [] | no_license | KimWoongwon/2A_TOTAL | 23059d717442f4df257b3eca762afcf024286a6c | 21f58798c5a08ce648ecb75d1e45ff22ab01afa8 | refs/heads/master | 2022-11-24T10:03:01.411097 | 2020-08-04T07:32:09 | 2020-08-04T07:32:09 | 276,353,062 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 421 | cpp | #include "Singleton.h"
Singleton* Singleton::Instance = nullptr;
bool Singleton::InsFlag = false;
Singleton* Singleton::GetInstance()
{
if (Instance == nullptr)
{
cout << "Create Singleton" << endl;
Instance = new Singleton();
InsFlag = true;
}
return Instance;
}
void Singleton::Addvalue(int p_val)
{
cout << "Add Value : " << p_val << endl;
m_val += p_val;
}
int Singleton::GetValue()
{
return m_val;
}
| [
"[email protected]"
] |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.