blob_id stringlengths 40 40 | directory_id stringlengths 40 40 | path stringlengths 3 264 | content_id stringlengths 40 40 | detected_licenses listlengths 0 85 | license_type stringclasses 2
values | repo_name stringlengths 5 140 | snapshot_id stringlengths 40 40 | revision_id stringlengths 40 40 | branch_name stringclasses 905
values | visit_date timestamp[us]date 2015-08-09 11:21:18 2023-09-06 10:45:07 | revision_date timestamp[us]date 1997-09-14 05:04:47 2023-09-17 19:19:19 | committer_date timestamp[us]date 1997-09-14 05:04:47 2023-09-06 06:22:19 | github_id int64 3.89k 681M โ | star_events_count int64 0 209k | fork_events_count int64 0 110k | gha_license_id stringclasses 22
values | gha_event_created_at timestamp[us]date 2012-06-07 00:51:45 2023-09-14 21:58:39 โ | gha_created_at timestamp[us]date 2008-03-27 23:40:48 2023-08-21 23:17:38 โ | gha_language stringclasses 141
values | src_encoding stringclasses 34
values | language stringclasses 1
value | is_vendor bool 1
class | is_generated bool 2
classes | length_bytes int64 3 10.4M | extension stringclasses 115
values | content stringlengths 3 10.4M | authors listlengths 1 1 | author_id stringlengths 0 158 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
01a7ab9e10fef3cc1c08332c7e33107024081637 | 832ab919748632d0bad116c4a7d9c1de970ece0d | /SetHunterA1/CollisionDetector.cpp | 62145ba5131865f4c257cc385b1f359883c945b5 | [] | no_license | mayesi/sethunter | 1e9d11a946318dbc5c5620e7b97c0cb3a122b2e3 | 263c6220a705c5a640cc54464e2953c8a31460f8 | refs/heads/master | 2020-04-23T03:55:31.752931 | 2019-04-12T19:05:49 | 2019-04-12T19:05:49 | 170,892,321 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 352 | cpp | #include "CollisionDetector.h"
CollisionDetector::CollisionDetector()
{
}
CollisionDetector::~CollisionDetector()
{
}
// True - collision detected
bool CollisionDetector::CollisionCheck(HitBox box1, HitBox box2)
{
return (box1.upperx < box2.lowerx &&
box1.lowerx > box2.upperx &&
box1.uppery < box2.lowery &&
box1.lowery > box2.uppery);
}
| [
"maye.saechao@gmail.com"
] | maye.saechao@gmail.com |
b9632644721ea13fa2618f0fd4fe702867bc901b | 3f8b288711bb5adc2394171507f54c62dc60c601 | /ari/schedule.cpp | 5bbacb4b4fc6d6aa0ce3c4fe49d4142d145e49e9 | [] | no_license | pontsuyo/procon | 65df6356f0ea1cfb619898d9e8cc6e326c0586e7 | 804aaeb526946172a8f41e0619712f5989b6b613 | refs/heads/master | 2021-06-15T15:13:04.441761 | 2021-03-20T05:26:54 | 2021-03-20T05:26:54 | 175,234,672 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 599 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
#define rep(i,n) for(int i=0;i<n;i++)
const int MAX_N = 100000;
int N, S[MAX_N], T[MAX_N];
pair<int, int> itv[MAX_N];
void solve(){
rep(i, N){
itv[i].first = T[i];
itv[i].second = S[i];
}
sort(itv, itv+N);
int ans=0, t=0;
rep(i,N){
if(t<itv[i].second){
ans++;
t = itv[i].first;
}
}
printf("%d\n", ans);
}
int main(){
cin >> N;
rep(i, N){
cin >> S[i];
}
rep(i, N){
cin >>T[i];
}
solve();
return 0;
} | [
"tsuyopon9221@gmail.com"
] | tsuyopon9221@gmail.com |
c740eab1c4f8850ceaebb5f245e85fa4726fe2bb | eae39e688a55ae5359ee374d24980fee6b88c1a6 | /app/src/main/cpp/rtmp_pusher.cpp | fbad70b708816359e4282d46203a532e4f278636 | [] | no_license | AnJoiner/X264Cmake | 2380c763f128ef6884de9f2c2bbd843a860fa51f | 907bba0098db84dc51174b8be0505d06ced04324 | refs/heads/main | 2023-06-13T00:47:33.300557 | 2021-07-10T10:07:58 | 2021-07-10T10:07:58 | 356,831,110 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,699 | cpp | //
// Created by c2yu on 2021/5/10.
//
#include "android/log.h"
extern "C" {
#include "jni.h"
#include "rtmp_core.h"
}
#define LOGD(...) __android_log_print(ANDROID_LOG_DEBUG , "rtmp-pusher", __VA_ARGS__)
#define LOGI(...) __android_log_print(ANDROID_LOG_INFO , "rtmp-pusher", __VA_ARGS__)
#define LOGE(...) __android_log_print(ANDROID_LOG_ERROR , "rtmp-pusher", __VA_ARGS__)
#define LOGW(...) __android_log_print(ANDROID_LOG_WARN , "rtmp-pusher", __VA_ARGS__)
extern "C"
JNIEXPORT jint JNICALL
Java_com_coder_x264cmake_jni_RtmpPusher_rtmp_1pusher_1open(JNIEnv *env, jobject thiz, jstring url,
jint width, jint height) {
char *rtmp_url = const_cast<char *>(env->GetStringUTFChars(url, JNI_FALSE));
// int ret = rtmp_sender_alloc(rtmp_url);
// if (ret == RTMP_OK){
// rtmp_sender_start_publish(width,height);
// }
return rtmp_pusher_open(rtmp_url,width,height);
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_coder_x264cmake_jni_RtmpPusher_rtmp_1pusher_1close(JNIEnv *env, jobject thiz) {
return rtmp_sender_close();
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_coder_x264cmake_jni_RtmpPusher_rtmp_1pusher_1is_1connected(JNIEnv *env, jobject thiz) {
return rtmp_is_connected();
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_coder_x264cmake_jni_RtmpPusher_rtmp_1pusher_1push_1audio(JNIEnv *env, jobject thiz,
jbyteArray data, jint size,
jlong timestamp) {
jbyte *bytes = env->GetByteArrayElements(data, JNI_FALSE);
unsigned char *buffer = new unsigned char[size];
for (int i = 0; i < size; ++i) {
buffer[i] = bytes[i];
}
if (!rtmp_is_connected()){
LOGE("Failed to connect the rtmp server!");
return -1;
}
int ret = rtmp_sender_write_audio_frame(buffer,size,timestamp,0);
delete[] buffer;
env->ReleaseByteArrayElements(data,bytes,0);
return ret;
}
extern "C"
JNIEXPORT jint JNICALL
Java_com_coder_x264cmake_jni_RtmpPusher_rtmp_1pusher_1push_1video(JNIEnv *env, jobject thiz,
jbyteArray data, jint size,
jlong timestamp) {
jbyte *bytes = env->GetByteArrayElements(data, JNI_FALSE);
unsigned char *buffer = new unsigned char[size];
for (int i = 0; i < size; ++i) {
buffer[i] = bytes[i];
}
int ret = rtmp_sender_write_video_frame(buffer,size,timestamp,0);
delete[] buffer;
env->ReleaseByteArrayElements(data,bytes,0);
return ret;
}
| [
"anjoiner@163.com"
] | anjoiner@163.com |
a3b605cdcd9ee24248f275916c1bdc1aea9b89fb | 67662fce6ea9265d5b413b26b1dc66e898afe35b | /motoman_driver/include/motoman_driver/simple_message/motoman_read_single_io.h | ab5cc40a7837b715d0a30f7ce350f4a008bbfb63 | [
"BSD-3-Clause",
"Apache-2.0"
] | permissive | gavanderhoorn/motoman | 71194335d4a08b662148bd41e0566da90f3f08c7 | 63e624215180110474e0d89289f7434eb961d3b0 | refs/heads/kinetic-devel | 2023-07-07T21:14:16.399614 | 2023-03-21T12:15:18 | 2023-03-21T12:15:18 | 15,493,825 | 2 | 8 | null | 2020-10-22T19:30:23 | 2013-12-28T14:46:31 | C++ | UTF-8 | C++ | false | false | 4,364 | h | /*
* Software License Agreement (BSD License)
*
* Copyright (c) 2016, Delft Robotics Institute
* 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 Delft Robotics Institute, nor the names
* of its contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS"
* AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE
* IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
* ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE
* LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
* CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
* SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
* INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
* CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
* ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*
* \author G.A. vd. Hoorn (TU Delft Robotics Institute)
*/
#ifndef MOTOMAN_DRIVER_SIMPLE_MESSAGE_MOTOMAN_READ_SINGLE_IO_H
#define MOTOMAN_DRIVER_SIMPLE_MESSAGE_MOTOMAN_READ_SINGLE_IO_H
#ifdef ROS
#include "simple_message/simple_serialize.h"
#include "simple_message/shared_types.h"
#include "simple_message/log_wrapper.h"
#endif
#ifdef MOTOPLUS
#include "simple_serialize.h" // NOLINT(build/include)
#include "shared_types.h" // NOLINT(build/include)
#include "log_wrapper.h" // NOLINT(build/include)
#endif
namespace motoman
{
namespace simple_message
{
namespace io_ctrl
{
/**
* \brief Class encapsulated read single io data. Motoman specific interface
* to read a single IO element on the controller.
*
* The byte representation of a read single IO command is as follows
* (in order lowest index to highest). The standard sizes are given,
* but can change based on type sizes:
*
* member: type size
* address (industrial::shared_types::shared_int) 4 bytes
*
*
* THIS CLASS IS NOT THREAD-SAFE
*
*/
class ReadSingleIO : public industrial::simple_serialize::SimpleSerialize
{
public:
/**
* \brief Default constructor
*
* This method creates empty data.
*
*/
ReadSingleIO(void);
/**
* \brief Destructor
*
*/
~ReadSingleIO(void);
/**
* \brief Initializes a empty motion control command
*
*/
void init();
/**
* \brief Initializes a complete motion control command
*
*/
void init(industrial::shared_types::shared_int address);
/**
* \brief Sets address
*
* \param address Controller address of the targeted IO element.
*/
void setAddress(industrial::shared_types::shared_int address)
{
this->address_ = address;
}
/**
* \brief Returns the address of the IO element
*
* \return address
*/
industrial::shared_types::shared_int getAddress()
{
return this->address_;
}
/**
* \brief Copies the passed in value
*
* \param src (value to copy)
*/
void copyFrom(ReadSingleIO &src);
/**
* \brief == operator implementation
*
* \return true if equal
*/
bool operator==(ReadSingleIO &rhs);
// Overrides - SimpleSerialize
bool load(industrial::byte_array::ByteArray *buffer);
bool unload(industrial::byte_array::ByteArray *buffer);
unsigned int byteLength()
{
return 1 * sizeof(industrial::shared_types::shared_int);
}
private:
/**
* \brief Address of IO element.
*/
industrial::shared_types::shared_int address_;
};
} // namespace io_ctrl
} // namespace simple_message
} // namespace motoman
#endif // MOTOMAN_DRIVER_SIMPLE_MESSAGE_MOTOMAN_READ_SINGLE_IO_H
| [
"dan.ambrosio@gmail.com"
] | dan.ambrosio@gmail.com |
cf7f3835902f6018c5342540e804d9f352fa44b0 | 83bd35233ed87ac36a61e1b32e26c4e3af41cd4d | /Graphics/004_line_intersection.CPP | 412874d2e2a57ca98c6224f0e10844d753a9d3ec | [] | no_license | KamalDGRT/TurboCPP | c7c89afbba6d0695bdf0f2074529a2c48ec4827a | e326ca2948dbec77e8d2a5ac13543e79b6046557 | refs/heads/master | 2020-12-03T18:59:18.760753 | 2020-09-24T18:19:33 | 2020-09-24T18:19:33 | 231,441,492 | 5 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,181 | cpp | #include<stdio.h>
#include<math.h>
#include<graphics.h>
#include<iostream.h>
#include<conio.h>
void main()
{
clrscr();
float m1,c1,m2,c2,x1,y1,x2,y2,dx,dy,X_Intersection,Y_Intersection;
int gd=DETECT,gm;
initgraph(&gd,&gm,"");
cout<<"Program to find the intersecting point of two lines\n";
cout<<"Enter Line 1 X1 , Y1 : ";cin>>x1>>y1;
cout<<"Enter Line 1 X2 , Y2 : ";cin>>x2>>y2;
line(x1,y1,x2,y2);
dx=x2-x1;
dy=y2-y1;
m1=dy/dx;
//y=mx+c ==> Intercept c = Y-mx
c1=y1-m1*x1; // which is same as y2-slope*x2
cout<<"Enter Line 2 X1 , Y1 : ";cin>>x1>>y1;
cout<<"Enter Line 2 X2 , Y2 : ";cin>>x2>>y2;
line(x1,y1,x2,y2);
dx=x2-x1;
dy=y2-y1;
m2=dy/dx;
//y=mx+c ==> c=y-mx
c2=y1-m2*x1;//which is same as y2-slope* x2
cout<<"\nEquation of Line 1 : Y = "<<m1<<"x";
(c1<0)?cout<<' '<<c1:cout<<'+'<<c1;
cout<<"\nEquation of Line 2 : Y = "<<m2<<"x";
(c2<0)?cout<<' '<<c2:cout<<'+'<<c2;
if((m1-m2)==0)
cout<<"No Intersection between the lines :";
else
{
X_Intersection=(c2-c1)/(m1-m2);
Y_Intersection=m1*X_Intersection+c1;
cout<<"\n\tIntersecting point : "<<X_Intersection<<","<<Y_Intersection;
circle(X_Intersection,Y_Intersection,5);
}
getch();
} | [
"kamaldgrt@gmail.com"
] | kamaldgrt@gmail.com |
e567f96489f66fe5ecf22b75c226d58e2758eacc | 972cbb6a65ab3347ec0b1f08b6f3003d75186f43 | /Chapter03/colordetector.cpp | 1425a372b697713e7bda13bc0d61a63b406f8c2d | [
"MIT"
] | permissive | PacktPublishing/OpenCV3-Computer-Vision-Application-Programming-Cookbook-Third-Edition | e37f0f8d8725578f460a4e08cdc4cad662882bd6 | 2f3a251612b2879f00819f7f57009b9121ff89ab | refs/heads/master | 2023-02-03T20:35:50.202816 | 2023-01-30T08:05:22 | 2023-01-30T08:05:22 | 81,076,786 | 221 | 131 | MIT | 2022-08-02T03:40:05 | 2017-02-06T10:42:01 | C++ | UTF-8 | C++ | false | false | 2,089 | cpp | /*------------------------------------------------------------------------------------------*\
This file contains material supporting chapter 3 of the book:
OpenCV3 Computer Vision Application Programming Cookbook
Third Edition
by Robert Laganiere, Packt Publishing, 2016.
This program is free software; permission is hereby granted to use, copy, modify,
and distribute this source code, or portions thereof, for any purpose, without fee,
subject to the restriction that the copyright notice may not be removed
or altered from any source or altered source distribution.
The software is released on an as-is basis and without any warranties of any kind.
In particular, the software is not guaranteed to be fault-tolerant or free from failure.
The author disclaims all warranties with regard to this software, any use,
and any consequent failure, is purely the responsibility of the user.
Copyright (C) 2016 Robert Laganiere, www.laganiere.name
\*------------------------------------------------------------------------------------------*/
#include "colordetector.h"
#include <vector>
cv::Mat ColorDetector::process(const cv::Mat &image) {
// re-allocate binary map if necessary
// same size as input image, but 1-channel
result.create(image.size(),CV_8U);
// Converting to Lab color space
if (useLab)
cv::cvtColor(image, converted, CV_BGR2Lab);
// get the iterators
cv::Mat_<cv::Vec3b>::const_iterator it= image.begin<cv::Vec3b>();
cv::Mat_<cv::Vec3b>::const_iterator itend= image.end<cv::Vec3b>();
cv::Mat_<uchar>::iterator itout= result.begin<uchar>();
// get the iterators of the converted image
if (useLab) {
it = converted.begin<cv::Vec3b>();
itend = converted.end<cv::Vec3b>();
}
// for each pixel
for ( ; it!= itend; ++it, ++itout) {
// process each pixel ---------------------
// compute distance from target color
if (getDistanceToTargetColor(*it)<maxDist) {
*itout= 255;
} else {
*itout= 0;
}
// end of pixel processing ----------------
}
return result;
}
| [
"subhalaxmin@packtpub.com"
] | subhalaxmin@packtpub.com |
11c585171579c70119796cc72c9455d5dfe2dbb5 | ceeddddcf3e99e909c4af5ff2b9fad4a8ecaeb2a | /tags/release-1.1/source/Irrlicht/IImagePresenter.h | f822f594eba2dbc7b83fb20df59537e90304289e | [
"Zlib",
"LicenseRef-scancode-other-permissive",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | jivibounty/irrlicht | d9d6993bd0aee00dce2397a887b7f547ade74fbb | c5c80cde40b6d14fe5661440638d36a16b41d7ab | refs/heads/master | 2021-01-18T02:56:08.844268 | 2015-07-21T08:02:25 | 2015-07-21T08:02:25 | 39,405,895 | 0 | 0 | null | 2015-07-20T20:07:06 | 2015-07-20T20:07:06 | null | UTF-8 | C++ | false | false | 798 | h | // Copyright (C) 2002-2006 Nikolaus Gebhardt
// This file is part of the "Irrlicht Engine".
// For conditions of distribution and use, see copyright notice in irrlicht.h
#ifndef __I_IMAGE_PRESENTER_H_INCLUDED__
#define __I_IMAGE_PRESENTER_H_INCLUDED__
#include "IImage.h"
namespace irr
{
namespace video
{
/*!
Interface for a class which is able to present an IImage
an the Screen. Usually only implemented by an IrrDevice for
presenting Software Device Rendered images.
This class should be used internal only.
*/
class IImagePresenter
{
public:
//! presents a surface in the client area
virtual void present(video::IImage* surface, s32 windowId=0, core::rect<s32>* src=0 ) = 0;
};
} // end namespace video
} // end namespace irr
#endif
| [
"hybrid@dfc29bdd-3216-0410-991c-e03cc46cb475"
] | hybrid@dfc29bdd-3216-0410-991c-e03cc46cb475 |
dab4155c9627a64b354d211cd5b348ff02146913 | 482c0df0db19446f3f3c68705b366777c9795bb4 | /test/unittest/compiler/unittest_interpreter.cpp | ee4f3c5247c3be7902c77f543ef9aacdd1d3caff | [
"Apache-2.0",
"LicenseRef-scancode-free-unknown"
] | permissive | priyankmohanverma/nntrainer | dc5efa1aabe3fddbec4485b56059a495550f6787 | 0c82b2f21d2587dce0a18afa35fbc8d59c23adcd | refs/heads/main | 2023-08-29T04:14:56.297226 | 2021-10-14T17:07:03 | 2021-10-18T04:28:55 | 408,322,547 | 0 | 0 | Apache-2.0 | 2021-09-23T12:14:42 | 2021-09-20T05:35:59 | C++ | UTF-8 | C++ | false | false | 6,530 | cpp | // SPDX-License-Identifier: Apache-2.0
/**
* Copyright (C) 2021 Jihoon Lee <jhoon.it.lee@samsung.com>
*
* @file unittest_interpreter.cpp
* @date 02 April 2021
* @brief interpreter test
* @see https://github.com/nnstreamer/nntrainer
* @author Jihoon Lee <jhoon.it.lee@samsung.com>
* @bug No known bugs except for NYI items
*/
#include <functional>
#include <gtest/gtest.h>
#include <memory>
#include <app_context.h>
#include <execution_mode.h>
#include <ini_interpreter.h>
#include <interpreter.h>
#include <layer.h>
#include <layer_node.h>
#include <network_graph.h>
#include <node_exporter.h>
#ifdef ENABLE_TFLITE_INTERPRETER
#include <tflite_interpreter.h>
#include <tensorflow/contrib/lite/interpreter.h>
#include <tensorflow/contrib/lite/kernels/register.h>
#include <tensorflow/contrib/lite/model.h>
#endif
#include <app_context.h>
#include <compiler_test_util.h>
using LayerRepresentation = std::pair<std::string, std::vector<std::string>>;
auto ini_interpreter = std::make_shared<nntrainer::IniGraphInterpreter>(
nntrainer::AppContext::Global(), compilerPathResolver);
/**
* @brief nntrainer Interpreter Test setup
*
* @note Proposing an evolutional path of current test
* 1. A reference graph vs given paramter
* 2. A reference graph vs list of models
* 3. A reference graph vs (pick two models) a -> b -> a graph, b -> a -> b
* graph
*/
class nntrainerInterpreterTest
: public ::testing::TestWithParam<
std::tuple<nntrainer::GraphRepresentation, const char *,
std::shared_ptr<nntrainer::GraphInterpreter>>> {
protected:
virtual void SetUp() {
auto params = GetParam();
reference = std::get<0>(params);
file_path = compilerPathResolver(std::get<1>(params));
interpreter = std::move(std::get<2>(params));
}
nntrainer::GraphRepresentation reference;
std::shared_ptr<nntrainer::GraphInterpreter> interpreter;
std::string file_path;
};
/**
* @brief Check two compiled graph is equal
* @note later this will be more complicated (getting N graph and compare each
* other)
*
*/
TEST_P(nntrainerInterpreterTest, graphEqual) {
std::cout << "testing " << file_path << '\n';
// int status = reference->compile("");
// EXPECT_EQ(status, ML_ERROR_NONE);
auto g = interpreter->deserialize(file_path);
/// @todo: change this to something like graph::finalize
// status = g->compile("");
// EXPECT_EQ(status, ML_ERROR_NONE);
/// @todo: make a proper graph equal
/// 1. having same number of nodes
/// 2. layer name is identical (this is too strict though)
/// 3. attributes of layer is identical
graphEqual(g, reference);
}
/**
* @brief graph serialize after deserialize, compare if they are the same
*
*/
TEST_P(nntrainerInterpreterTest, graphSerializeAfterDeserialize) {
auto g = interpreter->deserialize(file_path);
auto out_file_path = file_path + ".out";
/// @todo: change this to something like graph::finalize
// int status = g->compile("");
// EXPECT_EQ(status, ML_ERROR_NONE);
interpreter->serialize(g, out_file_path);
auto new_g = interpreter->deserialize(out_file_path);
graphEqual(g, new_g);
EXPECT_EQ(remove(out_file_path.c_str()), 0) << strerror(errno);
}
auto fc0 = LayerRepresentation("fully_connected",
{"name=fc0", "unit=2", "input_shape=1:1:100"});
auto fc1 = LayerRepresentation("fully_connected", {"name=fc1", "unit=2"});
auto flatten = LayerRepresentation("flatten", {"name=flat"});
#ifdef ENABLE_TFLITE_INTERPRETER
/**
* TODO: update tflite interpreter after the change of semantics that tensors
* are different between input and output of a layer but the underlying data
* is same. Once the interpreter is updated, this test can be enabled.
*/
TEST(nntrainerInterpreterTflite, simple_fc) {
nntrainer::TfliteInterpreter interpreter;
auto fc0_zeroed = LayerRepresentation(
"fully_connected", {"name=fc0", "unit=2", "input_shape=1:1:1",
"bias_initializer=ones", "weight_initializer=ones"});
auto fc1_zeroed = LayerRepresentation(
"fully_connected",
{"name=fc1", "unit=2", "bias_initializer=ones", "weight_initializer=ones"});
auto g = makeGraph({fc0_zeroed, fc1_zeroed});
nntrainer::NetworkGraph ng;
for (auto &node : g) {
ng.addLayer(node);
}
EXPECT_EQ(ng.compile(""), ML_ERROR_NONE);
EXPECT_EQ(ng.initialize(), ML_ERROR_NONE);
ng.allocateTensors(nntrainer::ExecutionMode::INFERENCE);
interpreter.serialize(g, "test.tflite");
ng.deallocateTensors();
tflite::ops::builtin::BuiltinOpResolver resolver;
std::unique_ptr<tflite::Interpreter> tf_interpreter;
std::unique_ptr<tflite::FlatBufferModel> model =
tflite::FlatBufferModel::BuildFromFile("test.tflite");
EXPECT_NE(model, nullptr);
tflite::InterpreterBuilder(*model, resolver)(&tf_interpreter);
EXPECT_NE(tf_interpreter, nullptr);
EXPECT_EQ(tf_interpreter->AllocateTensors(), kTfLiteOk);
nntrainer::Tensor in(nntrainer::TensorDim({1, 1, 1, 1}));
in.setValue(2.0f);
nntrainer::Tensor out(nntrainer::TensorDim({1, 1, 1, 2}));
auto in_indices = tf_interpreter->inputs();
for (size_t idx = 0; idx < in_indices.size(); idx++) {
tf_interpreter->tensor(in_indices[idx])->data.raw =
reinterpret_cast<char *>(in.getData());
}
auto out_indices = tf_interpreter->outputs();
for (size_t idx = 0; idx < out_indices.size(); idx++) {
tf_interpreter->tensor(out_indices[idx])->data.raw =
reinterpret_cast<char *>(out.getData());
}
int status = tf_interpreter->Invoke();
EXPECT_EQ(status, TfLiteStatus::kTfLiteOk);
nntrainer::Tensor ans(nntrainer::TensorDim({1, 1, 1, 2}));
ans.setValue(7.0f);
EXPECT_EQ(out, ans);
if (remove("test.tflite")) {
std::cerr << "remove ini "
<< "test.tflite"
<< "failed, reason: " << strerror(errno);
}
}
#endif
/**
* @brief make ini test case from given parameter
*/
static std::tuple<nntrainer::GraphRepresentation, const char *,
std::shared_ptr<nntrainer::GraphInterpreter>>
mkTc(nntrainer::GraphRepresentation graph, const char *file,
std::shared_ptr<nntrainer::GraphInterpreter> interpreter) {
return std::make_tuple(graph, file, interpreter);
}
// clang-format off
INSTANTIATE_TEST_CASE_P(nntrainerAutoInterpreterTest, nntrainerInterpreterTest,
::testing::Values(
mkTc(makeGraph({fc0, flatten}), "simple_fc.ini", ini_interpreter),
mkTc(makeGraph({fc0, flatten}), "simple_fc_backbone.ini", ini_interpreter)
));
// clang-format on
| [
"jijoong.moon@samsung.com"
] | jijoong.moon@samsung.com |
f45972a6712be8f86cd0b4a5a2fc1b6579e1ba53 | 5838cf8f133a62df151ed12a5f928a43c11772ed | /NT/shell/themes/themeui/thscheme.h | db3d60cedfa06972a8c53a7bc70b0b7e3dea2636 | [] | no_license | proaholic/Win2K3 | e5e17b2262f8a2e9590d3fd7a201da19771eb132 | 572f0250d5825e7b80920b6610c22c5b9baaa3aa | refs/heads/master | 2023-07-09T06:15:54.474432 | 2021-08-11T09:09:14 | 2021-08-11T09:09:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,046 | h | /*****************************************************************************\
FILE: thScheme.h
DESCRIPTION:
This is the Autmation Object to theme scheme object. This one will be
a skin.
BryanSt 5/9/2000 (Bryan Starbuck)
Copyright (C) Microsoft Corp 2000-2000. All rights reserved.
\*****************************************************************************/
#ifndef _FILE_H_THSCHEME
#define _FILE_H_THSCHEME
#include <cowsite.h>
#include <atlbase.h>
static const GUID CLSID_SkinScheme = { 0x570fdefa, 0x5907, 0x47fe, { 0x96, 0x6b, 0x90, 0x30, 0xb4, 0xba, 0x10, 0xcd } };// {570FDEFA-5907-47fe-966B-9030B4BA10CD}
HRESULT CSkinScheme_CreateInstance(IN LPCWSTR pszFilename, OUT IThemeScheme ** ppThemeScheme);
class CSkinScheme : public CObjectCLSID
, public IThemeScheme
{
public:
//////////////////////////////////////////////////////
// Public Interfaces
//////////////////////////////////////////////////////
// *** IUnknown ***
virtual STDMETHODIMP QueryInterface(REFIID riid, LPVOID * ppvObj);
virtual STDMETHODIMP_(ULONG) AddRef(void);
virtual STDMETHODIMP_(ULONG) Release(void);
// *** IThemeScheme ***
virtual STDMETHODIMP get_DisplayName(OUT BSTR * pbstrDisplayName);
virtual STDMETHODIMP put_DisplayName(IN BSTR bstrDisplayName) {return E_NOTIMPL;}
virtual STDMETHODIMP get_Path(OUT BSTR * pbstrPath);
virtual STDMETHODIMP put_Path(IN BSTR bstrPath);
virtual STDMETHODIMP get_length(OUT long * pnLength);
virtual STDMETHODIMP get_item(IN VARIANT varIndex, OUT IThemeStyle ** ppThemeStyle);
virtual STDMETHODIMP get_SelectedStyle(OUT IThemeStyle ** ppThemeStyle);
virtual STDMETHODIMP put_SelectedStyle(IN IThemeStyle * pThemeStyle);
virtual STDMETHODIMP AddStyle(OUT IThemeStyle ** ppThemeStyle);
// *** IDispatch ***
virtual STDMETHODIMP GetTypeInfoCount(UINT *pctinfo) { return E_ACCESSDENIED; }
virtual STDMETHODIMP GetTypeInfo(UINT itinfo,LCID lcid,ITypeInfo **pptinfo) { return E_ACCESSDENIED; }
virtual STDMETHODIMP GetIDsOfNames(REFIID riid,OLECHAR **rgszNames,UINT cNames, LCID lcid, DISPID * rgdispid) { return E_ACCESSDENIED; }
virtual STDMETHODIMP Invoke(DISPID dispidMember,REFIID riid,LCID lcid,WORD wFlags, DISPPARAMS * pdispparams, VARIANT * pvarResult, EXCEPINFO * pexcepinfo,UINT * puArgErr) { return E_ACCESSDENIED; }
private:
CSkinScheme(IN LPCWSTR pszFilename);
virtual ~CSkinScheme(void);
// Private Member Variables
long m_cRef;
IThemeStyle * m_pSelectedStyle; // The selected style.
LPWSTR m_pszFilename; // This is the full path to the ".thx" file
long m_nSize; // The size of the collection of "Color Styles".
// Private Member Functions
// Friend Functions
friend HRESULT CSkinScheme_CreateInstance(IN LPCWSTR pszFilename, OUT IThemeScheme ** ppThemeScheme);
};
#endif // _FILE_H_THSCHEME
| [
"blindtiger@foxmail.com"
] | blindtiger@foxmail.com |
bcec913585aa7aff2ac4c3751333ba2190154001 | bb97dfe96fdaa550058b28248d1f414bf4ff809d | /Except/Except/Myexceptions.h | 43690918a7c6124e54d1fffbed9a3a47fadc089b | [] | no_license | Anat37/cpl_2018 | 65fdc81816e085a041c38aeab411965fa9f6bca5 | 8a02d246db272d27f24c7c7e614fdbddfc2a15cf | refs/heads/master | 2021-04-05T23:47:21.220862 | 2018-05-01T11:01:34 | 2018-05-01T11:01:34 | 124,889,081 | 0 | 0 | null | 2018-05-09T21:40:34 | 2018-03-12T12:55:31 | C++ | UTF-8 | C++ | false | false | 1,290 | h | #pragma once
#include<vector>
#include<setjmp.h>
#include <iostream>
class BaseObject {
public:
BaseObject();
virtual ~BaseObject();
};
class BaseException {
public:
virtual ~BaseException() {};
};
extern std::vector<jmp_buf*> envs;
extern std::vector<BaseObject*> stackObjects;
extern std::vector<int> tries;
extern BaseException* raisedException;
extern int jmpVal;
extern jmp_buf* env;
void callDestroyers();
#define TRY tries.push_back(stackObjects.size()); \
env = new jmp_buf[1]; \
jmpVal = setjmp(*env); \
if (!jmpVal) {{ \
envs.push_back(env);
#define RETHROW(exception) if (envs.size() == 0) { \
exit(1); \
} \
raisedException = exception; \
callDestroyers(); \
longjmp(*envs.back(), 1);
#define THROW(exception) if (raisedException != nullptr) { \
exit(1); \
} else { \
RETHROW(exception) \
}
#define CATCH(type, name) }} \
{type* ptr = dynamic_cast<type*>(raisedException); \
if (ptr != nullptr) { \
raisedException = nullptr; \
type name = *ptr;
#define ENDCATCH }} \
delete envs.back(); \
envs.pop_back(); \
if (raisedException != nullptr){ \
RETHROW(raisedException) \
}
| [
"kozlof9@yandex.ru"
] | kozlof9@yandex.ru |
f70d8ed14eaac9d9f9874344a9368f5090b5fcad | 97ae532fd3b838ef80917a4a64e09e1167781911 | /plugins/gui/src/widgets/MinimalPopUp.h | 02f42352fd234477ce61db6524f1ade6a07abf54 | [] | no_license | aiosin/megamol | 88417a47b24b238131cf82548f9ed8a6e93fb658 | 9f0331272203d73d6cc2b4136ff316c1862249f5 | refs/heads/master | 2022-12-19T23:03:17.854986 | 2020-08-14T13:21:41 | 2020-08-14T13:21:41 | 288,465,958 | 0 | 0 | null | 2020-08-18T13:37:34 | 2020-08-18T13:37:34 | null | UTF-8 | C++ | false | false | 705 | h | /*
* MinimalPopUp.h
*
* Copyright (C) 2019 by Universitaet Stuttgart (VIS).
* Alle Rechte vorbehalten.
*/
#ifndef MEGAMOL_GUI_MINIMALPOPUP_INCLUDED
#define MEGAMOL_GUI_MINIMALPOPUP_INCLUDED
#include "GUIUtils.h"
namespace megamol {
namespace gui {
/**
* String search widget.
*/
class MinimalPopUp {
public:
static bool PopUp(const std::string& label_id, bool open_popup, const std::string& info_text,
const std::string& confirm_btn_text, bool& confirmed, const std::string& abort_btn_text, bool& aborted);
private:
MinimalPopUp(void) = default;
~MinimalPopUp(void) = default;
};
} // namespace gui
} // namespace megamol
#endif // MEGAMOL_GUI_MINIMALPOPUP_INCLUDED
| [
"matthias.braun@visus.uni-stuttgart.de"
] | matthias.braun@visus.uni-stuttgart.de |
8f40468fc32d2536eb7a3f03f63699b77284d107 | 3981346b574bfa72ca68350835c3bc6c7e8936e5 | /OpenMesh-6.3/src/OpenMesh/Apps/ClothSimulation/Particle.h | 8db9c799947ee5be41090b80b06f25681c2a2fa9 | [
"BSD-3-Clause"
] | permissive | humberthumbert/drape | 98ee73e930bec5148bd90720fef919b04df159d8 | 90515d04baa8ec016af04130f19e4e92708997f5 | refs/heads/master | 2021-05-01T13:19:50.453833 | 2018-03-22T20:17:14 | 2018-03-22T20:17:14 | 121,075,716 | 0 | 0 | null | 2018-02-22T22:37:02 | 2018-02-11T02:30:50 | C++ | UTF-8 | C++ | false | false | 2,082 | h | #ifndef PARTICLE_H
#define PARTICLE_H
#include "GlobalTypes.h"
#include "Vector.h"
// -------------------- STL
#include <functional>
// -------------------- OpenMesh
//#include <OpenMesh/Core/Geometry/VectorT.hh>
class Particle
{
private:
bool m_active;
bool m_movable;
float m_mass;
//MyMesh::VertexIter v_it; // OpenMesh vertex iterator to the vertex this particle belongs to
Vector3 m_pos;
Vector3 m_oldPos;
Vector3 m_acceleration;
Vector3 m_norm;
public:
Particle(const Vector3 &pos, float mass)
:m_movable(true), m_mass(mass), m_pos(pos), m_oldPos(pos), m_acceleration(Vec::Zero), m_norm(Vec::Zero)
{
m_active = (pos.m_x != -1.0f) && (pos.m_y != -1.0f);
}
Particle() {}
void addForce(const Vector3 &f) { m_acceleration += f / m_mass; }
void timeStep(float deltaTime)
{
if(m_movable)
{
Vector3 temp = m_pos;
m_pos = m_pos + (m_pos-m_oldPos)*(1.0 - PARTICLE_VELOCITY_DAMPING) + m_acceleration*deltaTime*deltaTime;
m_oldPos = temp;
resetAcceleration();
}
}
bool isValid() { return m_active; }
Vector3 getPos() { return m_pos; }
void setMovable(bool value) { m_movable = value; }
void offsetPos(const Vector3 &v)
{
if (m_movable)
{
m_oldPos = m_pos;
m_pos += v;
}
}
void resetAcceleration()
{
m_acceleration = Vec::Zero;
}
void resetNormal()
{
m_norm = Vec::Zero;
}
void addToNormal(const Vector3& normal)
{
m_norm += normal;
}
Vector3& getNormal()
{
return m_norm;
}
void setToPrevPosition()
{
m_pos = m_oldPos;
}
// might be used for std::set
// std::size_t getHash()
// {
// size_t hash = std::hash<float>()(pos[0]);
// hash = hash ^ (std::hash<float>()(pos[1]) << 1);
// hash = hash ^ (std::hash<float>()(pos[2]) << 1);
// return hash;
// }
// bool operator==(const Particle & p) const
// {
// Vector3 oPos = p.getPos();
// return pos[0] == oPos[0] && pos[1] == oPos[1] && pos[2] == oPos[2];
// }
// bool operator!=(const Particle & p) const
// {
// return !(*this == p);
// }
};
#endif /* end of PARTICLE_H */ | [
"lemonloic@gmail.com"
] | lemonloic@gmail.com |
115774102baedf75540fa08703b415bd94a47ee5 | 8ed4f41e2db7c11ddfe3ae5569f5a1f0fb145dd7 | /ScaleVeiw/3DScreen.cpp | c777837c2b4320cee7e425d6bfb017c164a2c1aa | [
"MIT"
] | permissive | hillelskolnik/TabsFrame | 4299c2ab3a691a3bf9b82945947da207b02b73e4 | 58115e2eb4a156f21596e608d4ce516b1e8f4420 | refs/heads/master | 2020-05-29T21:44:45.788823 | 2019-05-30T10:52:19 | 2019-05-30T10:52:19 | 189,389,307 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 44,595 | cpp | //#include "3DScreen.h"
//#include "3DScreen.h"
//#include "3DScreen.h"
//#include "3DScreen.h"
//#include "3DScreen.h"
#include "stdafx.h"
#include "ScaleVeiw.h"
#include ".\3dscreen.h"
//#include "DEFF.H"
C3DScreen::C3DScreen(void)
: m_edgeLeft(0)
, m_edgeTop(0)
, m_edgeReight(0)
, m_edgeBottom(0)
, m_tansparentColpr(0x64000000)
, m_pPixelBuf(NULL)
, m_yEngle(0)
,m_hThread(NULL)
, m_uiThreadId(0)
, m_currentObject(NULL)
, m_pWnd(NULL)
, m_pDibBits(NULL)
,m_bQuit(false)
, m_bNotPaint(false)
{
m_hThread = (HANDLE)::_beginthreadex(NULL, 0, SRun, this, 0, &m_uiThreadId);
CString str;
str.Format("GetCurrentThreadId(%d)", m_uiThreadId);
HANDLE hEv = CreateEvent(NULL, TRUE, FALSE, str);
DWORD hr = WaitForSingleObject(hEv, INFINITE);
Sleep(50);
}
C3DScreen::~C3DScreen(void)
{
m_bQuit = true;
::PostThreadMessage(m_uiThreadId, WM_QUIT, 0, 0);
::WaitForSingleObject(m_hThread, 1500);
POSITION pos = m_3DObjectMap.GetStartPosition();
int key = -1;
C3DObject* ob = NULL;
while(pos != NULL)
{
m_3DObjectMap.GetNextAssoc(pos, key, ob);
delete ob;
}
m_pixselArr.RemoveAll();
DeleteGdiObjects();
// delete [] m_pDibBits;
}
bool C3DScreen::SetRelativeEdge(int edge, ScreenBorder sb)
{
switch(sb)
{
case sb_left:
if((edge + m_edgeReight) >= 1.0)
return false;
m_edgeLeft = edge;
break;
case sb_top:
if((edge + m_edgeBottom) >= 1.0)
return false;
m_edgeTop = edge;
break;
case sb_right:
if((edge + m_edgeLeft) >= 1.0)
return false;
m_edgeReight = edge;
break;
case sb_bottom:
if((edge + m_edgeTop) >= 1.0)
return false;
m_edgeBottom = edge;
break;
}
return true;
}
// Set logic image pixsel size
bool C3DScreen::SetSceenSize(int cx, int cy, double yEngle, double nearPlane, double farPlane)
{
if(cx <= 0 || cy <= 0 || yEngle <= 0.0 || yEngle >= 90.0 ||
nearPlane <= 0.0 || farPlane <= 0.0 || farPlane <= nearPlane)
return false;
double fullRatio = farPlane / nearPlane;
m_info.cx = (int)(float)((double)(float)cx * fullRatio);
m_info.cy = (int)(float)((double)(float)cy * fullRatio);
m_rasterRc.SetRect(m_info.cx, m_info.cy, 0, 0);
// fix ratio
//fullRatio = (double)(float)m_cy / (double)(float)cy;
m_info.middleSpace.x = (double)(float)m_info.cx / 2.0;
m_info.middleSpace.y = (double)(float)m_info.cy / 2.0;
// find ratio in middle way between far and near
double halfWay = (nearPlane + farPlane) / 2.0;
double halfRatio = halfWay / nearPlane;
double cotangHalfYEngle = 1.0 / tan((yEngle / 2.0) * g_degtorad);
m_info.middleSpace.z = halfRatio * cotangHalfYEngle *
((double)(float)cy / 2.0);
// Use as Transform vector to convert x and y to logic screen
// TransformVector / z * (x or y)
m_info.TransformVector = cotangHalfYEngle *
((double)(float)cy / 2.0) * fullRatio;
double zRadius = m_info.TransformVector - m_info.middleSpace.z;
m_info.Near = m_info.middleSpace.z - zRadius;
DeleteGdiObjects();
m_pixselArr.RemoveAll();
m_clearingArr.RemoveAll();
m_clearingArr.SetSize(m_info.cx);
m_pixselArr.SetSize(m_info.cx*m_info.cy);
m_pPixelBuf = m_pixselArr.GetData();
m_clearingArr.SetSize(m_info.cx);
int size = m_clearingArr.GetCount();
CScreenPixsel* p = m_clearingArr.GetData();
for(register int i = 0; i < size; ++i, ++p)
p->color = m_tansparentColpr;
return true;
}
void C3DScreen::SetScreenTransparentColor(unsigned long color)
{
m_tansparentColpr = color;
m_tansparentColpr |= 0x64000000;
int size = m_clearingArr.GetCount();
CScreenPixsel* p = m_clearingArr.GetData();
for(register int i = 0; i < size; ++i, ++p)
p->color = m_tansparentColpr;
p = m_clearingArr.GetData();
CScreenPixsel* pixselBuf = m_pPixelBuf;
int rowSize = m_info.cx * sizeof(CScreenPixsel);
for(register int y = 0; y < m_info.cy; ++y, pixselBuf += m_info.cx)
memcpy(pixselBuf, p, rowSize);
}
void C3DScreen::PaintTansparent(void)
{
RGBQUAD* pCol = NULL;
BYTE c[4] = {0,0,0,0};
POSITION pos = m_3DObjectMap.GetStartPosition();
int key = -1;
C3DObject* ob = NULL;
m_rasterRc.SetRect(m_info.cx, m_info.cy, 0, 0);
while(pos != NULL)
{
m_3DObjectMap.GetNextAssoc(pos, key, ob);
if(ob->m_bPause)
continue;
tdPixelRowArr& pixArr = ob->m_2DScreen;
tdPixselArr** pPixData = pixArr.GetData();
int nLeft = (int)(float)ob->m_leftScreen;
int nTop = (int)(float)(ob->m_topScreen/* + 1*/);
int nRight = (int)(float)ob->m_rightScreen;
int nBottom = (int)(float)ob->m_bottomScreen ;
int sizePosCount = ob->m_sizePosArr.GetCount();
int *pSizePos = ob->m_sizePosArr.GetData();
int *pPos = ob->m_posArr.GetData();
//++nTop; // to InflateRect rect
int topPos = m_info.cy - nTop;
if(topPos < 0)
{
nTop += topPos;
pPixData -= topPos;
pPos -= topPos * sizePosCount;
pSizePos -= topPos;
}
int xcorection = 0;
if(nLeft < 0)
{
xcorection = nLeft;
nLeft = 0;
}
if(nRight > m_info.cx)
nRight = m_info.cx;
int pcy = nTop - nBottom;
if(pcy <= 1)
continue;
int pcx = nRight - nLeft;
if(pcx <= 1)
continue;
nBottom = m_info.cy - nBottom;
int nopTop = m_info.cy - nTop;
m_rasterRc.left = min(m_rasterRc.left, nLeft - 1);
m_rasterRc.right = max(m_rasterRc.right, nRight +1);
m_rasterRc.top = min(m_rasterRc.top, nopTop - 1);
m_rasterRc.bottom = max(m_rasterRc.bottom, nBottom +1);
int cymintop = nopTop;
CRect rc(0,0, nRight, nBottom);
//if(ob->m_objectType == t3d_rect)
//{
// rc.SetRect(0,0,sizePosCount,sizePosCount);
//}
//else
rc.InflateRect(2,2);
//rc += CPoint(-1,-2);
m_dibDC.BitBlt(rc.left,rc.top,rc.Width()
,rc.Height(),m_refreshDC,rc.left,
rc.top,SRCCOPY);
CScreenPixsel* p = m_clearingArr.GetData();
CScreenPixsel* psp;
/* if(nLeft < 0)
{
pcx += nLeft;
nLeft = 0;
}*/
int delsize = pcx * sizeof(CScreenPixsel);
CScreenPixsel SPi;
for(register int y = 0; y < pcy && y < nTop; ++y,
++pSizePos, pPos += sizePosCount)
{
// if((cymintop + y) < 0)
// continue;
int SizePos = *pSizePos;
if(SizePos && pcx / SizePos < 6)
{
psp = m_pPixelBuf +
((cymintop + y) * m_info.cx + nLeft);
memcpy(psp, p, delsize);
}
else
{
int nnLc = nLeft + xcorection;
for(register int x = 0; x < SizePos/*pcx*/; ++x)//, sp++)
{
int Pos = *(pPos + x);
if((nnLc + Pos) < 0 || (nnLc + Pos) >= m_info.cx)
continue;
psp = m_pPixelBuf +
((cymintop + y) * m_info.cx + (nnLc + Pos));//x));
*psp = SPi;
}
}
}
}
}
// Tread loop run in this function
void C3DScreen::Run(void)
{
BOOL bRet;
MSG msg;
PeekMessage(&msg, NULL, 0, 0, PM_NOREMOVE);
CString str;
str.Format("GetCurrentThreadId(%d)", GetCurrentThreadId());
HANDLE hEv = CreateEvent(NULL, TRUE, FALSE, str);
SetEvent(hEv);
while( (bRet = GetMessage( &msg, NULL, 0, 0 )) != 0)
{
if(bRet == -1)
{
return;
}
else
{
m_cs.Lock();
switch(msg.message)
{
case sc_OnPaint:
if(m_bQuit)
continue;
{
thOnPaint();
}
break;
case sc_DeleteObject:
if(m_bQuit)
continue;
{
thDeleteObject((int)msg.wParam);
}
break;
case sc_TrigerPaintAlow:
if(m_bQuit)
continue;
{
thTrigerPaintAlow(msg.wParam, msg.lParam);
}
break;
case sc_ScreenToDC:
if(m_bQuit)
continue;
thScreenToDC(msg.wParam);
break;
case sc_Translate3Dto2D:
if(m_bQuit)
{
delete [](BYTE*)msg.lParam;
continue;
}
{
int bDoObTrans, xStart, xStopSize;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&bDoObTrans, params, sizeof(int));
params += sizeof(int);
memcpy(&xStart, params, sizeof(int));
params += sizeof(int);
memcpy(&xStopSize, params, sizeof(int));
thTranslate3Dto2D((C3DObject*)msg.wParam,
bDoObTrans, xStart, xStopSize);
delete [] p;
}
break;
case sc_ResetShift:
if(m_bQuit)
continue;
thResetShift((C3DObject*)msg.wParam);
break;
case sc_InitMatrix:
if(m_bQuit)
continue;
thInitMatrix((C3DObject*)msg.wParam);
case sc_Transform:
if(m_bQuit)
continue;
thTransform((C3DObject*)msg.wParam, msg.lParam?true:false);
break;
case sc_ResetTranslation:
if(m_bQuit)
continue;
thResetTranslation((C3DObject*)msg.wParam);
break;
case sc_PaintTansparent:
if(m_bQuit)
continue;
PaintTansparent();
break;
case sc_TurnShape:
{
if(m_bQuit)
{
delete [](BYTE*)msg.lParam;
continue;
}
double angle;
Axis ax;
int bLastTurn;
bool bBase;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&angle, params, sizeof(double));
params += sizeof(double);
memcpy(&ax, params, sizeof(Axis));
params += sizeof(Axis);
memcpy(&bLastTurn, params, sizeof(int));
params += sizeof(int);
memcpy(&bBase, params, sizeof(bool));
thTurnShape(angle, ax, bLastTurn, bBase,
(C3DObject*)msg.wParam);
delete [] p;
}
break;
case sc_CreatObjectPixselMap:
{
if(m_bQuit)
{
delete [](BYTE*)msg.lParam;
continue;
}
int cx, cy ,num;
unsigned long transColor;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&cx, params, sizeof(int));
params += sizeof(int);
memcpy(&cy, params, sizeof(int));
params += sizeof(int);
memcpy(&transColor, params, sizeof(unsigned long));
params += sizeof(unsigned long);
memcpy(&num, params, sizeof(int));
thCreatObjectPixselMap(cx, cy, transColor,
(C3DObject*)msg.wParam, num);
delete [] p;
}
break;
case sc_FillRect:
{
if(m_bQuit)
{
delete [](BYTE*)msg.lParam;
continue;
}
int x, y, cx, cy;
unsigned long color;
eFiillRectOp op;
CFillRectData data;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&x, params, sizeof(int));
params += sizeof(int);
memcpy(&y, params, sizeof(int));
params += sizeof(int);
memcpy(&cx, params, sizeof(int));
params += sizeof(int);
memcpy(&cy, params, sizeof(int));
params += sizeof(int);
memcpy(&color, params, sizeof(unsigned long));
params += sizeof(unsigned long);
memcpy(&op, params, sizeof(eFiillRectOp));
params += sizeof(eFiillRectOp);
memcpy(&data, params, sizeof(CFillRectData));
thFillRect(x, y, cx, cy, color,
(C3DObject*)msg.wParam, op, data);
delete [] p;
}
break;
case sc_TurnObjectCenter:
{
if(m_bQuit)
{
delete [](BYTE*)msg.lParam;
continue;
}
double angle;
Axis ax;
bool bBase;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&angle, params, sizeof(double));
params += sizeof(double);
memcpy(&ax, params, sizeof(Axis));
params += sizeof(Axis);
memcpy(&bBase, params, sizeof(bool));
thTurnObjectCenter(angle, ax, bBase, (C3DObject*)msg.wParam);
delete [] p;
}
break;
case sc_TurnLightPt:
{
if(m_bQuit)
{
delete [](BYTE*)msg.lParam;
continue;
}
double angle;
Axis ax;
bool bReset;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&angle, params, sizeof(double));
params += sizeof(double);
memcpy(&ax, params, sizeof(Axis));
params += sizeof(Axis);
memcpy(&bReset, params, sizeof(bool));
thTurnLightPt(angle, ax, bReset, (C3DObject*)msg.wParam);
delete [] p;
}
break;
case sc_TurnMatrix:
{
if(m_bQuit)
{
delete [](BYTE*)msg.lParam;
continue;
}
double angle;
Axis ax;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&angle, params, sizeof(double));
params += sizeof(double);
memcpy(&ax, params, sizeof(Axis));
thTurnMatrix(angle, ax, (C3DObject*)msg.wParam);
delete [] p;
}
break;
case sc_ShiftObjectCenter:
{
if(m_bQuit)
{
delete [](BYTE*)msg.lParam;
continue;
}
double angle;
Axis ax;
bool bBase;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&angle, params, sizeof(double));
params += sizeof(double);
memcpy(&ax, params, sizeof(Axis));
params += sizeof(Axis);
memcpy(&bBase, params, sizeof(bool));
thShiftObjectCenter(angle, ax, bBase, (C3DObject*)msg.wParam);
delete [] p;
}
break;
case sc_CreateSphereObject:
{
if(m_bQuit)
{
delete [](BYTE*)msg.lParam;
continue;
}
int diameter;
unsigned long color;
double circle;
double top;
double bottom;
double fine;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&diameter, params, sizeof(int));
params += sizeof(int);
memcpy(&color, params, sizeof(unsigned long));
params += sizeof(unsigned long);
memcpy(&circle, params, sizeof(double));
params += sizeof(double);
memcpy(&top, params, sizeof(double));
params += sizeof(double);
memcpy(&bottom, params, sizeof(double));
params += sizeof(double);
memcpy(&fine, params, sizeof(double));
thCreateSphereObject(diameter, color, circle, top, bottom, fine, (C3DObject*)msg.wParam);
delete [] p;
}
break;
case sc_CreateCylinderObject:
{
if(m_bQuit)
{
delete [](BYTE*)msg.lParam;
continue;
}
int topDiameter, bottomDiameter, height;
unsigned long color;
double circle;
double fine;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&topDiameter, params, sizeof(int));
params += sizeof(int);
memcpy(&bottomDiameter, params, sizeof(int));
params += sizeof(int);
memcpy(&height, params, sizeof(int));
params += sizeof(int);
memcpy(&color, params, sizeof(unsigned long));
params += sizeof(unsigned long);
memcpy(&circle, params, sizeof(double));
params += sizeof(double);
memcpy(&fine, params, sizeof(double));
thCreateCylinderObject(topDiameter, bottomDiameter, height, color, circle, fine, (C3DObject*)msg.wParam);
delete [] p;
}
break;
case sc_CreateFlatSpiralObject:
{
if(m_bQuit)
{
delete [](BYTE*)msg.lParam;
continue;
}
int width, height, space, minRadius;
double circle;
unsigned long col;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&width, params, sizeof(int));
params += sizeof(int);
memcpy(&height, params, sizeof(int));
params += sizeof(int);
memcpy(&space, params, sizeof(int));
params += sizeof(int);
memcpy(&minRadius, params, sizeof(int));
params += sizeof(unsigned long);
memcpy(&circle, params, sizeof(double));
params += sizeof(double);
memcpy(&col, params, sizeof(unsigned long));
thCreateFlatSpiralObject(width, height, space, minRadius, circle, col, (C3DObject*)msg.wParam);
delete [] p;
}
break;
case sc_CReateCircleLineObject:
{
if(m_bQuit)
{
delete [](BYTE*)msg.lParam;
continue;
}
int diameter, num;
double circle, fine;
unsigned long col;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&diameter, params, sizeof(int));
params += sizeof(int);
memcpy(&col, params, sizeof(unsigned long));
params += sizeof(int);
memcpy(&fine, params, sizeof(double));
params += sizeof(double);
memcpy(&circle, params, sizeof(double));
params += sizeof(double);
memcpy(&num, params, sizeof(int));
thCReateCircleLineObject(diameter, col, fine, circle, num, (C3DObject*)msg.wParam);
delete [] p;
}
break;
case sc_BitmapToObject:
{
if(m_bQuit)
{
CMyFBitmap* pBm;
COLORREF transperant;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&pBm, params, sizeof(CMyFBitmap*));
params += sizeof(CMyFBitmap*);
memcpy(&transperant, params, sizeof(COLORREF));
delete pBm;
delete [] p;
continue;
}
CMyFBitmap* pBm;
COLORREF transperant;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&pBm, params, sizeof(CMyFBitmap*));
params += sizeof(CMyFBitmap*);
memcpy(&transperant, params, sizeof(COLORREF));
thBitmapToObject(*pBm, transperant, (C3DObject*)msg.wParam);
delete pBm;
delete [] p;
}
break;
case sc_CreateFlatBmObj:
{
if(m_bQuit)
{
CMyFBitmap* pBm;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&pBm, params, sizeof(CMyFBitmap*));
delete pBm;
delete [] p;
continue;
}
CMyFBitmap* pBm;
COLORREF transperant;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&pBm, params, sizeof(CMyFBitmap*));
params += sizeof(CMyFBitmap*);
memcpy(&transperant, params, sizeof(COLORREF));
thCreateFlatBmObj(*pBm, transperant, (C3DObject*)msg.wParam);
delete pBm;
delete [] p;
}
break;
case sc_CreateSphereBmObj:
{
if(m_bQuit)
{
CMyFBitmap* pBm;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
params += sizeof(int);
memcpy(&pBm, params, sizeof(CMyFBitmap*));
delete pBm;
delete [] p;
continue;
}
int diameter;
CMyFBitmap* pBm;
double top;
double bottom;
unsigned long transperantcol;
BYTE* params = (BYTE*)msg.lParam;
BYTE* p = params;
memcpy(&diameter, params, sizeof(int));
params += sizeof(int);
memcpy(&pBm, params, sizeof(CMyFBitmap*));
params += sizeof(CMyFBitmap*);
memcpy(&top, params, sizeof(double));
params += sizeof(double);
memcpy(&bottom, params, sizeof(double));
params += sizeof(double);
memcpy(&transperantcol, params, sizeof(unsigned long));
thCreateSphereBmObj(diameter, *pBm, top, bottom, transperantcol, (C3DObject*)msg.wParam);
delete pBm;
delete [] p;
}
break;
}
m_cs.Unlock();
}
}
}
// Static function for running thread
unsigned int __stdcall C3DScreen::SRun(void* lpVoid)
{
C3DScreen* a = (C3DScreen*)lpVoid;
a->Run();
return 0;
}
// Create new object if not exist and set it curent
bool C3DScreen::BeginObject(int id)
{
C3DObject* ob = NULL;
if(m_3DObjectMap.Lookup(id, ob) == FALSE)
{
ob = new C3DObject(m_info);
m_3DObjectMap[id] = ob;
}
m_currentObject = ob;
return true;
}
// The transColor is an RBG and last byte is a transparency of the color 0 no transparency 100 full transparency.
bool C3DScreen::CreatObjectPixselMap(int cx, int cy, unsigned long transColor, int num)
{
if(m_currentObject == NULL)
return false;
BYTE* params = new BYTE[sizeof(int)*3 + sizeof(unsigned long)];
BYTE* p = params;
memcpy(p, &cx, sizeof(int));
p += sizeof(int);
memcpy(p, &cy, sizeof(int));
p += sizeof(int);
memcpy(p, &transColor, sizeof(unsigned long));
p += sizeof(unsigned long);
memcpy(p, &num, sizeof(unsigned long));
PostThreadMessage(m_uiThreadId, sc_CreatObjectPixselMap,
(WPARAM)m_currentObject, (LPARAM)params);
return true;
}
// filling color acording the position in the memory x y arrays
bool C3DScreen::FillRect(int x, int y, int cx, int cy, unsigned long color,
eFiillRectOp op, CFillRectData data)
{
if(m_currentObject == NULL)
return false;
BYTE* params = new BYTE[sizeof(int)*5 + sizeof(unsigned long) + sizeof(CFillRectData)];
BYTE* p = params;
memcpy(p, &x, sizeof(int));
p += sizeof(int);
memcpy(p, &y, sizeof(int));
p += sizeof(int);
memcpy(p, &cx, sizeof(int));
p += sizeof(int);
memcpy(p, &cy, sizeof(int));
p += sizeof(int);
memcpy(p, &color, sizeof(unsigned long));
p += sizeof(unsigned long);
memcpy(p, &op, sizeof(eFiillRectOp));
p += sizeof(eFiillRectOp);
memcpy(p, &data, sizeof(CFillRectData));
PostThreadMessage(m_uiThreadId, sc_FillRect,
(WPARAM)m_currentObject, (LPARAM)params);
return true;
}
void C3DScreen::ResetShift(void)
{
if(m_currentObject == NULL)
return ;
PostThreadMessage(m_uiThreadId, sc_ResetShift,
(WPARAM)m_currentObject, 0);
}
void C3DScreen::ResetTranslation(void)
{
if(m_currentObject == NULL)
return ;
PostThreadMessage(m_uiThreadId, sc_ResetTranslation,
(WPARAM)m_currentObject, 0);
}
void C3DScreen::ShiftObjectCenter(double shift, Axis ax, bool bBase)
{
if(m_currentObject == NULL)
return ;
BYTE* params = new BYTE[sizeof(double) + sizeof(Axis) + sizeof(bool)];
BYTE* p = params;
memcpy(p, &shift, sizeof(double));
p += sizeof(double);
memcpy(p, &ax, sizeof(Axis));
p += sizeof(Axis);
memcpy(p, &bBase, sizeof(bool));
PostThreadMessage(m_uiThreadId, sc_ShiftObjectCenter,
(WPARAM)m_currentObject, (LPARAM)params);
}
void C3DScreen::TurnObjectCenter(double angle, Axis ax, bool bBase)
{
if(m_currentObject == NULL)
return ;
BYTE* params = new BYTE[sizeof(double) + sizeof(Axis) + sizeof(bool)];
BYTE* p = params;
memcpy(p, &angle, sizeof(double));
p += sizeof(double);
memcpy(p, &ax, sizeof(Axis));
p += sizeof(Axis);
memcpy(p, &bBase, sizeof(bool));
PostThreadMessage(m_uiThreadId, sc_TurnObjectCenter,
(WPARAM)m_currentObject, (LPARAM)params);
}
bool C3DScreen::TurnShape(double angle, Axis ax, int bLastTurn,
bool bBase)
{
if(m_currentObject == NULL)
return false;
BYTE* params = new BYTE[sizeof(double) + sizeof(Axis) + sizeof(bool) + sizeof(int)];
BYTE* p = params;
memcpy(p, &angle, sizeof(double));
p += sizeof(double);
memcpy(p, &ax, sizeof(Axis));
p += sizeof(Axis);
memcpy(p, &bLastTurn, sizeof(int));
p += sizeof(int);
memcpy(p, &bBase, sizeof(bool));
PostThreadMessage(m_uiThreadId, sc_TurnShape,
(WPARAM)m_currentObject, (LPARAM)params);
return true;
}
bool C3DScreen::Translate3Dto2D(BOOL bDoObTrans,
int xStart, int xStopSize)
{
if(m_currentObject == NULL || m_info.cx == 0 || m_info.cy == 0
|| m_pPixelBuf == NULL)
return false;
BYTE* params = new BYTE[3 * sizeof(int)];
BYTE* p = params;
memcpy(p, &bDoObTrans, sizeof(int));
p += sizeof(int);
memcpy(p, &xStart, sizeof(int));
p += sizeof(int);
memcpy(p, &xStopSize, sizeof(int));
PostThreadMessage(m_uiThreadId, sc_Translate3Dto2D,
(WPARAM)m_currentObject, (LPARAM)params);
return true;
}
void C3DScreen::SetScreenWnd(CWnd* pWnd)
{
m_pWnd = pWnd;
}
bool C3DScreen::ScreenToDC(BOOL bPaintRefresh)
{
::PostThreadMessage(m_uiThreadId, sc_ScreenToDC, (WPARAM)bPaintRefresh,0);
return true;
}
bool C3DScreen::CreateScreenDC(void)
{
if(m_dibDC.GetSafeHdc())
return true;
CClientDC cdc(m_pWnd);
m_dibDC.CreateCompatibleDC(&cdc);
BITMAPINFO BMI;
memset(&BMI, 0, sizeof(BITMAPINFO));
// Fill in the header info.
BMI.bmiHeader.biSize = sizeof(BITMAPINFOHEADER);
BMI.bmiHeader.biWidth = m_info.cx;
BMI.bmiHeader.biHeight = m_info.cy;
BMI.bmiHeader.biPlanes = 1;
BMI.bmiHeader.biBitCount = 32 ; // Must use 32 bpps
BMI.bmiHeader.biCompression = BI_RGB ; // to use this flag.
m_hbm = CreateDIBSection( m_dibDC.GetSafeHdc(),
&BMI,
DIB_RGB_COLORS,
(VOID **) &m_pDibBits,
NULL,
0);
if(m_hbm == NULL)
{
m_dibDC.DeleteDC();
return false;
}
m_hbmOld = (HBITMAP)::SelectObject(m_dibDC.GetSafeHdc(), m_hbm);
CArray<RGBQUAD, RGBQUAD> arr;
arr.SetSize(m_info.cx);
RGBQUAD screenColor;
screenColor.rgbRed = GetRValue(m_tansparentColpr);
screenColor.rgbGreen = GetGValue(m_tansparentColpr);
screenColor.rgbBlue = GetBValue(m_tansparentColpr);
screenColor.rgbReserved = 0;
RGBQUAD* pSc = &screenColor;
RGBQUAD* pCol = arr.GetData();
int sizeRGBQUAD = sizeof(RGBQUAD);
for(register int x = 0; x < m_info.cx; ++x, ++pCol)
memcpy(pCol, pSc, sizeRGBQUAD);
pCol = arr.GetData();
int arrSize = sizeRGBQUAD * m_info.cx;
RGBQUAD* pDibBits = m_pDibBits;
for(register int y = 0; y < m_info.cy; ++y, pDibBits += m_info.cx)
memcpy(pDibBits, pCol, arrSize);
m_refreshDC.CreateMyCompatibleBitmap(&cdc,m_info.cx,m_info.cy,
m_tansparentColpr & 0xFFFFFF);
m_refreshDC.GetMyPaintDC();
return true;
}
void C3DScreen::DeleteGdiObjects(void)
{
if(m_dibDC.GetSafeHdc() && m_hbmOld)
{
::SelectObject(m_dibDC.GetSafeHdc(), m_hbmOld);
m_hbmOld = NULL;
m_dibDC.DeleteDC();
}
if(m_hbm)
{
::DeleteObject(m_hbm);
m_hbm = NULL;
}
}
void C3DScreen::thScreenToDC(BOOL bPaintRefresh)
{
if(m_pWnd == NULL || m_info.cx == 0 || m_info.cy == 0
|| m_pPixelBuf == NULL || m_dibDC.GetSafeHdc() == NULL
|| m_hbm == NULL || m_pDibBits == NULL)
return;
CRect rc = *((CRect*)m_pWnd->SendMessage(WM_GET_WND_RC));
// m_pWnd->GetClientRect(rc);
CClientDC dc(m_pWnd);
dc.SetMapMode(MM_ISOTROPIC);
dc.SetWindowExt(m_info.cx,m_info.cy);
int cx = rc.Width();
int cy = rc.Height();
//TRACE("cx = %d cy = %d\n", cx,cy);
dc.SetViewportExt(cx,cy);
dc.SetViewportOrg (m_edgeLeft, m_edgeTop) ;
dc.SetStretchBltMode(HALFTONE);
//CRect sa = GetDestinationRect();
RGBQUAD* pCol = NULL;
BYTE c[4] = {0,0,0,0};
POSITION pos = m_3DObjectMap.GetStartPosition();
int key = -1;
C3DObject* ob = NULL;
//if(bPaintRefresh)
// m_rasterRc.SetRect(m_info.cx, m_info.cy, 0, 0);
while(pos != NULL)
{
m_3DObjectMap.GetNextAssoc(pos, key, ob);
if(ob->m_bPause)
continue;
int nLeft = (int)(float)ob->m_leftScreen;// - pcx/2;
int nRight = (int)(float)ob->m_rightScreen;// - pcx/2;
int nTop = (int)(float)ob->m_topScreen ;//-pcy;
int nBottom = (int)(float)ob->m_bottomScreen;
int topPos = m_info.cy - nTop;
if(topPos < 0)
{
nTop += topPos;
}
int xcorection = 0;
if(nLeft < 0)
{
xcorection = -nLeft;
nLeft = 0;
}
if(nRight > m_info.cx)
nRight = m_info.cx;
int pcy = nTop - nBottom;
if(pcy <= 1)
continue;
int pcx = nRight - nLeft;
if(pcx <= 1)
continue;
int cymintop = m_info.cy - nTop;
int cyminbottom = m_info.cy - nBottom;
m_rasterRc.left = min(m_rasterRc.left, nLeft - 1);
m_rasterRc.right = max(m_rasterRc.right, nRight + 1);
m_rasterRc.top = min(m_rasterRc.top, cymintop - 1);
m_rasterRc.bottom = max(m_rasterRc.bottom, cyminbottom+1);
for(int y = 0; y < pcy && y < nTop; ++y)
{
if((cymintop + y) <= 0)
continue;
for(register int x = 0; x < pcx; ++x)
{
if((nLeft + x) < 0)
continue;
CScreenPixsel* psp = m_pPixelBuf +
((cymintop + y) * m_info.cx + (nLeft + x));
*((DWORD*)c) = psp->color;
if(c[3] == 100)
continue;
pCol = m_pDibBits +
((nTop - y) *
m_info.cx + (nLeft + x));
pCol->rgbRed = c[0];
pCol->rgbGreen = c[1];
pCol->rgbBlue = c[2];
}
}
}
if(bPaintRefresh)
{
CDC* pDC = m_refreshDC.GetMyPaintDC();
pDC->BitBlt(m_rasterRc.left,m_rasterRc.top,
m_rasterRc.Width(),m_rasterRc.Height(),
&m_dibDC,
m_rasterRc.left,m_rasterRc.top,SRCCOPY);
}
else
{
dc.BitBlt(m_rasterRc.left,
m_rasterRc.top,m_rasterRc.Width(),
m_rasterRc.Height()
,&m_dibDC,m_rasterRc.left,
m_rasterRc.top, SRCCOPY);
// m_rasterRc.InflateRect(3,3);
}
}
void C3DScreen::thTranslate3Dto2D(C3DObject* ob, BOOL bDoObTrans,
int xStart, int xStopSize)
{
if(xStopSize == -2)
{
ob->m_bPause = true;
return;
}
else
{
ob->m_bPause = false;
}
bool res = true;
if(bDoObTrans)
res = ob->Translate3Dto2D(xStart, xStopSize);
tdPixelRowArr& pixArr = ob->m_2DScreen;
tdPixselArr** pPixData = pixArr.GetData();
int nLeft = (int)(float)ob->m_leftScreen;
int nTop = (int)(float)ob->m_topScreen ;
// int nRight = (int)(float)ob->m_rightScreen;
int nBottom = (int)(float)ob->m_bottomScreen ;
int sizePosCount = ob->m_sizePosArr.GetCount();
int *pSizePos = ob->m_sizePosArr.GetData();
int *pPos = ob->m_posArr.GetData();
int topPos = m_info.cy - nTop;
if(topPos < 0)
{
nTop += topPos;
pPixData -= topPos;
pPos -= topPos * sizePosCount;
pSizePos -= topPos;
}
int pcy = nTop - nBottom;
if(pcy <= 1)
return;
int cymintop = m_info.cy - nTop;
// the x y of m_2DScreen to world x y
BYTE color[4] = {0,0,0,0};
BYTE c[4] = {0,0,0,0};
for(int y = 0; y < pcy && y < nTop; ++y, ++pPixData,
++pSizePos, pPos += sizePosCount)
{
int SizePos = *pSizePos;
// CScreenPixsel* sp = (*pPixData)->GetData() + xcorection;
for(register int x = 0; x < SizePos/*pcx*/; ++x)//, sp++)
{
int Pos = *(pPos + x);
if((nLeft + Pos) < 0 || (nLeft + Pos) >= m_info.cx)
continue;
CScreenPixsel* sp = (*pPixData)->GetData() + Pos;
// if(sp->lastZ == clean_z)//(nLeft + x) < 0)
// continue;
*((DWORD*)color) = sp->color;
CScreenPixsel* psp = m_pPixelBuf +
((cymintop + y) * m_info.cx + (nLeft + Pos));//x));
*((DWORD*)c) = psp->color;
// if sp->lastZ far then psp->lastZ do not paint it.
bool bNear = sp->lastZ > psp->lastZ;
if(bNear )
continue;
psp->lastZ = sp->lastZ;
if(psp->color == sp->color)
continue;
bool bc3NotTransparent = c[3] == 0;
if(c[3] == 100 || (color[3] == 0 && bc3NotTransparent))//c[3] == 100
{
psp->color = sp->color;
}
else //if(bNear)
{
//2 Transparents
int color3 = 100 - color[3];
int c3 = color[3];//100 - c[3];
c[0] = (c[0] * c3 + color[0] * color3)
/ (c3 + color3);
c[1] = (c[1] * c3 + color[1] * color3)
/ (c3 + color3);
c[2] = (c[2] * c3 + color[2] * color3)
/ (c3 + color3);
// c[3] = (c[3] * c3 + color[3] * color3)
// / (c3 + color3);
psp->color = *((DWORD*)c);
}
}
}
}
void C3DScreen::thTurnShape(double angle, Axis ax, int bLastTurn,
bool bBase,
C3DObject* ob)
{
if(bBase)
ob->TurnBaseShape(angle, ax);
else
ob->TurnShape(angle, ax, bLastTurn);
}
void C3DScreen::thTurnObjectCenter(double angle, Axis ax, bool bBase, C3DObject* ob)
{
ob->TurnObjectCenter(angle, ax, bBase);
}
void C3DScreen::thShiftObjectCenter(double angle, Axis ax, bool bBase, C3DObject* ob)
{
ob->ShiftObjectCenter(angle, ax, bBase);
}
void C3DScreen::thResetShift(C3DObject* ob)
{
ob->ResetShift();
}
void C3DScreen::thResetTranslation(C3DObject* ob)
{
// PaintTansparent();
ob->ResetTranslation();
}
void C3DScreen::thBeginObject(int id)
{
}
void C3DScreen::thCreatObjectPixselMap(int cx, int cy,
unsigned long transColor,
C3DObject* ob,
int num)
{
ob->CreatObjectPixselMap(cx, cy, transColor, num);
}
void C3DScreen::thFillRect(int x, int y, int cx, int cy, unsigned long color, C3DObject* ob,
eFiillRectOp op, CFillRectData data)
{
ob->FillRect(x, y, cx, cy, color, op, data);
}
// 3 <= diameter, 0 < circle <= 360, -90 <= bottom < top <= 90
bool C3DScreen::CreateSphereObject(int diameter, unsigned long color,
double circle, double top,
double bottom, double fine)
{
if(m_currentObject == NULL)
return false;
BYTE* params = new BYTE[sizeof(int) + sizeof(unsigned long) + 4 * sizeof(double)];
BYTE* p = params;
memcpy(p, &diameter, sizeof(int));
p += sizeof(int);
memcpy(p, &color, sizeof(unsigned long));
p += sizeof(unsigned long);
memcpy(p, &circle, sizeof(double));
p += sizeof(double);
memcpy(p, &top, sizeof(double));
p += sizeof(double);
memcpy(p, &bottom, sizeof(double));
p += sizeof(double);
memcpy(p, &fine, sizeof(double));
PostThreadMessage(m_uiThreadId, sc_CreateSphereObject,
(WPARAM)m_currentObject, (LPARAM)params);
return true;
}
void C3DScreen::thCreateSphereObject(int diameter, unsigned long color,
double circle, double top, double bottom, double fine, C3DObject* ob)
{
ob->CreateSphereObject(diameter, color, circle, top, bottom, fine);
}
void C3DScreen::ClearScreen(void)
{
PostThreadMessage(m_uiThreadId, sc_PaintTansparent,
0, 0);
}
bool C3DScreen::CreateCylinderObject(int topDiameter,
int bottomDiameter,
int height,
unsigned long color,
double circle,
double fine)
{
if(m_currentObject == NULL)
return false;
BYTE* params = new BYTE[3 * sizeof(int) + sizeof(unsigned long) + sizeof(double) * 2];
BYTE* p = params;
memcpy(p, &topDiameter, sizeof(int));
p += sizeof(int);
memcpy(p, &bottomDiameter, sizeof(int));
p += sizeof(int);
memcpy(p, &height, sizeof(int));
p += sizeof(int);
memcpy(p, &color, sizeof(unsigned long));
p += sizeof(unsigned long);
memcpy(p, &circle, sizeof(double));
p += sizeof(double);
memcpy(p, &fine, sizeof(double));
PostThreadMessage(m_uiThreadId, sc_CreateCylinderObject,
(WPARAM)m_currentObject, (LPARAM)params);
return true;
}
void C3DScreen::thCreateCylinderObject(int topDiameter, int bottomDiameter,
int height, unsigned long color,
double circle, double fine, C3DObject* ob)
{
ob->CreateCylinderObject(topDiameter, bottomDiameter, height, color, circle, fine);
}
//CRect C3DScreen::GetDestinationRect(void)
//{
// double left = (double)cs_cx * m_edgeLeft;
// double top = (double)cs_cy * m_edgeTop;
// double reight = (double)cs_cx -
// ((double)cs_cx * m_edgeReight);
// double bottom = (double)cs_cy -
// ((double)cs_cy * m_edgeBottom);
// int nleft = (int)(float)left;
// int ntop = (int)(float)top;
// int nreight = (int)(float)reight;
// int nbottom = (int)(float)bottom;
// CRect windArea(nleft, ntop, nreight, nbottom);
//
// // best fiting screen in window
// float windRelation = (float)windArea.Width()
// / (float)windArea.Height();
// float psRelation = (float)m_info.cx / (float)m_info.cy;
// float mulRlation = 0.0f;
// bool bWndGt = windRelation > psRelation;
// if(bWndGt)
// {
// mulRlation = (float)windArea.Height()
// / (float)m_info.cy;
// }
// else
// {
// mulRlation = (float)windArea.Width()
// / (float)m_info.cx;
// }
// float gt = bWndGt?(float)windArea.Width():(float)windArea.Height();
// float space = bWndGt?(float)m_info.cx : (float)m_info.cy;
// space *= mulRlation;
// space = (gt - space) / 2.0f;
// CRect sa = windArea;
// if(bWndGt)
// sa.DeflateRect((int)space, 0);
// else
// sa.DeflateRect(0, (int)space);
// ////////
// return sa;
//}
void C3DScreen::OnPaint(void)
{
// PostThreadMessage(m_uiThreadId, sc_OnPaint,
// 0,0);
if(m_bQuit || m_bNotPaint)
return;
//m_cs.Lock();
thOnPaint();
//m_cs.Unlock();
}
void C3DScreen::thOnPaint(void)
{
CClientDC dc(m_pWnd);
dc.SetMapMode(MM_ISOTROPIC);
dc.SetWindowExt(m_info.cx,m_info.cy);
CRect rc = *((CRect*)m_pWnd->SendMessage(WM_GET_WND_RC));
// m_pWnd->GetClientRect(rc);
int cx = rc.Width();
int cy = rc.Height();
//TRACE("cx = %d cy = %d\n", cx,cy);
dc.SetViewportExt(cx,cy);
dc.SetViewportOrg (m_edgeLeft, m_edgeTop) ;
dc.SetStretchBltMode(HALFTONE);
//CRect sa = GetDestinationRect();
dc.BitBlt(0,0,m_info.cx,m_info.cy
,&m_dibDC,0,0,SRCCOPY);
//CRect sa = GetDestinationRect();
//dc.StretchBlt(sa.left,sa.top,sa.Width(),sa.Height()
// ,&m_dibDC,0,0,m_info.cx,m_info.cy,SRCCOPY);
}
void C3DScreen::CopyRefreshToDib(void)
{
m_dibDC.BitBlt(0,0,m_info.cx,m_info.cy,m_refreshDC,0,0,SRCCOPY);
}
void C3DScreen::BitmapToObject(CMyFBitmap& bm, COLORREF transperant)
{
if(m_currentObject == NULL)
return ;
CMyFBitmap* pBm = new CMyFBitmap(bm);
BYTE* params = new BYTE[sizeof(CMyFBitmap*) + sizeof(COLORREF)];
BYTE* p = params;
memcpy(p, &pBm, sizeof(CMyFBitmap*));
p += sizeof(CMyFBitmap*);
memcpy(p, &transperant, sizeof(COLORREF));
PostThreadMessage(m_uiThreadId, sc_BitmapToObject,
(WPARAM)m_currentObject, (LPARAM)params);
}
void C3DScreen::thBitmapToObject(CMyFBitmap& bm, COLORREF transperant, C3DObject* ob)
{
td3DRowsArr& arr = ob->m_3DRowsArr;
int sizey = arr.GetCount() - 1;
td3DPixselColumnArr** pData = arr.GetData();
int sizex = (*pData)->GetCount() - 1;
CBase3DObjectPixsel* pPixsel = NULL;//(*pData)->GetData();
CMyFBitmap objBm;
if(bm.m_height == sizey && bm.m_width == sizex)
{
objBm = bm;
}
else
{
objBm.CreateMyCompatibleBitmap(bm, sizex, sizey);
CDC* pDC = objBm.operator CDC *();
pDC->SetStretchBltMode(HALFTONE);
bm.StrechDraw(objBm,0,0,sizex, sizey);
}
CDC* pDC = objBm.operator CDC *();
COLORREF col = 0;
COLORREF tran = (COLORREF)100 << 24;
COLORREF colTran = transperant & 0XFF000000;
transperant &= 0XFFFFFF;
for(int y = 0; y < sizey; ++y, ++pData)
{
pPixsel = (*pData)->GetData();
for(int x = 0; x < sizex; ++x, ++pPixsel)
{
col = pDC->GetPixel(x,y);
if(col == transperant)
{
col |= tran;
pPixsel->color = col;
}
else
pPixsel->color = col | colTran;
}
}
}
void C3DScreen::TurnPoint(C3DPoint& p, double angle, Axis ax)
{
angle *= C3DObject::m_degtorad;
CDPoint yx(cos(angle),sin(angle));
C3DObject::Turn(p,yx,ax);
}
bool C3DScreen::CreateFlatSpiralObject(int width,
int height,
int space,
int minRadius,
double circle,
unsigned long col)
{
if(m_currentObject == NULL)
return false;
BYTE* params = new BYTE[4 * sizeof(int) + sizeof(unsigned long) + sizeof(double)];
BYTE* p = params;
memcpy(p, &width, sizeof(int));
p += sizeof(int);
memcpy(p, &height, sizeof(int));
p += sizeof(int);
memcpy(p, &space, sizeof(int));
p += sizeof(int);
memcpy(p, &minRadius, sizeof(int));
p += sizeof(int);
memcpy(p, &circle, sizeof(double));
p += sizeof(double);
memcpy(p, &col, sizeof(unsigned long));
PostThreadMessage(m_uiThreadId, sc_CreateFlatSpiralObject,
(WPARAM)m_currentObject, (LPARAM)params);
return true;
}
void C3DScreen::thCreateFlatSpiralObject(int width, int height, int space, int minRadius, double circle, unsigned long col, C3DObject* ob)
{
ob->CreateFlatSpiralObject(width, height, space, minRadius, circle, col);
}
void C3DScreen::thCReateCircleLineObject(int diameter, unsigned long color, double fine, double circle, int num,C3DObject* ob)
{
ob->CReateCircleLineObject(diameter, color, fine, circle, num);
}
void C3DScreen::CReateCircleLineObject(int diameter,
unsigned long color,
double fine,
double circle,
int num)
{
if(m_currentObject == NULL)
return;
BYTE* params = new BYTE[sizeof(int) * 2 + sizeof(unsigned long) + sizeof(double) * 2];
BYTE* p = params;
memcpy(p, &diameter, sizeof(int));
p += sizeof(int);
memcpy(p, &color, sizeof(unsigned long));
p += sizeof(unsigned long);
memcpy(p, &fine, sizeof(double));
p += sizeof(double);
memcpy(p, &circle, sizeof(double));
p += sizeof(double);
memcpy(p, &num, sizeof(int));
PostThreadMessage(m_uiThreadId, sc_CReateCircleLineObject,
(WPARAM)m_currentObject, (LPARAM)params);
}
bool C3DScreen::DeleteObject(int id)
{
PostThreadMessage(m_uiThreadId, sc_DeleteObject,
(WPARAM)id, 0);
return false;
}
bool C3DScreen::thDeleteObject(int id)
{
C3DObject* ob = NULL;
if(m_3DObjectMap.Lookup(id, ob) == TRUE)
{
delete ob;
m_3DObjectMap.RemoveKey(id);
}
m_currentObject = NULL;
return true;
}
void C3DScreen::NoPaint(void)
{
m_bNotPaint = true;
}
void C3DScreen::TrigerPaintAlow(WPARAM wParam, LPARAM lParam)
{
PostThreadMessage(m_uiThreadId, sc_TrigerPaintAlow,
wParam, lParam);
}
void C3DScreen::thTrigerPaintAlow(WPARAM wParam, LPARAM lParam)
{
m_bNotPaint = false;
m_pWnd->PostMessageA(WM_ON_TRIGER_MSG, wParam, lParam);
}
void C3DScreen::CopyRefresh(CRect& rc)
{
//m_cs.Lock();
m_dibDC.FillSolidRect(rc,0);
m_dibDC.BitBlt(rc.left,rc.top,rc.Width(),
rc.Height(),m_refreshDC,rc.left,rc.top,SRCCOPY);
//m_cs.Unlock();
}
double C3DScreen::GetTransformVector(void)
{
return m_info.TransformVector;
}
double C3DScreen::GetMiddleZ(void)
{
return m_info.middleSpace.z;
}
void C3DScreen::CreateSphereBmObj(int diameter, CMyFBitmap& bm,
double top, double bottom,
unsigned long transperantcol)
{
if(m_currentObject == NULL)
return;
CMyFBitmap* pBm = new CMyFBitmap(bm);
BYTE* params = new BYTE[sizeof(CMyFBitmap*) + sizeof(int) + sizeof(unsigned long) + sizeof(double) * 2];
BYTE* p = params;
memcpy(p, &diameter, sizeof(int));
p += sizeof(int);
memcpy(p, &pBm, sizeof(CMyFBitmap*));
p += sizeof(CMyFBitmap*);
memcpy(p, &top, sizeof(double));
p += sizeof(double);
memcpy(p, &bottom, sizeof(double));
p += sizeof(double);
memcpy(p, &transperantcol, sizeof(unsigned long));
PostThreadMessage(m_uiThreadId, sc_CreateSphereBmObj,
(WPARAM)m_currentObject, (LPARAM)params);
}
void C3DScreen::thCreateSphereBmObj(int diameter, CMyFBitmap& bm,
double top, double bottom,
unsigned long transperantcol, C3DObject* ob)
{
ob->CreateSphereBmObj(diameter,bm,top,bottom,transperantcol);
}
void C3DScreen::CreateFlatBmObj(CMyFBitmap& bm, unsigned long transperant)
{
if(m_currentObject == NULL)
return ;
CMyFBitmap* pBm = new CMyFBitmap(bm);
BYTE* params = new BYTE[sizeof(CMyFBitmap*) + sizeof(COLORREF)];
BYTE* p = params;
memcpy(p, &pBm, sizeof(CMyFBitmap*));
p += sizeof(CMyFBitmap*);
memcpy(p, &transperant, sizeof(COLORREF));
PostThreadMessage(m_uiThreadId, sc_CreateFlatBmObj,
(WPARAM)m_currentObject, (LPARAM)params);
}
void C3DScreen::thCreateFlatBmObj(CMyFBitmap& bm, unsigned long transperant, C3DObject* ob)
{
ob->CreateFlatBmObj(bm, transperant);
}
void C3DScreen::TurnLightPt(double angle, Axis ax, bool bReset)
{
if(m_currentObject == NULL)
return ;
BYTE* params = new BYTE[sizeof(double) + sizeof(Axis) + sizeof(bool)];
BYTE* p = params;
memcpy(p, &angle, sizeof(double));
p += sizeof(double);
memcpy(p, &ax, sizeof(Axis));
p += sizeof(Axis);
memcpy(p, &bReset, sizeof(bool));
PostThreadMessage(m_uiThreadId, sc_TurnLightPt,
(WPARAM)m_currentObject, (LPARAM)params);
}
void C3DScreen::thTurnLightPt(double angle, Axis ax, bool bReset, C3DObject* ob)
{
ob->TurnLightPt(angle, ax, bReset);
}
void C3DScreen::thInitMatrix(C3DObject* ob)
{
ob->m_matrix.Init();
}
void C3DScreen::InitMatrix(void)
{
if(m_currentObject == NULL)
return ;
PostThreadMessage(m_uiThreadId, sc_InitMatrix,
(WPARAM)m_currentObject, 0);
}
void C3DScreen::TurnMatrix(double angle, Axis ax)
{
if(m_currentObject == NULL)
return ;
BYTE* params = new BYTE[sizeof(double) + sizeof(Axis)];
BYTE* p = params;
memcpy(p, &angle, sizeof(double));
p += sizeof(double);
memcpy(p, &ax, sizeof(Axis));
PostThreadMessage(m_uiThreadId, sc_TurnMatrix,
(WPARAM)m_currentObject, (LPARAM)params);
}
void C3DScreen::thTurnMatrix(double angle, Axis ax, C3DObject* ob)
{
CMatrix m1, tm;
tm = ob->m_matrix;
switch(ax)
{
case axis_x:
m1.RotX(angle);
break;
case axis_y:
m1.RotY(angle);
break;
case axis_z:
m1.RotZ(angle);
break;
case axis_s:
ob->m_matrix.Scale(angle);
return;
}
ob->m_matrix.Mul(m1, tm);
}
void C3DScreen::Transform(bool bWorldTranslation)
{
if(m_currentObject == NULL)
return ;
PostThreadMessage(m_uiThreadId, sc_Transform,
(WPARAM)m_currentObject, (LPARAM)bWorldTranslation);
}
void C3DScreen::thTransform(C3DObject* ob, bool bWorldTranslation)
{
ob->Transform(bWorldTranslation);
}
| [
"hillelskolnik@gmail.com"
] | hillelskolnik@gmail.com |
2a1519efd7787b652aee64f6bd6f74c5587911e6 | 3b1d08997d0dc9c444f2bdaaab55a8606c60d332 | /IOCMain/BestWrap/BT3Debug.h | cf868b82fcae221e0d845c21f95689bed51819cd | [] | no_license | zjsaisi/sm2000 | 8303ece373516c871694d382bb3daef9f5129d1a | 0fa74cdb7566621162e1845dd4558723182a49ac | refs/heads/master | 2020-04-16T09:22:12.797424 | 2019-01-23T10:31:07 | 2019-01-23T10:31:07 | 165,461,667 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 993 | h | // BT3Debug.h: interface for the CBT3Debug class.
//
//////////////////////////////////////////////////////////////////////
/*
* Filename: BT3Debug.h
* Author: Zheng Miao
* All rights reserved.
* RCS: $Header: BT3Debug.h 1.1 2007/12/06 11:41:04PST Zheng Miao (zmiao) Exp $
* $Revision: 1.1 $
*/
#if !defined(AFX_BT3DEBUG_H__0CEA391E_125F_4336_9F89_FB958319F7EB__INCLUDED_)
#define AFX_BT3DEBUG_H__0CEA391E_125F_4336_9F89_FB958319F7EB__INCLUDED_
#include "CodeOpt.h"
#include "DataType.h"
#include "ConstDef.h"
class Ccomm;
class CBT3Debug
{
protected:
CBT3Debug();
virtual ~CBT3Debug();
public:
void PrintBT3Status(unsigned long *param, Ccomm *pComm);
static CBT3Debug *s_pBT3Debug;
static void Create(void);
private:
void PrintMpll(Ccomm *pComm);
void PrintSpanFifo(Ccomm *pComm, struct Span_Meas_Data *pData);
void Print(const char *str);
void PrintBT3Help(void);
Ccomm *m_port;
};
#endif // !defined(AFX_BT3DEBUG_H__0CEA391E_125F_4336_9F89_FB958319F7EB__INCLUDED_)
| [
"you@example.com"
] | you@example.com |
1e97fd5242acc23155a8545c5875a8d74b4079f5 | 777fc6f8debd99dcc1b459e80c56846cfd55a61b | /Lab_5/main_test.cpp | 7b58d246c222aae1dc57060584fb720ab38d7dc9 | [] | no_license | ChaseOdgers/Data-Structures | c45131872f710892a5bc2303367e94d3b26f7c56 | 4d6b7d84cbc312f4f817dc7ad29031245732884f | refs/heads/main | 2023-01-22T14:22:26.792803 | 2020-11-10T04:50:47 | 2020-11-10T04:50:47 | 309,506,972 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,857 | cpp | //Main Program to test all Doubly Linked list methods
#include <iostream>
#include <string>
#include <fstream>
#include <vector>
#include <stdexcept>
#include "myHashTable.hpp"
using namespace std;
int main(int argc, char* argv[])
{
if(argc != 3)
{
std::cout << "You have to provide one test instance file and output file name to run the test main!\n";
return 0;
}
//File Intiallization for input and output files
ifstream inFile;
ifstream inFile1;
inFile.open(argv[1]);
ofstream outfile (argv[2]);
//Open input and out file and sstart with hash table methods
if(inFile.is_open() and outfile.is_open())
{
int num;
//Hahs table object with <int> as templete type
myHashTable<int> hash;
myDlList<int> dll;
while(!inFile.eof())
{
inFile >> num;
/**
* @Pre A new instance has been read from input file
* @Post Add the input instance from input file into Hah table using insert
*/
hash.insert(num);
}
/**
* @Pre The Hash table was built
* @Post Display all the elements of hash table using DlList iterators
*/
myDlList<int>::iterator i;
for (int k=0; k< hash.hashsize() ;++k){
outfile << k << ": ";
for (i= hash.getiteratorbegin(k); i != hash.getiteratorend(k); ++i)
outfile <<"-->" << *i;
outfile << "\n";
}
//OPen a new file to get some elements from same instance file
inFile1.open(argv[1]);
int count=0;
num=0;
/**
* @Pre Hash table as input
* @Check first 20 elements from input files are present in hash table
*/
inFile1.open(argv[1]);
count=0;
num=0;
while(!inFile1.eof() and (count !=20))
{
inFile1 >> num;
if(hash.contains(num))
outfile <<"1"<<"\n";
else
outfile<<"0"<<"\n";
count=count+1;
}
inFile1.close();
/**
* @Pre Hash table as input
* @Remove first 20 elements from input files from hash table
*/
inFile1.open(argv[1]);
count=0;
num=0;
while(!inFile1.eof() and (count !=20))
{
inFile1 >> num;
if(hash.remove(num))
outfile <<"1"<<"\n";
else
outfile<<"0"<<"\n";
count=count+1;
}
inFile1.close();
/**
* @Pre Hash table as input
* @Check first 20 elements from input files are present in hash table
*/
inFile1.open(argv[1]);
count=0;
num=0;
while(!inFile1.eof() and (count !=20))
{
inFile1 >> num;
if(hash.contains(num))
outfile <<"1"<<"\n";
else
outfile<<"0"<<"\n";
count=count+1;
}
inFile1.close();
/**
* @Pre Hash table as input
* @Post Make hash table empty
*/
hash.makeEmpty();
}
else
{
cout << "The instance.txt file cannot be opened";
}
inFile.close();
outfile.close();
}
| [
"chaseodgers@ku.edu"
] | chaseodgers@ku.edu |
f2044ee62959d1507491b6d2ab5d59fa0c642da0 | ee6c236ba07ddd2f1328e38f3b0a00c3eaf3a38a | /Code/Client/FindingTreasure_Test_PhysicalCollision_20170326/Player.cpp | e721e17fc2a129b5854ff23b9a28941c7d7c236e | [] | no_license | GreeeeeShot/Graduation-Work | b01b4662813a1a25a0ed82f0a43af92c38801bbc | 53e2c000241b71da222d065d0697ec79b0ded65c | refs/heads/master | 2021-01-11T01:55:47.025089 | 2017-10-18T10:25:06 | 2017-10-18T10:25:06 | 70,653,275 | 0 | 1 | null | null | null | null | UHC | C++ | false | false | 13,239 | cpp | #include "stdafx.h"
#include "Player.h"
#include "CameraOperator.h"
#include "PhysicalCollision.h"
CPlayer::CPlayer()
{
// m_pCamera = NULL;
//InitCameraOperator();
m_d3dxvMoveDir = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
m_d3dxvVelocity = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
m_fDamping = PLAYER_DAMPING_VALUE;
}
CPlayer::~CPlayer()
{
// if (m_pCamera) delete m_pCamera;
}
void CPlayer::InitCameraOperator(void)
{
m_CameraOperator.InitCameraOperator(this);
}
//void CPlayer::GoForward(float fTimeElapsed)
//{
// Moving(0.01f * m_CameraOperator.GetLook());
// m_CameraOperator.MoveCameraOperator(0.01f * m_CameraOperator.GetLook());
//}
//
//void CPlayer::GoBack(float fTimeElapsed)
//{
// Moving(-0.01f * m_CameraOperator.GetLook());
// m_CameraOperator.MoveCameraOperator(-0.01f * m_CameraOperator.GetLook());
//}
//
//void CPlayer::GoRight(float fTimeElapsed)
//{
// Moving(0.01f * m_CameraOperator.GetRight());
// m_CameraOperator.MoveCameraOperator(0.01f * m_CameraOperator.GetRight());
//}
//
//void CPlayer::GoLeft(float fTimeElapsed)
//{
// Moving(-0.01f * m_CameraOperator.GetRight());
// m_CameraOperator.MoveCameraOperator(-0.01f * m_CameraOperator.GetRight());
//}
//void CPlayer::MovingByCamera(D3DXVECTOR3 d3dxvDirSum, float fTimeElapsed)
//{
// if (-0.01 < d3dxvDirSum.x && d3dxvDirSum.x <0.01f && -0.01 < d3dxvDirSum.y && d3dxvDirSum.y <0.01f && -0.01 < d3dxvDirSum.z && d3dxvDirSum.z <0.01f) return;
//
// D3DXVECTOR3 d3dxvCross;
// D3DXVec3Cross(&d3dxvCross, &D3DXVECTOR3(0.0f, 0.0f, 1.0f), &(m_CameraOperator.GetLook()));
// D3DXVec3Normalize(&d3dxvCross, &d3dxvCross);
//
// float fDot = D3DXVec3Dot(&D3DXVECTOR3(0.0f, 0.0f, 1.0f), &(m_CameraOperator.GetLook()));
// float fRotationAngle = D3DXToDegree(acosf(fDot));
// fRotationAngle = d3dxvCross.y > 0.0f ? fRotationAngle : -fRotationAngle; // Degree
//
// D3DXMATRIX d3dxmtxRotation;
// D3DXMatrixRotationAxis(&d3dxmtxRotation, &d3dxvCross, D3DXToRadian(fRotationAngle));
//
// D3DXVec3TransformNormal(&d3dxvDirSum, &d3dxvDirSum, &d3dxmtxRotation);
//
// D3DXVec3Cross(&d3dxvCross, &GetLook(), &d3dxvDirSum);
// D3DXVec3Normalize(&d3dxvCross, &d3dxvCross);
//
// fDot = D3DXVec3Dot(&GetLook(), &d3dxvDirSum);
// fRotationAngle = D3DXToDegree(acosf(fDot));
// fRotationAngle = d3dxvCross.y > 0.0f ? fRotationAngle : -fRotationAngle; // Degree
//
// // RotateWorldY(fRotationAngle, fTimeElapsed);
// Moving(0.01f * d3dxvDirSum);
// m_CameraOperator.MoveCameraOperator(0.01f * d3dxvDirSum);
//}
void CPlayer::RotateMoveDir(void)
{
if (m_d3dxvMoveDir.x == 0.0f && m_d3dxvMoveDir.y == 0.0f && m_d3dxvMoveDir.z == 0.0f) return;
/*printf("Moving Dir : (%lf, %lf, %lf) \n", d3dxvMovingDir.x, d3dxvMovingDir.y, d3dxvMovingDir.z);*/
//D3DXVec3Normalize(&m_d3dxvMoveDir, &m_d3dxvMoveDir);
D3DXMATRIX mtxRotate;
// ํ์ ์ถ์ ๊ตฌํ๋ค.
D3DXVECTOR3 d3dxvCross;
D3DXVec3Cross(&d3dxvCross, &D3DXVECTOR3(0.0f, 0.0f, 1.0f), &m_CameraOperator.GetLook());
//D3DXVec3Normalize(&d3dxvCross, &d3dxvCross);
// ํ์ ๋์ ๊ตฌํ๋ค.
float fDot = D3DXVec3Dot(&D3DXVECTOR3(0.0f, 0.0f, 1.0f), &m_CameraOperator.GetLook());
if (fDot >= 1.0f) fDot = 1.0f;
else if (fDot <= -1.0f) fDot = -1.0f;
float fRotationRadianForProofreading = acosf(fDot);
fRotationRadianForProofreading = d3dxvCross.y > 0.0f ? fRotationRadianForProofreading : -fRotationRadianForProofreading;
D3DXMatrixRotationAxis(&mtxRotate, &D3DXVECTOR3(0.0f, 1.0f, 0.0f), fRotationRadianForProofreading);
D3DXVec3TransformNormal(&m_d3dxvMoveDir, &m_d3dxvMoveDir, &mtxRotate); // ๋ณด์ ๋ ์์น ๋ฒกํฐ
D3DXVec3Normalize(&m_d3dxvMoveDir, &m_d3dxvMoveDir);
D3DXVec3Cross(&d3dxvCross, &GetLook(), &m_d3dxvMoveDir);
//D3DXVec3Normalize(&d3dxvCross, &d3dxvCross);
fDot = D3DXVec3Dot(&GetLook(), &m_d3dxvMoveDir);
/*printf("Player GetLook : (%f, %f, %f), Length : %f \n", GetLook().x, GetLook().y, GetLook().z, D3DXVec3Length(&GetLook()));
printf("d3dxvMoveIdr : (%f, %f, %f), Length : %f \n", m_d3dxvMoveDir.x, m_d3dxvMoveDir.y, m_d3dxvMoveDir.z, D3DXVec3Length(&m_d3dxvMoveDir));*/
fRotationRadianForProofreading = acosf(fDot);
/*printf("fDot : %f \n", fDot);*/
if (fDot >= 1.0f) fDot = 1.0f;
else if (fDot <= -1.0f) fDot = -1.0f;
fRotationRadianForProofreading = d3dxvCross.y > 0.0f ? fRotationRadianForProofreading : -fRotationRadianForProofreading;
fRotationRadianForProofreading = D3DXToRadian(D3DXToDegree(fRotationRadianForProofreading) / PLAYER_SOFT_ROTATION_INTERVAL_NUM);
D3DXMatrixRotationAxis(&mtxRotate, &D3DXVECTOR3(0.0f, 1.0f, 0.0f), fRotationRadianForProofreading);
/*printf("Prev Player Position : (%lf, %lf, %lf) \n", GetPosition().x, GetPosition().y, GetPosition().z);
printf("fRotationRadianForProofreading(Degree) : %f \n", D3DXToDegree(fRotationRadianForProofreading));
printf("fDot : %f \n", fDot);
printf("mtxRotate : (%f, %f, %f, %f) \n", mtxRotate._11, mtxRotate._12, mtxRotate._13, mtxRotate._14);
printf("mtxRotate : (%f, %f, %f, %f) \n", mtxRotate._21, mtxRotate._22, mtxRotate._23, mtxRotate._24);
printf("mtxRotate : (%f, %f, %f, %f) \n", mtxRotate._31, mtxRotate._32, mtxRotate._33, mtxRotate._34);
printf("mtxRotate : (%f, %f, %f, %f) \n", mtxRotate._41, mtxRotate._42, mtxRotate._43, mtxRotate._44);*/
D3DXMatrixMultiply(&m_d3dxmtxWorld, &mtxRotate, &m_d3dxmtxWorld);
/*printf("Post Player Position : (%lf, %lf, %lf) \n", GetPosition().x, GetPosition().y, GetPosition().z);*/
//printf("World Position : (%lf, %lf, %lf) \n", m_d3dxmtxWorld._41, m_d3dxmtxWorld._42, m_d3dxmtxWorld._43);
/*printf("_________________________________________ \n");*/
}
void CPlayer::MovingUnderPhysicalEnvironment(CScene *pScene, CVoxelTerrain *pVoxelTerrain, float fTimeElapsed)
{
static D3DXVECTOR3 d3dxvSearchDir[14] =
{
D3DXVECTOR3(0.0f, 0.0f, 1.0f), // ์
D3DXVECTOR3(0.0f, 0.0f, -1.0f), // ํ
D3DXVECTOR3(1.0f, 0.0f, 0.0f), // ์ฐ
D3DXVECTOR3(-1.0f, 0.0f, 0.0f), // ์ข
D3DXVECTOR3(0.0f, 0.0f, 0.0f),
D3DXVECTOR3(1.0f, -1.0f, -1.0f), D3DXVECTOR3(0.0f, -1.0f, -1.0f), D3DXVECTOR3(-1.0f, -1.0f, -1.0f),
D3DXVECTOR3(1.0f, -1.0f, 0.0f), D3DXVECTOR3(0.0f, -1.0f, 0.0f), D3DXVECTOR3(-1.0f, -1.0f, 0.0f),
D3DXVECTOR3(1.0f, -1.0f, 1.0f), D3DXVECTOR3(0.0f, -1.0f, 1.0f), D3DXVECTOR3(-1.0f, -1.0f, 1.0f)
};
// ์ธ๊ณ์ ์ค๋ ฅ์ ๋ฐ๋๋ค.
D3DXVECTOR3 d3dxvPostV = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
D3DXVECTOR2 d3dxvVelocityXZ = D3DXVECTOR2(0.0f, 0.0f);
D3DXVECTOR3 d3dxvG = D3DXVECTOR3(0.0f, GRAVITATIONAL_ACCELERATION, 0.0f);
D3DXVECTOR3 d3dxvMovingDir = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
//printf("Post Velocity : (%f, %f, %f) \n", d3dxvPostV.x, d3dxvPostV.y, d3dxvPostV.z);
// ๋ณต์
์งํ๋งต๊ณผ์ ์ถฉ๋ ์ฒดํฌ๋ฅผ ํ๋ค.
D3DXMATRIX d3dxmtxFromPosToIdx;
D3DXVECTOR4 d3dxvColLayerRow;
D3DXMatrixIdentity(&d3dxmtxFromPosToIdx);
D3DXMatrixInverse(&d3dxmtxFromPosToIdx, NULL, &pVoxelTerrain->m_d3dxmtxFromIdxToPos);
D3DXVec3Transform(&d3dxvColLayerRow, &GetPosition(), &d3dxmtxFromPosToIdx);
d3dxvColLayerRow.x = round(d3dxvColLayerRow.x);
d3dxvColLayerRow.y = round(d3dxvColLayerRow.y);
d3dxvColLayerRow.z = round(d3dxvColLayerRow.z);
CVoxel *pCollidedVoxel;
D3DXVECTOR3 d3dxvInspectionIdx;
for (int i = 0; i < 14; i++)
{
d3dxvInspectionIdx.x = d3dxvColLayerRow.x + d3dxvSearchDir[i].x;
d3dxvInspectionIdx.y = d3dxvColLayerRow.y + d3dxvSearchDir[i].y;
d3dxvInspectionIdx.z = d3dxvColLayerRow.z + d3dxvSearchDir[i].z;
if ((0 <= d3dxvInspectionIdx.x && d3dxvInspectionIdx.x < pVoxelTerrain->m_iMaxCol)
&& (0 <= d3dxvInspectionIdx.y && d3dxvInspectionIdx.y < pVoxelTerrain->m_iMaxLayer)
&& (0 <= d3dxvInspectionIdx.z && d3dxvInspectionIdx.z < pVoxelTerrain->m_iMaxRow))
{
if ((pCollidedVoxel = pVoxelTerrain->m_ppVoxelObjectsForCollision[
(int)((d3dxvColLayerRow.y + d3dxvSearchDir[i].y) * pVoxelTerrain->m_iLayerStride
+ (d3dxvColLayerRow.z + d3dxvSearchDir[i].z) * pVoxelTerrain->m_iRowStride
+ (d3dxvColLayerRow.x + d3dxvSearchDir[i].x))]) != NULL)
{
if (CPhysicalCollision::IsCollided(
&CPhysicalCollision::MoveAABB(this->m_pMesh->m_AABB, GetPosition()),
&CPhysicalCollision::MoveAABB(pCollidedVoxel->m_pMesh->m_AABB, pCollidedVoxel->GetPosition())))
{
D3DXVECTOR3 d3dxvRevision(0.0f, 0.0f, 0.0f);
if (i < 4)
{
if (i < 2)
{
m_d3dxvVelocity = m_d3dxvVelocity - 2.0f * (D3DXVec3Dot(&m_d3dxvVelocity, &D3DXVECTOR3(0.0f, 0.0f, -d3dxvSearchDir[i].z)) * D3DXVECTOR3(0.0f, 0.0f, -d3dxvSearchDir[i].z));
m_d3dxvVelocity.z *= pCollidedVoxel->m_fReflection;
//d3dxvPostV.y = m_d3dxvVelocity.y;
//d3dxvPostV.y *= pCollidedVoxel->m_fReflection;
d3dxvRevision.z = ((pCollidedVoxel->GetPosition().z - d3dxvSearchDir[i].z * pVoxelTerrain->m_fCubeDepth / 2.0f)
- (GetPosition().z + d3dxvSearchDir[i].z * m_pMesh->m_AABB.m_d3dxvMax.z));
//d3dxvPostV.z = 0.0f;
}
else
{
m_d3dxvVelocity = m_d3dxvVelocity - 2.0f * (D3DXVec3Dot(&m_d3dxvVelocity, &D3DXVECTOR3(-d3dxvSearchDir[i].x, 0.0f, 0.0f)) * D3DXVECTOR3(-d3dxvSearchDir[i].x, 0.0f, 0.0f));
m_d3dxvVelocity.x *= pCollidedVoxel->m_fReflection;
//d3dxvPostV.y = m_d3dxvVelocity.y;
//d3dxvPostV.y *= pCollidedVoxel->m_fReflection;
d3dxvRevision.x = ((pCollidedVoxel->GetPosition().x + d3dxvSearchDir[i].x * pVoxelTerrain->m_fCubeWidth / 2.0f)
- (GetPosition().x - d3dxvSearchDir[i].x * m_pMesh->m_AABB.m_d3dxvMax.x));
//d3dxvPostV.x = 0.0f;
}
Moving(d3dxvRevision);
m_CameraOperator.MoveCameraOperator(d3dxvRevision);
}
else if (i < 14)
{
m_d3dxvVelocity = m_d3dxvVelocity - 2.0f * (D3DXVec3Dot(&m_d3dxvVelocity, &D3DXVECTOR3(0.0f, 1.0f, 0.0f)) * D3DXVECTOR3(0.0f, 1.0f, 0.0f));
m_d3dxvVelocity.y *= pCollidedVoxel->m_fReflection;
// ๋ง์ฐฐ๋ ฅ์ ์ ์ฉํ๋ค.
d3dxvVelocityXZ = D3DXVECTOR2(m_d3dxvVelocity.x, m_d3dxvVelocity.z);
d3dxvVelocityXZ *= (pCollidedVoxel->m_fDamping * PLAYER_DAMPING_VALUE);
m_d3dxvVelocity.x = d3dxvVelocityXZ.x;
m_d3dxvVelocity.z = d3dxvVelocityXZ.y;
//printf("y V : %f\n", d3dxvPostV.y);
d3dxvRevision.y = ((pCollidedVoxel->GetPosition().y + pVoxelTerrain->m_fCubeHeight / 2.0f)
- (GetPosition().y + m_pMesh->m_AABB.m_d3dxvMin.y));
Moving(d3dxvRevision);
m_CameraOperator.MoveCameraOperator(d3dxvRevision);
/*printf("<<<<<<<<<<<<<<<<<COLLIDE!!!!>>>>>>>>>>>>>>>>>>>>>\n");*/
i = 13;
}
}
}
}
}
d3dxvPostV = m_d3dxvVelocity;
// ์ธ๋ถ์์ ๊ฐํด์ง ์ด๋ ์๋๋ฅผ ๊ฐฑ์ ํ๋ค
D3DXVec3Normalize(&m_d3dxvMoveDir, &m_d3dxvMoveDir);
d3dxvMovingDir = PLAYER_ACCELERATION_MAGNITUDE * m_d3dxvMoveDir * fTimeElapsed;// +d3dxvPostV;
// ์ต๋ ์๋๋ฅผ ์ ํํ๋ค.
d3dxvVelocityXZ = D3DXVECTOR2(d3dxvMovingDir.x, d3dxvMovingDir.z);
if (D3DXVec2Length(&d3dxvVelocityXZ) > PLAYER_MAX_VELOCITY_MAGNITUDE)
{
D3DXVec2Normalize(&d3dxvVelocityXZ, &d3dxvVelocityXZ);
d3dxvVelocityXZ *= PLAYER_MAX_VELOCITY_MAGNITUDE;
}
d3dxvPostV.x += d3dxvVelocityXZ.x;
d3dxvPostV.z += d3dxvVelocityXZ.y;
// ์๋์ ์ค๋ ฅ๊ฐ์๋๋ฅผ ์ ์ฉํ๋ค.
d3dxvPostV = d3dxvG * fTimeElapsed + d3dxvPostV;
// ๋ฐ๋ ์ ํญ์ ๊ณ์ฐํ๋ค.
d3dxvVelocityXZ = D3DXVECTOR2(d3dxvPostV.x, d3dxvPostV.z);
d3dxvVelocityXZ *= (AIR_RESISTANCE_COEFFICIENT * PLAYER_DAMPING_VALUE);
//d3dxvPostV.x = d3dxvVelocityXZ.x;
//d3dxvPostV.z = d3dxvVelocityXZ.y;
//d3dxvVelocityXZ = D3DXVECTOR2(d3dxvPostV.x, d3dxvPostV.z);
// ์ต๋ ์๋ ์ ํ
if (D3DXVec2Length(&d3dxvVelocityXZ) > PLAYER_MAX_VELOCITY_MAGNITUDE)
{
D3DXVec2Normalize(&d3dxvVelocityXZ, &d3dxvVelocityXZ);
d3dxvVelocityXZ *= PLAYER_MAX_VELOCITY_MAGNITUDE;
}
// ์ต์ข
์๋ ์์ฑ
d3dxvPostV.x = d3dxvVelocityXZ.x;
d3dxvPostV.z = d3dxvVelocityXZ.y;
// ์ด๋๋ ๊ฐฑ์
d3dxvMovingDir = ((d3dxvPostV + m_d3dxvVelocity) * fTimeElapsed) / 2.0f;
// ์ค์ ์ด๋
Moving(d3dxvMovingDir);
m_CameraOperator.MoveCameraOperator(d3dxvMovingDir);
// ํ์ฌ ์๋ ๊ฐฑ์
m_d3dxvVelocity = d3dxvPostV;
// ์ด๋ ๋ฐฉํฅ ์ด๊ธฐํ
m_d3dxvMoveDir = D3DXVECTOR3(0.0f, 0.0f, 0.0f);
d3dxvVelocityXZ = D3DXVECTOR2(m_d3dxvVelocity.x, m_d3dxvVelocity.z);
//printf("Player Velocity : %f\n", D3DXVec2Length(&d3dxvVelocityXZ));
//printf("Velocity : (%f, %f, %f) \n", m_d3dxvVelocity.x, m_d3dxvVelocity.y, m_d3dxvVelocity.z);
//printf("-----------------------------\n");
}
void CPlayer::ProofreadLocalAxis(void)
{
D3DXVECTOR3 d3dxvNormalizedAxis;
D3DXVec3Normalize(&d3dxvNormalizedAxis, &GetLook());
SetLook(d3dxvNormalizedAxis);
SetUp(D3DXVECTOR3(0.0f, 1.0f, 0.0f));
D3DXVec3Cross(&d3dxvNormalizedAxis, &GetUp(), &GetLook());
D3DXVec3Normalize(&d3dxvNormalizedAxis, &d3dxvNormalizedAxis);
SetRight(d3dxvNormalizedAxis);
m_CameraOperator.ProofreadLocalAxis();
}
void CPlayer::CreateShaderVariables(ID3D11Device *pd3dDevice)
{
m_CameraOperator.CreateShaderVariables(pd3dDevice);
}
void CPlayer::UpdateShaderVariables(ID3D11DeviceContext *pd3dDeviceContext)
{
//ํ๋ ์ด์ด์ ํ์ฌ ์นด๋ฉ๋ผ์ UpdateShaderVariables() ๋ฉค๋ฒ ํจ์๋ฅผ ํธ์ถํ๋ค.
// if (m_pCamera) m_pCamera->UpdateShaderVariables(pd3dDeviceContext);
m_CameraOperator.UpdateShaderVariables(pd3dDeviceContext);
}
| [
"batherit0703@naver.com"
] | batherit0703@naver.com |
71ab05bfed2ae38965bcbc1c3aea07e7dce4a962 | 1b1f088d7b3c314e97f8c63610958a85edefaa11 | /src/prx/utilities/heuristics/medial_axis.cpp | 699b688a3f608a9c46e63347c2df4f6a3fec6440 | [
"MIT"
] | permissive | hello-starry/ML4KP | 8b9969e620ecbb9df1bcc81016e8a9e7c4af3ca4 | ccbbb97a778dcfdca961e5d7085ef67398d16d56 | refs/heads/main | 2023-06-19T09:33:06.701877 | 2021-07-07T13:45:52 | 2021-07-07T13:45:52 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 49,837 | cpp | #include "prx/utilities/heuristics/medial_axis.hpp"
#include <fstream>
#include <string>
#ifdef __cpp_lib_filesystem
#include <filesystem>
using std::filesystem::exists;
#elif __cpp_lib_experimental_filesystem
#define _LIBCPP_NO_EXPERIMENTAL_DEPRECATION_WARNING_FILESYSTEM
#include <experimental/filesystem>
using std::experimental::filesystem::exists;
#endif
// using namespace std::complex_literals;
namespace prx
{
constexpr std::complex<double> ma_cell::z_obstacle;// = std::complex<double>(std::numeric_limits<double>::max(),std::numeric_limits<double>::max());
void medial_axis_t::set_map(int x_grid, int y_grid, valid_state_t& valid_state, mapping_f f,
space_t* state_space, std::string _map_name)
{
prx_assert(_map_name != "", "Not a valid name for the map!");
prx_assert(state_space != nullptr, "State space is null!");
map_file_name = _map_name;
std::ofstream ofs_map;
ofs_map.open(map_file_name.c_str(), std::ofstream::trunc);
space_point_t space_point = state_space -> make_point();
bool vs;
for (int i = 0; i < state_space -> get_dimension(); ++i)
{
space_point -> at(i) = 0.0;
}
ofs_map << "type octile" << std::endl;
ofs_map << "height " << x_grid << std::endl;
ofs_map << "width " << y_grid << std::endl;
ofs_map << "map" << std::endl;
for (int i = 0; i < x_grid; i++)
{
// std::vector<ma_cell> row;
ma_map.push_back(std::vector<ma_cell>());
for (int j = 0; j < y_grid; j++)
{
f(i,j,space_point);
vs = valid_state(space_point);
ofs_map << (vs?".":"@");
ma_map.back().push_back(ma_cell());
set_obstacle(i,j, !vs);
}
ofs_map << std::endl;
}
height = x_grid;
width = y_grid;
ofs_map.close();
stage = map_set;
}
void medial_axis_t::set_map(const std::string map_file)
{
map_file_name = map_file;
std::ifstream ifs(map_file_name);
std::string line;
std::getline(ifs,line); // Assuming map_close type is octile, so skip
std::getline(ifs,line);
int i = 0;
for (; i < line.length(); i++) if (std::isdigit(line[i])) break;
line = line.substr(i,line.length() - i);
height = std::atoi(line.c_str());
std::getline(ifs,line);
for (i = 0; i < line.length(); i++) if (std::isdigit(line[i])) break;
line = line.substr(i,line.length() - i);
width = std::atoi(line.c_str());
std::getline(ifs,line); // This is the line that says "map_close"
init_ma_map();
for (i = 0; i < height; i++)
{
std::getline(ifs,line);
for (int j = 0; j < width; j++)
{
set_obstacle(i,j, line[j] != '.');
}
}
stage = map_set;
}
void medial_axis_t::add_obstacles_to_graph()
{
std::vector<double> pt;
std::function<bool(int, int)> surrounded_by_obstacles = [&](int i, int j)
{
// Vec contains the 8 points arround (i,j):
// (i--, j--) (i--, j ) (i--, j++)
// ( i , j--) ( i , j ) ( i , j++)
// (i++, j--) (i++, j ) (i++, j++)
// return true iff ALL points are obstacles (or out of bound)
auto vec = {std::make_pair( i-1, j-1 ), std::make_pair( i-1, j ), std::make_pair( i-1, j+1),
std::make_pair( i , j-1 ), std::make_pair( i , j+1),
std::make_pair( i+1, j-1 ), std::make_pair( i+1, j ), std::make_pair( i+1, j+1)};
for (auto p : vec)
{
if (p.first < 0 || p.second < 0 || p.first >= rows() || p.second >= cols() ) continue;
if (!( is_obstacle(p.first, p.second))) return false;
}
return true;
};
// Only add the border of each obstacle
for (int i = 0; i < rows(); ++i)
{
for (int j = 0; j < cols(); ++j)
{
// If this pt is sorrounded by obstacles, no need to add it to the gnn of obstacles
if ( is_obstacle(i, j) && !surrounded_by_obstacles(i,j) )
{
pt.clear();
pt.push_back(i);
pt.push_back(j);
auto node_index = obstacles_graph.add_vertex<undirected_node_t,undirected_edge_t>();
auto node = obstacles_graph.get_vertex_as<undirected_node_t>(node_index);
node -> point = state_space -> make_point();
state_space -> copy_point_from_vector(node -> point, pt);
metric_obstacles -> add_node(node.get());
}
}
}
// Add borders as (internal) obstalces
for (int i = -1; i < rows() + 1; ++i)
{
pt.clear();
pt.push_back(i);
pt.push_back(-1);
auto node_index = obstacles_graph.add_vertex<undirected_node_t,undirected_edge_t>();
auto node = obstacles_graph.get_vertex_as<undirected_node_t>(node_index);
node -> point = state_space -> make_point();
state_space -> copy_point_from_vector(node -> point, pt);
metric_obstacles -> add_node(node.get());
pt.clear();
pt.push_back(i);
pt.push_back( cols());
node_index = obstacles_graph.add_vertex<undirected_node_t,undirected_edge_t>();
node = obstacles_graph.get_vertex_as<undirected_node_t>(node_index);
node -> point = state_space -> make_point();
state_space -> copy_point_from_vector(node -> point, pt);
metric_obstacles -> add_node(node.get());
}
for (int i = -1; i < cols() +1; ++i)
{
pt.clear();
pt.push_back(-1);
pt.push_back(i);
auto node_index = obstacles_graph.add_vertex<undirected_node_t,undirected_edge_t>();
auto node = obstacles_graph.get_vertex_as<undirected_node_t>(node_index);
node -> point = state_space -> make_point();
state_space -> copy_point_from_vector(node -> point, pt);
metric_obstacles -> add_node(node.get());
pt.clear();
pt.push_back( rows());
pt.push_back(i);
node_index = obstacles_graph.add_vertex<undirected_node_t,undirected_edge_t>();
node = obstacles_graph.get_vertex_as<undirected_node_t>(node_index);
node -> point = state_space -> make_point();
state_space -> copy_point_from_vector(node -> point, pt);
metric_obstacles -> add_node(node.get());
}
}
void medial_axis_t::set_sknw(const std::string nodes_file, const std::string edges_file, const std::string sknw_file)
{
std::ifstream ifs_n(nodes_file);
std::ifstream ifs_s(sknw_file);
std::ifstream ifs_e(edges_file);
std::unordered_map<unsigned long, node_index_t> nodes;
std::unordered_map<unsigned long, std::vector<std::complex<double>>> edges;
std::vector<double> pt;
for (std::string line; std::getline(ifs_e, line); )
{
std::stringstream ss(line);
std::istream_iterator<std::string> begin(ss);
std::istream_iterator<std::string> end;
std::vector<std::string> vstrings(begin, end);
prx_assert(vstrings.size() >= 3, "Not enough indexes on a line of file: " << edges_file );
unsigned long e_index = std::stoul(vstrings[0]);
edges[e_index].push_back(std::complex<double>(std::stod(vstrings[1]), std::stod(vstrings[2])));
}
// Get nodes from a file of the form:
// INDEX X1 X2 (...) Xn
for (std::string line; std::getline(ifs_n, line); )
{
std::stringstream ss(line);
std::istream_iterator<std::string> begin(ss);
std::istream_iterator<std::string> end;
std::vector<std::string> vstrings(begin, end);
unsigned long index;
prx_assert(vstrings.size() >= 2, "Not enough indexes on a line of file: " << nodes_file );
index = std::stoul(vstrings[0]);
for (int i = 1; i < vstrings.size(); ++i)
{
pt.push_back(std::stod(vstrings[i]));
}
auto node_index = graph.add_vertex<undirected_node_t,undirected_edge_t>();
auto node = graph.get_vertex_as<undirected_node_t>(node_index);
node -> point = state_space -> make_point();
state_space -> copy_point_from_vector(node -> point, pt);
metric_close -> add_node(node.get());
nodes[index] = node_index;
set_as_node(std::floor(pt.at(0)), std::floor(pt.at(1)), node_index);
pt.clear();
}
for (std::string line; std::getline(ifs_s, line); )
{
std::stringstream ss(line);
std::istream_iterator<std::string> begin(ss);
std::istream_iterator<std::string> end;
std::vector<std::string> vstrings(begin, end);
prx_assert(vstrings.size() >= 2, "Not enough indexes on a line of file: " << sknw_file);
node_index_t index_1 = nodes[std::stoul(vstrings[0])];
node_index_t index_2 = nodes[std::stoul(vstrings[1])];
auto node_1 = graph.get_vertex_as<undirected_node_t>(index_1);
auto node_2 = graph.get_vertex_as<undirected_node_t>(index_2);
auto edge_pts = edges[std::stoul(vstrings[2])];
std::function<void(node_index_t, node_index_t, int, int)> add_new_node = [&](node_index_t n1, node_index_t n2, int edge1_index, int edge2_index)
{
node_1 = graph.get_vertex_as<undirected_node_t>(n1);
node_2 = graph.get_vertex_as<undirected_node_t>(n2);
if ( edge1_index + 1 == edge2_index || edge1_index == edge2_index
|| has_direct_line_of_sight(node_1 -> point, node_2 -> point, los_clearance) )
{
auto edge_index = graph.add_edge(n1, n2);
auto new_edge = graph.get_edge_as<undirected_edge_t>(edge_index);
new_edge -> set_value( df_ma(node_1 -> point, node_2 -> point) );
for (int i = edge1_index; i < edge2_index; ++i)
{
nodes_edges[edge_index] = std::make_pair(node_1 -> get_index(), node_2 -> get_index());
set_as_edge(edge_pts[i].real(), edge_pts[i].imag(), edge_index);
set_as_edge(edge_pts[i].real(), edge_pts[i].imag()+1, edge_index);
set_as_edge(edge_pts[i].real(), edge_pts[i].imag()-1, edge_index);
set_as_edge(edge_pts[i].real()+1, edge_pts[i].imag(), edge_index);
set_as_edge(edge_pts[i].real()-1, edge_pts[i].imag(), edge_index);
}
edges_list[node_1 -> get_index()].push_back(edge_index);
edges_list[node_2 -> get_index()].push_back(edge_index);
}
else
{
// printf("Creating new node\n");
int middle = edge1_index + (edge2_index - edge1_index)/2;
// prx_assert( (candidate/2) != (candidate + (edge_pts.size() - candidate) / 2), "Can't connect nodes!");
auto node_index = graph.add_vertex<undirected_node_t,undirected_edge_t>();
auto node = graph.get_vertex_as<undirected_node_t>(node_index);
node -> point = state_space -> make_point();
std::vector<double> v = {edge_pts[middle].real(), edge_pts[middle].imag()};
// unset_edge(edge_pts[middle].real(), edge_pts[middle].imag());
set_as_node(edge_pts[middle].real(), edge_pts[middle].imag(), node_index);
next_node_id++;
// std::cout << v[0] << " " << v[1] << std::endl;
state_space -> copy_point_from_vector(node -> point, v);
metric_close -> add_node(node.get());
add_new_node(n1, node_index, edge1_index, middle);
add_new_node(node_index, n2, middle, edge2_index);
}
};
add_new_node(index_1, index_2, 0, edge_pts.size());
}
// stage = sknw_set;
}
// TODO: Remove this function (check that something else is not using it...)
void medial_axis_t::compute_sknw_and_save_to_files(std::string nodes_file, std::string edges_file, std::string sknw_file, std::string py_sknw, std::string py_cmd)
{
prx_assert(goal != nullptr, "Goal not set!");
std::string cmd = py_cmd + " " + py_sknw + " " + map_file_name + " " + nodes_file + " " + edges_file + " " + sknw_file;
int res = std::system(cmd.c_str());
prx_assert(res == 0, "Python command failed");
set_sknw(nodes_file, edges_file, sknw_file);
stage = sknw_set;
}
void medial_axis_t::add_goal_to_graph()
{
auto create_edges = [&](space_point_t p1, space_point_t p2, node_index_t other, edge_index_t edge_i)
{
std::complex<double> c1(std::floor(p1 -> at(0)), std::floor(p1 -> at(1)));
std::complex<double> c2(std::floor(p2 -> at(0)), std::floor(p2 -> at(1)));
std::complex<double> c12 = (c2 - c1)/std::abs(c2 - c1);
set_as_edge(std::floor(c1.real()), std::floor(c1.imag()), edge_i);
nodes_edges[edge_i] = std::make_pair(goal_index, other);
while (std::abs(c1-c2) > 1.0)
{
c1 += c12;
set_as_edge(std::floor(c1.real()), std::floor(c1.imag()), edge_i);
nodes_edges[edge_i] = std::make_pair(goal_index, other);
}
};
auto vec = metric_close -> multi_query(goal, 20);
goal_index = graph.add_vertex<undirected_node_t,undirected_edge_t>();
auto goal_node = graph.get_vertex_as<undirected_node_t>(goal_index);
goal_node -> point = goal;
metric_close -> add_node(goal_node.get());
set_as_node(std::floor(goal -> at(0)), std::floor(goal -> at(1)), goal_index);
// set_as_node(pt, goal_index);
for (auto n : vec)
{
auto node = static_cast<undirected_node_t*>(n);
if ( is_obstacle(node -> point -> at(0), node -> point -> at(1))) continue;
if ( node -> point -> at(0) == goal -> at(0) && node -> point -> at(1) == goal -> at(1) ) continue;
if (has_direct_line_of_sight(goal, node -> point, los_clearance))
{
auto edge_index = graph.add_edge(goal_index, node -> get_index());
auto new_edge = graph.get_edge_as<undirected_edge_t>(edge_index);
new_edge -> set_value( df_ma(goal, node -> point) );
create_edges(node->point, goal, node -> get_index(), edge_index);
set_as_node(std::floor(node -> point -> at(0)), std::floor(node -> point -> at(1)), node -> get_index());
edges_list[node -> get_index()].push_back(edge_index);
edges_list[goal_index].push_back(edge_index);
}
}
}
void medial_axis_t::prepare_graph()
{
prx_assert(stage >= sknw_set, "To prepare graph, sknw has to be set/computed.");
compute_distances_to_ma();
add_goal_to_graph();
graph.dijkstra(goal_index);
graph.vertex_list_to_file(lib_path + "/out/ma_graph_dijkstra.txt");
stage = graph_ready;
}
void medial_axis_t::compute_vector_fields()
{
prx_assert(false, "Function not usable");
space_point_t pt;
pt = state_space -> make_point();
std::complex<double> best_far;
std::complex<double> best_close;
double best_cost, min_dist, aux_dist;
undirected_node_t* node;
for (int i = 0; i < rows(); ++i)
{
for (int j = 0; j < cols(); ++j)
{
}
}
stage = far_ready;
}
void medial_axis_t::find_medial_axis()
{
std::complex<double> vp;
std::complex<double> v;
std::vector<std::complex<double>> possible_edges;
// std::function<bool(ma_pt, ma_pt)> ma_pt_cmp = [](ma_pt a, ma_pt b)
// {return (std::hash<double>{}(a.real()) ^ (std::hash<double>{}(a.imag()) << 1) ) <
// (std::hash<double>{}(b.real()) ^ (std::hash<double>{}(b.imag()) << 1) );};
// std::set<ma_pt,decltype(ma_pt_cmp)> nodes(ma_pt_cmp);
std::vector<ma_pt> nodes;
ma_pt uv;
std::function<double(ma_pt, ma_pt)> dot = [](ma_pt a, ma_pt b)
{
return a.real() * b.real() + a.imag() * b.imag();
};
// Check if the current coordinate should be part of the Medial Axis
// by checking if there is a change on direction of the surrounding vectors
std::function<bool(int, int)> is_ma = [&](int i, int j)
{
std::vector<ma_pt> vs;
ma_pt c = -map_close(i,j);
// if (0 <= i-1 && 0 <= j-1 && i-1 < rows() && j-1 < cols() && !is_obstacle(i-1, j-1)) vs.push_back(-map_close(i-1,j-1));
if (0 <= i-1 && 0 <= j+0 && i-1 < rows() && j+0 < cols() && !is_obstacle(i-1, j+0)) vs.push_back(-map_close(i-1,j+0));
// if (0 <= i-1 && 0 <= j+1 && i-1 < rows() && j+1 < cols() && !is_obstacle(i-1, j+1)) vs.push_back(-map_close(i-1,j+1));
if (0 <= i+0 && 0 <= j-1 && i+0 < rows() && j-1 < cols() && !is_obstacle(i+0, j-1)) vs.push_back(-map_close(i+0,j-1));
// if (0 <= i+0 && 0 <= j+0 && i+0 < rows() && j+0 < cols() && !is_obstacle(i+0, j+0)) vs.push_back(-map_close(i+0,j+0));
if (0 <= i+0 && 0 <= j+1 && i+0 < rows() && j+1 < cols() && !is_obstacle(i+0, j+1)) vs.push_back(-map_close(i+0,j+1));
// if (0 <= i+1 && 0 <= j-1 && i+1 < rows() && j-1 < cols() && !is_obstacle(i+1, j-1)) vs.push_back(-map_close(i+1,j-1));
if (0 <= i+1 && 0 <= j+0 && i+1 < rows() && j+0 < cols() && !is_obstacle(i+1, j+0)) vs.push_back(-map_close(i+1,j+0));
// if (0 <= i+1 && 0 <= j+1 && i+1 < rows() && j+1 < cols() && !is_obstacle(i+1, j+1)) vs.push_back(-map_close(i+1,j+1));
if (vs.size() <= 1) return true;
double cn = std::abs(c);
double ang = 0;
for (int k = 0; k < vs.size(); ++k)
{
// MA_DEBUG(i, j, 181, 350, "c: " << c << " vs[k]: " << vs[k] << " angle: " << ang << " count: " << ma_map[i][j].close_count);
if (c == -vs[k] ) return true; // std::abs(std::arg(vs[i] + vs[j]));
ang = std::abs(std::acos(dot(c, vs[k]) / (cn * std::abs(vs[k]))));
if (ang >= M_PI / 2.0 ) return true; // std::abs(std::arg(vs[i] + vs[j]));
// if (ma_map[i][j].close_count > 1 && ang >= M_PI / 4.0) return true;
// if (ma_map[i][j].close_count > 1 && ang == M_PI / 2.0) return true;
// for (int l = k+1; l < vs.size(); ++l)
// {
// if (std::abs(vs[k]) == std::abs(vs[l])) return true;
// // if (vs[k] == -vs[l] ) return true; // std::abs(std::arg(vs[i] + vs[j]));
// // else if (std::abs(std::acos(dot(vs[k], vs[l]) / (std::abs(vs[k]) * std::abs(vs[l])))) >= M_PI / 2.0 ) return true; // std::abs(std::arg(vs[i] + vs[j]));
// }
}
// MA_DEBUG(i, j, 181, 350, "returning false");
// return cont >= vs.size();
// return true;
return false;
};
std::function<double(double, double)> angle_diff = [&](double a1, double a2)
{
return std::fabs(a1 - a2);
// return std::min(std::fabs(a1 - a2), std::fabs(norm_angle_pi(a1+M_PI, -M_PI, M_PI) - a2 ));
};
ma_pt init;
int i, j;
std::function<void(ma_pt, double)> set_MA = [&](ma_pt pt, double dist_prev)
{
// std::cout << "init: " << init << std::endl;
// if (is_edge(EXPAND_CMP(pt))) return false;
// if (is_obstacle(EXPAND_CMP(pt))) return false;
// if (!in_bounds(EXPAND_CMP(pt))) return false;
// double dist_curr = dist_to_obstacle(pt);
// // double sin_angle = std::sin(std::arg(pt));
// double curr_angle = std::arg(pt - init);
// if (dist_curr <= dist_prev) return true;
// // MA_DEBUG(i,j, 10, 10, "curr_angle: " << curr_angle << " dist_prev: " << dist_prev << " distance: " << angle_diff(curr_angle, dist_prev));
// // MA_DEBUG(pt.real(), pt.imag(), 10, 10, "sin_angle: " << sin_angle << " dist_prev: " << dist_prev);
// set_as_edge(EXPAND_CMP(pt));
// auto close = close_vector_at(EXPAND_CMP(pt));
// auto close_ang = std::arg(close);
// std::cout << "\tpt: " << pt << " curr_angle: " << curr_angle << " close_ang: " << close_ang << " diff: " << angle_diff(curr_angle, close_ang) << std::endl;
// auto cv = pt + close ;// close_vector_at(EXPAND_CMP(pt));
// std::cout <<"\tclose: " << close_vector_at(EXPAND_CMP(pt)) << " cv: " << cv << std::endl;
// if ( set_MA(cv, dist_curr))
// {
// std::cout << "\t\tTRUE!" << std::endl;
// nodes.push_back(cv);
// }
// return false;
bool first = true;
ma_pt first_obst = pt -close_vector_at(EXPAND_CMP(pt), false);
for (auto d : dir4)
{
auto adj = pt + d.first;
// std::cout << "pt: " << pt << " adj: " << adj << " obst: " << first_obst << std::endl;
if (is_obstacle(EXPAND_CMP(adj))) continue;
if (!in_bounds(EXPAND_CMP(adj))) continue;
auto close = -close_vector_at(EXPAND_CMP(adj), false);
auto v = adj + close;
// std::cout << "\tclose: " << close << " v: " << v << " diff: " << std::fabs(std::abs(first_obst) - std::abs(v)) << std::endl;
// if (first)
// {
// first = false;
// first_obst = v;
// }
if ( first_obst == v ) continue;
if ( std::fabs(std::abs(first_obst - v)) >= 1.5 )
{
// std::cout << "\t\tFOUND!" << std::endl;
nodes.push_back(pt);
return;
}
}
};
// const std::string file_to_ma = lib_path + "/out/ma_map_" + "simple_obstacle" + "_vf_to_ma.txt";
// std::ofstream ofs_map;
// ofs_map.open(file_to_ma.c_str(), std::ofstream::trunc);
for (i = 0; i < rows(); ++i)
{
for (j = 0; j < cols(); ++j)
{
if (is_obstacle(i, j) ) continue;
// if (is_ma(i,j)) nodes.push_back(std::complex<double>(i,j));
// MA_DEBUG(i, j, 460, 233, "is_node: " << is_node(i,j));
// MA_DEBUG(i, j, 461, 233, "is_node: " << is_node(i,j));
// if (ma_map[i][j].close_count > 1)
// if (is_node(i,j))
// {
// MA_DEBUG(i,j, 10, 10, "Debuging...");
// nodes.push_back(std::complex<double>(i,j));
// set_node_as(i, j, false);
// }
// set_MA()
set_node_as(i, j, false);
init = std::complex<double>(i,j);
auto pt = init + close_vector_at(EXPAND_CMP(init));
set_MA(init, 0);
// if ( set_MA(pt, std::arg(pt)) )
// {
// nodes.push_back(pt);
// }
}
}
// for (int i = 0; i < obstacles_graph.num_vertices(); ++i)
// {
// auto pt = obstacles_graph[i] -> point;
// std::complex<double> p(pt -> at(0), pt -> at(1));
// for (auto d : dirs)
// {
// set_MA(p + d.first, 0);
// }
// }
// PRX_DEBUG_PRINT
// std::set<ma_pt,decltype(ma_pt_cmp)> visited(ma_pt_cmp);
std::set<node_index_t> nodes_visited;
auto add_node_to_graph = [&](ma_pt pt)
{
if (is_node(pt)) return get_node_id(pt);
auto node_index = graph.add_vertex<undirected_node_t,undirected_edge_t>();
auto node = graph.get_vertex_as<undirected_node_t>(node_index);
node -> point = state_space -> make_point();
state_space -> copy_point_from_vector(node -> point, {pt.real(), pt.imag()});
metric_close -> add_node(node.get());
nodes_visited.insert(node_index);
set_as_node(pt, node_index);
return node_index;
};
std::complex<double> r;
node_index_t n1, n2;
for (auto e : nodes)
{
n1 = add_node_to_graph(e);
// n1 = get_node_id(e);
for (auto d : dir4)
{
r = e + d.first;
if (is_node(r))
{
n2 = get_node_id(r);
auto node = graph.get_vertex_as<undirected_node_t>(n1);
if ( ! node -> is_neighbor(n2) )
{
auto edge_index = graph.add_edge(n1, n2, d.second);
}
}
}
}
// std::cout << "total metric numbers: " << metric_close -> get_nr_nodes() << std::endl;
stage = sknw_set;
}
void medial_axis_t::compute_close_vector(int i, int j)
{
// Skip where there is an obstacle
if ( is_obstacle(i,j) ) return;
// pt <- (i,j)
pt -> at(0) = i;
pt -> at(1) = j;
double aux_dist;
undirected_node_t* node;
// std::set<undirected_node_t*> vec_nodes;
double min_dist = std::numeric_limits<double>::infinity();
std::vector<proximity_node_t*> vec_nodes = metric_close -> multi_query(pt, 30);// radius_and_closest_query(pt, std::abs(map_close(i,j)));
for (int i = 0; i < 5; ++i)
{
node = static_cast<undirected_node_t*>(metric_obstacles -> single_query(pt));
aux_dist = df_ma(node -> point, pt);
if ( aux_dist <= min_dist )
{
min_dist = aux_dist;
vec_nodes.push_back(node);
// vec_nodes.insert(node);
}
}
double dist_aux = 0;
v1 = std::complex<double>(i, j);
v3 = std::complex<double>(0, 0);
double cont = 0;
for (auto n : vec_nodes)
{
node = static_cast<undirected_node_t*>(n);
dist_aux = df_ma(node -> point, pt);
if ( dist_aux == min_dist)
{
v2 = std::complex<double>(node -> point -> at(0), node -> point -> at(1));
MA_DEBUG(i, j, 181, 350, "v1: " << v1 << " v2: " << v2 << " v3: " << v3);
if ( v3 != -(v1 - v2) )
{
v3 = (v1 - v2);
cont++;
ma_map[i][j].close_count++;
}
}
}
// v3 = cont == 0 ? v3 : v3 / cont;
// MA_DEBUG(0, 0, i, j, "v3: " << v3)
map_close(i,j) = v3; //std::complex<double>(v3(0), v3(1));
}
void medial_axis_t::compute_far_vector(int i, int j)
{
prx_assert(stage >= graph_ready, "Close VF has not been computed!");
if ( is_obstacle(i,j) || !in_bounds(i,j)) return;
// pt <- (i,j)
pt -> at(0) = i;
pt -> at(1) = j;
v1 = std::complex<double>(i, j);
v3 = std::complex<double>(0, 0);
// Test direct line of sight to the goal
if (has_direct_line_of_sight(pt, goal, los_clearance))
{
// v2(0) = goal -> at(0);
// v2(1) = goal -> at(1);
v2 = std::complex<double>(goal -> at(0), goal -> at(1));
}
else // Find the medial axis node with direct line of sight from current pos that is closest to the goal
{
bool vector_computed = false;
double best_cost = std::numeric_limits<double>::infinity();
std::shared_ptr<undirected_node_t> node;
// undirected_node_t* node;
// Assume no sln
v2 = std::complex<double>(i, j);
std::set<node_index_t> vec_nodes;
std::vector<proximity_node_t*> vec_close = metric_close -> radius_and_closest_query(pt, dist_to_obstacle(v2));
if (is_node(i, j))
{
auto pn = graph.get_vertex_as<undirected_node_t>(get_node_id(i, j));
vec_nodes.insert(pn -> get_best_neighbor());
}
std::function<void(undirected_node_t*)> insert_nodes = [&](undirected_node_t* ni)
{
if (vec_nodes.count(ni -> get_index()) > 0) return;
if (has_direct_line_of_sight(pt, ni -> point, los_clearance))
{
vec_nodes.insert(ni -> get_index());
vec_close.push_back(static_cast<proximity_node_t*>(ni));
auto next_node = graph.get_vertex_as<undirected_node_t>(ni -> get_best_neighbor());
// insert_nodes(static_cast<undirected_node_t*>( ) );
insert_nodes(next_node.get());
}
};
while (vec_close.size() > 0)
{
insert_nodes(static_cast<undirected_node_t*>(vec_close[0]));
vec_close.erase(vec_close.begin());
}
for (auto n : vec_nodes)
{
node = graph.get_vertex_as<undirected_node_t>(n);
// MA_DEBUG(i, j, 389, 77, "n: " << node -> point -> at(0) << " " << node -> point -> at(1) <<
// " cost: " << node -> get_cost_to_go() << " best_cost: " << best_cost << " dist: " << df_ma(pt, node -> point));
if (n == get_node_id(i, j)) continue;
if ( df_ma(pt, node -> point) + node -> get_cost_to_go() < best_cost)// &&
{
best_cost = df_ma(pt, node -> point) + node -> get_cost_to_go();
v2 = std::complex<double>(node -> point -> at(0), node -> point -> at(1));
vector_computed = true;
}
}
// If no vector with the specified clearance was found, recompute with
// clearance of 0.
if ( best_cost == std::numeric_limits<double>::infinity() )
{
// if (i == 188 && j == 58) printf("clearance = 1\n" );
// for (auto n : vec_nodes)
for (auto n : vec_nodes)
{
node = graph.get_vertex_as<undirected_node_t>(n);
// node = static_cast<undirected_node_t*>(n);
if ( df_ma(pt, node -> point) + node -> get_cost_to_go() < best_cost &&
has_direct_line_of_sight(pt, node -> point, 0.0))
{
best_cost = df_ma(pt, node -> point) + node -> get_cost_to_go();
// v2(0) = node -> point -> at(0);
// v2(1) = node -> point -> at(1);
v2 = std::complex<double>(node -> point -> at(0), node -> point -> at(1));
vector_computed = true;
}
}
}
// If a sln has not been found yet, just point to the closer without checking
// line of sight
if ( best_cost == std::numeric_limits<double>::infinity() )
{
auto node_ptr = static_cast<undirected_node_t*>(metric_close -> single_query(pt));
// v2(0) = node -> point -> at(0);
// v2(1) = node -> point -> at(1);
v2 = std::complex<double>(node_ptr -> point -> at(0), node_ptr -> point -> at(1));
}
}
// MA_DEBUG(i, j,389, 77, "v2: " << v2);
v3 = (v2 - v1);
map_far(i,j) = v3;//std::complex<double>(v3(0), v3(1));
}
void medial_axis_t::compute_close_vector_field()
{
prx_assert(stage >= map_set, "To compute close VF, graph has to be ready (call prepare_graph).");
add_obstacles_to_graph();
std::deque<std::pair<ma_pt,ma_pt>> cells;
ma_pt a;
double dist_aux = 0.0;
std::function<void(ma_pt, ma_pt)> add_to_cells = [&](ma_pt pt, ma_pt obstacle)
{
if ( in_bounds(EXPAND_CMP(pt)) &&
!is_obstacle(EXPAND_CMP(pt)) )
{
dist_aux = dist_to_obstacle(pt);
ma_map[pt.real()][pt.imag()].close_count++;
}
else
{
dist_aux = 0.0;
}
for (auto d : dir4)
{
a = d.first + pt;
// auto b = in_bounds(EXPAND_CMP(a));
// auto c = !is_obstacle(a.real(), a.imag());
// std::cout << b << " " << c << " a: " << a << " pt: " << pt << std::endl;
// auto e = b && c ? dist_to_obstacle(a) : 0.0;
// PRX_DEBUG_PRINT;
// auto f = b && c ? dist_to_obstacle(pt) + d.second : 0.0;
// std::cout << b << " " << c << " " << e << " " << f << std::endl;
if ( in_bounds(EXPAND_CMP(a)) &&
!is_obstacle(a.real(), a.imag()) &&
dist_to_obstacle(a) > ( dist_aux + d.second )
)
{
// set_node_as(a.real(), a.imag(), true);
// if (dist_aux != 0.0)
// set_node_as(pt.real(), pt.imag(), false);
// std::cout << "pt: " << pt << " pt_dist: " << dist_to_obstacle(pt) << "cell: " << a << " dist: " << dist_to_obstacle(a) << std::endl;
// ma_map[a.real()][a.imag()].close_count++;
cells.push_back(std::make_pair(std::complex<double>(EXPAND_CMP(a)), obstacle));
// map_close(EXPAND_CMP(a)) = a - obstacle;
if (is_obstacle(EXPAND_CMP(pt)))
{
map_close(EXPAND_CMP(a)) = d.first;
// set_node_as(a.real(), a.imag(), true);
}
else
{
map_close(EXPAND_CMP(a)) = map_close(EXPAND_CMP(pt)) + d.first;
// set_node_as(a.real(), a.imag(), true);
// set_node_as(pt.real(), pt.imag(), false);
// MA_DEBUG(a.real(), a.imag(), 460, 233, "a: " << a << " pt: " << pt << map_close(a.real(), a.imag()));
// MA_DEBUG(pt.real(), pt.imag(), 460, 233, "a: " << a << " pt: " << pt << map_close(pt.real(), pt.imag()));
// MA_DEBUG(a.real(), a.imag(), 461, 233, "a: " << a << " pt: " << pt << map_close(a.real(), a.imag()));
// MA_DEBUG(pt.real(), pt.imag(), 461, 233, "a: " << a << " pt: " << pt << map_close(pt.real(), pt.imag()));
}
dist_to_obstacle(a) = dist_aux + d.second;
}
}
};
for (int i = 0; i < obstacles_graph.num_vertices(); ++i)
{
auto pt = obstacles_graph[i] -> point;
std::complex<double> p(pt -> at(0), pt -> at(1));
// std::cout << "obstacle: " << p << std::endl;
// cells.push_back(std::complex<double>(pt -> at(0), pt -> at(1)));
if (in_bounds(EXPAND_CMP(p)))
{
dist_to_obstacle(p) = 0;
}
add_to_cells(p, p);
}
// std::cout << "size: " << cells.size() << std::endl;
while (cells.size() > 0)
{
add_to_cells(cells.front().first, cells.front().second);
cells.pop_front();
}
stage = close_ready;
}
void medial_axis_t::compute_far_vector_field()
{
prx_assert(stage >= graph_ready , "Close VF has not been computed!");
for (int i = 0; i < rows(); ++i)
{
for (int j = 0; j < cols(); ++j)
{
// Skip where there is an obstacle
compute_far_vector(i,j);
}
}
stage = far_ready;
}
void medial_axis_t::close_vf_to_file(std::string file_name, bool normalized )
{
prx_assert(stage >= close_ready, "Close VF has not been computed!");
std::ofstream ofs_map;
std::cout << "Saving close VF to: " << file_name << std::endl;
ofs_map.open(file_name.c_str(), std::ofstream::trunc);
std::complex<double> uv;
for (int i = 0; i < rows(); ++i)
{
for (int j = 0; j < cols(); ++j)
{
uv = close_vector_at(i, j, normalized);
ofs_map << i << " " << j << " ";
ofs_map << uv.real() << " " << uv.imag() << std::endl;
}
}
ofs_map.close();
}
void medial_axis_t::far_vf_to_file(std::string file_name, bool normalized )
{
prx_assert(stage == far_ready, "Far VF has not been computed!");
std::cout << "Saving far VF to: " << file_name << std::endl;
std::ofstream ofs_map;
ofs_map.open(file_name.c_str(), std::ofstream::trunc);
std::complex<double> uv;
for (int i = 0; i < rows(); ++i)
{
for (int j = 0; j < cols(); ++j)
{
// if (is_node(i,j) || is_obstacle(i,j))
// {
uv = far_vector_at(i, j, normalized);
ofs_map << i << " " << j << " ";
ofs_map << uv.real() << " " << uv.imag() << std::endl;
// }
}
}
ofs_map.close();
}
std::complex<double> medial_axis_t::close_vector_at(int i, int j, bool normalized)
{
prx_assert(stage >= close_ready, "Close VF has not been computed!");
double u,v;
if ( !in_bounds(i,j) ) return ma_cell::z_obstacle;
if ( is_obstacle(i,j) || map_close(i, j) == v_zero)
{
u = map_close(i,j).real();
v = map_close(i,j).imag();
}
else
{
double n = normalized ? std::abs(map_close(i,j)) : 1.0;
u = map_close(i,j).real() / n;
v = map_close(i,j).imag() / n;
}
return std::complex<double>(u, v);
}
std::complex<double> medial_axis_t::far_vector_at(int i, int j, bool normalized)
{
prx_assert(stage >= close_ready, "Far VF has not been computed!");
double u,v;
if (stage == close_ready)
{
compute_far_vector(i, j);
}
if ( !in_bounds(i,j) )
{
u = std::numeric_limits<double>::max();
v = std::numeric_limits<double>::max();
}
else if ( is_obstacle(i,j) || map_far(i, j) == v_zero)
{
u = map_far(i,j).real();
v = map_far(i,j).imag();
}
else
{
double n = normalized ? std::abs(map_far(i,j)) : 1.0;
u = map_far(i,j).real() / n;
v = map_far(i,j).imag() / n;
}
return std::complex<double>(u, v);
}
std::vector<std::complex<double>> medial_axis_t::blossom(int i, int j, int n, double max_magnitud, double min_magnitud, bool avg_if_obstacle)
{
std::vector<ma_pt> r;
std::map<node_index_t, ma_pt> vectors;
std::map<node_index_t, ma_pt> rejected;
std::vector<double> vec_ids;
r.push_back(integrated_vector_at(i,j, max_magnitud, min_magnitud, avg_if_obstacle));
ma_pt start(i,j);
ma_pt far = far_vector_at(i,j, false);
ma_pt next;
pt -> at(0) = i;
pt -> at(1) = j;
// const double max_magnitud = std::abs(far);
std::function<void(ma_pt)> get_vectors = [&](ma_pt p)
{
// MA_DEBUG(i,j, 160, 160, "\tp: " << p )
if (vectors.count(get_node_id(p)) > 0) return;
if (rejected.count(get_node_id(p)) > 0) return;
// if (is_node(p))
// {
if (max_magnitud < std::abs(p - start) )
{
rejected[get_node_id(p)] = p;
}
else
{
vec_ids.push_back(get_node_id(p));
vectors[get_node_id(p)] = p;
}
auto node = graph.get_vertex_as<undirected_node_t>(get_node_id(p));
for (auto ni : node -> get_neighbors())
{
auto neighbor = graph.get_vertex_as<undirected_node_t>(ni);
ma_pt next(neighbor -> point -> at(0), neighbor -> point -> at(1));
// if (has_direct_line_of_sight(pt, neighbor -> point, 0))
get_vectors(next);
}
};
auto sf = start + far;
if (is_node(sf))
{
get_vectors(sf);
// std::default_random_engine e(seed);
// std::cout << "seed: " << seed << std::endl;
// PRX_DEBUG_ITERABLE("pre-shuffled", vec_ids);
// PRX_DEBUG_ITERABLE("shuffled", vec_ids);
}
if ( avg_if_obstacle && is_obstacle(i, j) )
{
std::complex<double> r(0, 0);
std::complex<double> b(0, 0);
double c = 0;
for (auto d : dirs)
{
auto a = d.first + start;
if (is_obstacle(EXPAND_CMP(a)) || !in_bounds(EXPAND_CMP(a))) continue;
sf = a + far_vector_at(EXPAND_CMP(a), false);// + d.first;
// MA_DEBUG(i,j,170,5, "sf: " << sf << " a: " << a << " is_node: " << is_node(sf));
if (is_node(sf))
{
get_vectors(sf);
}
}
// return c == 0 ? ma_cell::z_obstacle : clamp(r / c);
}
// MA_DEBUG(i,j,170,5, "vec_ids: " << vec_ids.size());
unsigned seed = std::chrono::system_clock::now().time_since_epoch().count();
std::shuffle(vec_ids.begin(), vec_ids.end(), std::default_random_engine(seed));
for (auto v : vec_ids)
{
// MA_DEBUG(i,j, 160, 160, "\tv: " << v.second )
if (r.size() >= n ) break;
auto other = graph.get_vertex_as<undirected_node_t>(v);
if ( avg_if_obstacle && is_obstacle(i, j) )
{
for (auto d : dirs)
{
auto a = d.first + start;
if (is_obstacle(EXPAND_CMP(a)) || !in_bounds(EXPAND_CMP(a))) continue;
pt -> at(0) = a.real();
pt -> at(1) = a.imag();
if (has_direct_line_of_sight(pt, other -> point, 0))
{
r.push_back(vectors[v] - start);
break;
}
}
}
if (has_direct_line_of_sight(pt, other -> point, 0))
{
r.push_back(vectors[v] - start);
}
}
return r;
}
std::complex<double> medial_axis_t::integrated_vector_at(int i, int j, double max_magnitud, double min_magnitud, bool avg_if_obstacle)
{
prx_assert(min_magnitud < max_magnitud, "Problem with the requested magnitud range of the vector: [ " << min_magnitud << " , " << max_magnitud << " ]" );
std::function<bool(ma_pt)> near_ma = [&](ma_pt v)
{
// int ii = v.real();
// int jj = v.imag();
return is_node( v.real(), v.imag() );
};
// std::function<std::complex<double>(ug_node_ptr, std::complex<double>)> update_v = [&](ug_node_ptr n, std::complex<double> v)
// {
// if (n -> get_cost_to_go() < best_cost)
// {
// v.real(n -> point -> at(0));
// v.imag(n -> point -> at(1));
// best_cost = n -> get_cost_to_go();
// }
// return v;
// };
auto try_connect_to_goal = [&](space_point_t pt)
{
std::complex<double> v = ma_cell::z_obstacle;
if (has_direct_line_of_sight(pt, goal, los_clearance))
{
v.real(goal -> at(0));
v.imag(goal -> at(1));
}
return v;
};
std::function<std::complex<double>(std::complex<double>)> clamp = [&](std::complex<double> uv)
{
double m = std::abs(uv);
std::complex<double> r;
if ( m == 0)
{
r = v_zero;
}
else if ( m > max_magnitud)
{
r = uv * max_magnitud / m;
}
else
{
r = uv;
}
return r;
// return m > max_magnitud ? uv * max_magnitud / m : uv;
};
std::function<std::complex<double>(std::complex<double>)> fancy_grow = [&](std::complex<double> v)
{
std::complex<double> init(i, j);
std::complex<double> r = v;
std::complex<double> point = v_zero;
int limit = 0;
// v = u + v;
while (std::abs(r) < min_magnitud && limit < min_magnitud*2)
{
point = init + r;
if (is_obstacle(EXPAND_CMP(point))) break;
if (!in_bounds(EXPAND_CMP(point))) break;
// std::cout << init << " r: " << r;
// std::cout << " magnitud: " << std::abs(r) << " point: " << point;
// std::cout << " map_far: " << map_far(EXPAND_CMP(point)) << std::endl;
r += far_vector_at(EXPAND_CMP(point));
// r += map_far(EXPAND_CMP(point));
// p += r;
limit++;
}
return r;
};
std::complex<double> u(i, j);
if ( avg_if_obstacle && is_obstacle(i, j) )
{
std::complex<double> r(0, 0);
std::complex<double> b(0, 0);
double c = 0;
for (auto d : dirs)
{
auto a = d.first + u;
if ( !in_bounds(EXPAND_CMP(a)) ) continue;
b = close_vector_at(EXPAND_CMP(a), false) ;
if (b != ma_cell::z_obstacle)
{
r += ( b * get_dist_to_ma(EXPAND_CMP(a)));
c++;
}
}
return c == 0 ? ma_cell::z_obstacle : clamp(r / c);
}
if ( is_obstacle(i, j) ) return ma_cell::z_obstacle;
if (get_node_id(i,j) == goal_index) return v_zero;
auto start = compute_integrated_vector(i,j);
if (start == v_zero) return v_zero;
std::complex<double> goal_c(goal -> at(0), goal -> at(1));
double mult = 0.0;
double curr_magnitud = 0.0;
double best_cost = std::numeric_limits<double>::infinity();
// double ma_cost_to_go = 0.0;
std::shared_ptr<undirected_node_t> node;
// double d_far = get_dist_to_ma(i,j);
// double d_close = std::max(1.,std::abs(map_close(i,j)));
// double close_weight = d_far/(d_far + d_close);
// double far_weight = d_close/(d_far + d_close);
curr_magnitud = std::abs(start);
double last_good_mult = 1.0;
while (true)
{
// MA_DEBUG(i,j, 15, 60, "u: " << u << " mult: " << mult << " last_good_mult: " << last_good_mult << " best_cost: " << best_cost);
if ( near_ma(u) )//&& !near_ma(u + start) )
{
node = graph.get_vertex_as<undirected_node_t>(get_node_id(EXPAND_CMP(u)));
if (node != nullptr && mult > 0 && best_cost >= node -> get_cost_to_go() + mult)
{
best_cost = std::ceil(mult + node -> get_cost_to_go());
last_good_mult = mult; // break;
}
}
// if (mult >= max_magnitud ) break;
if (std::abs(goal_c - u) <= 1) {last_good_mult = mult; break;}
// MA_DEBUG(i, j, 14, 6, "u: " << u << " was_near_ma: " << near_ma(u) << " near_ma: " << near_ma(u + start));
// if ( was_near_ma && !near_ma(std::floor(u.real()), std::floor(u.imag())) ) break;
if (!in_bounds(std::floor(u.real()), std::floor(u.imag()))) break;// return clamp(start * last_good_mult);
if (is_obstacle(std::floor(u.real()), std::floor(u.imag()))) break;// return clamp(start * last_good_mult);
// if ( best_cost != std::numeric_limits<double>::infinity() && get_dist_to_ma(EXPAND_CMP(u)) > dist_to_obstacle(u)) break;
// if ( best_cost != std::numeric_limits<double>::infinity() && std::min(get_dist_to_ma(EXPAND_CMP(u)), los_clearance) > dist_to_obstacle(u) ) break;
// if ( std::min(mult, los_clearance) > dist_to_obstacle(u) ) break;
if ( mult > los_clearance && std::min(los_clearance, get_dist_to_ma(EXPAND_CMP(u))) > dist_to_obstacle(u) ) break;
// was_near_ma = near_ma(std::floor(u.real()), std::floor(u.imag()));
// curr_magnitud += 1.0;// std::abs(start * mult);
u += start;
mult += 1.0;
}
mult = best_cost == std::numeric_limits<double>::infinity() ? mult : last_good_mult;
return fancy_grow(clamp(start * mult));
}
std::complex<double> medial_axis_t::compute_integrated_vector(int i, int j)
{
prx_assert(stage >= close_ready, "Close VF has not been computed!");
double u, v;
if (stage < far_ready)
{
compute_far_vector(i, j);
}
std::complex<double> v_far, v_close;
v_close = v_zero;
v_far = v_zero;
double weight = 1;
if ( is_obstacle(i,j) )
{
return ma_cell::z_obstacle;
}
else
{
double d_far = get_dist_to_ma(i,j);
double d_close = std::max(1.,std::abs(map_close(i,j)));
double clearance = std::max(1.,los_clearance);
double close_weight = d_far/(d_far + d_close);
double far_weight = d_close/(d_far + d_close);
// printf("close_weight: %.4f\tfar_weight: %.4f\n", close_weight, far_weight );
if ( map_close(i, j) != v_zero )
{
v_close = map_close(i,j) * close_weight / (std::abs(map_close(i,j))) ;
}
if( map_far(i, j) != v_zero )
{
v_far = map_far(i,j) * far_weight / (std::abs(map_far(i,j)));
}
}
return v_close + v_far;
}
double medial_axis_t::cost_to_go(int i, int j)
{
auto far = far_vector_at(i,j, false);
ma_pt init(i, j);
if (far == ma_cell::z_obstacle)
{
for (auto d : dirs)
{
auto a = d.first + init;
if (is_obstacle(EXPAND_CMP(a)) || !in_bounds(EXPAND_CMP(a))) continue;
return cost_to_go(EXPAND_CMP((d.first + init))) + d.second;
}
return std::numeric_limits<double>::max();
}
auto sf = init + far;
if (!is_node(sf)) return std::numeric_limits<double>::max();
auto node = graph.get_vertex_as<undirected_node_t>(get_node_id(sf));
return std::abs(far) + node -> get_cost_to_go();
}
void medial_axis_t::cost_to_go_to_file(std::string file_name)
{
std::ofstream ofs_map;
ofs_map.open(file_name.c_str(), std::ofstream::trunc);
for (int i = 0; i < rows(); ++i)
{
for (int j = 0; j < cols(); ++j)
{
// uv = integrated_vector_at(i,j, 100, 10, true);
ofs_map << i << " " << j << " ";
ofs_map << cost_to_go(i,j) << std::endl;
}
}
ofs_map.close();
}
void medial_axis_t::set_far_vf_from_file(std::string file_name)
{
prx_assert(stage == map_set, "Close VF not set.");
vector_field_from_file(file_name, 1);
stage = far_ready;
}
void medial_axis_t::set_close_vf_from_file(std::string file_name)
{
prx_assert(stage >= init_done, "Close VF not set.");
vector_field_from_file(file_name, 0);
// can't set stage to close_ready bc might not have far VF file
// ==> need to set goal, sknw & prep graph
stage = map_set;
}
void medial_axis_t::vector_field_from_file(std::string file_name, int map)
{
// prx_assert(exists(file_name), "File does not exists!");
std::ifstream ifs(file_name);
std::string line;
int v1, v2;
int h,w;
int i = 0;
while(std::getline(ifs,line))
{
i = h = w = v1 = v2 = 0 ;
std::istringstream ss(line);
std::string token;
std::vector<int> p;
while(std::getline(ss, token, ' '))
{
switch(i)
{
case 0: w = std::stoi(token); break;
case 1: h = std::stoi(token); break;
case 2: v1 = std::stoi(token); break;
case 3: v2 = std::stoi(token); break;
default: break;
}
i++;
}
if (map == 0) map_close(w,h) = std::complex<double>(v1, v2);
else if (map == 1) map_far(w,h) = std::complex<double>(v1, v2);
}
}
void medial_axis_t::edges_to_file(std::string file_name)
{
std::ofstream ofs_map;
ofs_map.open(file_name.c_str(), std::ofstream::trunc);
std::complex<double> uv;
for (int i = 0; i < rows(); ++i)
{
for (int j = 0; j < cols(); ++j)
{
if ( is_edge(i, j) )
{
ofs_map << get_edge_id(i,j) << " " << i << " " << j << std::endl;
}
}
}
ofs_map.close();
}
void medial_axis_t::integrated_vf_to_file(std::string file_name)
{
std::cout << "Saving integrated VF to: " << file_name << std::endl;
std::ofstream ofs_map;
ofs_map.open(file_name.c_str(), std::ofstream::trunc);
std::complex<double> uv;
for (int i = 0; i < rows(); ++i)
{
for (int j = 0; j < cols(); ++j)
{
// if (is_node(i,j) || is_obstacle(i,j))
// {
uv = integrated_vector_at(i,j, 10, 5, true);
// uv = integrated_vector_at(i,j, std::numeric_limits<double>::max(), false);
// uv = compute_integrated_vector(i, j);
ofs_map << i << " " << j << " ";
ofs_map << uv.real() << " " << uv.imag() << std::endl;
// }
}
}
ofs_map.close();
}
void medial_axis_t::blossom_to_file(std::string file_name)
{
std::cout << "Saving blossom vectors to: " << file_name << std::endl;
std::ofstream ofs_map;
ofs_map.open(file_name.c_str(), std::ofstream::trunc);
std::complex<double> uv;
for (int i = 0; i < rows(); ++i)
{
for (int j = 0; j < cols(); ++j)
{
// if (is_node(i,j) || is_obstacle(i,j))
// {
// if (!is_obstacle(i,j) && uniform_random() < .8) continue;
if (is_obstacle(i,j))
{
uv = integrated_vector_at(i,j, 100, 10, true);
ofs_map << i << " " << j << " ";
ofs_map << uv.real() << " " << uv.imag() << std::endl;
}
if (uniform_random() < .99) continue;
auto vs = blossom(i, j, 5, 100, 10, true);
prx_assert(vs.size() > 1 || is_obstacle(i,j) || !in_bounds(i,j), "returning only one vec: ( " << i << ", " << j << " )");
for (auto v : vs)
{
ofs_map << i << " " << j << " ";
ofs_map << v.real() << " " << v.imag() << std::endl;
}
}
}
ofs_map.close();
}
void medial_axis_t::nodes_to_file(std::string file_name)
{
std::ofstream ofs_map;
ofs_map.open(file_name.c_str(), std::ofstream::trunc);
for (int i = 0; i < rows(); ++i)
{
for (int j = 0; j < cols(); ++j)
{
if ( is_node(i, j) )
{
ofs_map << get_node_id(i,j) << " " << i << " " << j << std::endl;
}
}
}
ofs_map.close();
}
void medial_axis_t::grap_vertices_to_file(std::string file_name)
{
prx_assert(stage >= graph_ready, "Graph has not been prepared.");
graph.vertex_list_to_file(file_name);
}
void medial_axis_t::gnn_to_file(std::string file_name)
{
prx_assert(stage >= graph_ready, "Graph has not been prepared.");
// metric_obstacles -> nodes_to_file(file_name);
}
bool medial_axis_t::has_direct_line_of_sight(space_point_t init, space_point_t end, double clearance)
{
double dist = df_ma(init,end);
if (dist <= 0.01) return true;
double min_dist, min_clearance;
std::function<bool(space_point_t)> is_in_bounds = [&](space_point_t p1)
{
return p1 -> at(0) >= 0 &&
p1 -> at(1) >= 0 &&
p1 -> at(0) < rows() &&
p1 -> at(1) < cols();
};
const double delta = 1.0 / (2.*dist);
// if (init -> at(0) == 188 && init -> at(1) == 58) printf("delta: %.4f\n", delta);
for (double i = delta; i <= 1; i+=delta)
{
state_space -> interpolate(init,end,i,pt_cl1);
if ( is_obstacle(std::floor(pt_cl1 -> at(0)), std::floor(pt_cl1 -> at(1))))
{
return false;
}
min_dist = std::min(dist * i, dist * (1. - i));
// MA_DEBUG(std::floor(init -> at(0)), std::floor(init -> at(1)), 160, 160, "\tpt_cl1: " << state_space -> print_point(pt_cl1, 2) )
min_clearance = std::min(clearance, min_dist);//clearance < min_dist ? clearance : min_dist;
double dist_to_obst = dist_to_obstacle(std::complex<double>(std::floor(pt_cl1 -> at(0)), std::floor(pt_cl1 -> at(1))));
if (dist_to_obst < 1.) continue;
if (dist_to_obst < min_clearance) return false;
}
return true;
}
void medial_axis_t::gradient_vector_at(int i, int j)
{
auto iv = integrated_vector_at(i,j, 1.0);
}
void medial_axis_t::compute_distances_to_ma()
{
std::function<void(int, int, double)> check_and_add_to_queue = [&](int n, int m, double dist)
{
if (in_bounds(n, m) && ma_map[n][m].dist_to_ma > dist)
{
ma_map[n][m].dist_to_ma = dist;
ma_queue.push(std::make_pair(n, m));
}
};
int i, j;
double d;
double sqrt2 = std::sqrt(2.0);
while (ma_queue.size() > 0)
{
i = ma_queue.front().first;
j = ma_queue.front().second;
d = ma_map[i][j].dist_to_ma;
check_and_add_to_queue(i-1, j-1, d + sqrt2);
check_and_add_to_queue(i-1, j , d + 1.0);
check_and_add_to_queue(i-1, j+1, d + sqrt2);
check_and_add_to_queue( i , j-1, d + 1.0);
check_and_add_to_queue( i , j+1, d + 1.0);
check_and_add_to_queue(i+1, j-1, d + sqrt2);
check_and_add_to_queue(i+1, j , d + 1.0);
check_and_add_to_queue(i+1, j+1, d + sqrt2);
ma_queue.pop();
}
}
} | [
"aravind.siva@rutgers.edu"
] | aravind.siva@rutgers.edu |
2ccd77cf15b25ea41180c36ef39480e0345cb0f8 | 425fbce7733ebf5aafe8d10e604a4cbcae6518cf | /rice/detail/cfp.hpp | 4176405ecbb5e3c7f2456179928fc642dd862287 | [
"BSD-2-Clause"
] | permissive | nobu/rice | 19d232bad9869a2f330fcf47dba09116f243ed09 | 29bce9c3510ed2b782262c52aed7448bb74ff96f | refs/heads/master | 2020-12-07T22:54:38.949857 | 2019-11-28T17:11:25 | 2019-11-28T17:11:25 | 232,821,079 | 0 | 0 | NOASSERTION | 2020-01-09T13:55:58 | 2020-01-09T13:55:57 | null | UTF-8 | C++ | false | false | 337 | hpp | #ifndef Rice__detail__cfp__hpp_
#define Rice__detail__cfp__hpp_
#include "ruby.hpp"
namespace Rice
{
namespace detail
{
VALUE * cfp();
VALUE & cfp_data_memo_node_and_pc(VALUE * cfp);
VALUE & cfp_self(VALUE * cfp);
VALUE & cfp_method_class(VALUE * cfp);
} // detail
} // Rice
#include "cfp.ipp"
#endif // Rice__detail__cfp__hpp_
| [
"cout@sapphire.(none)"
] | cout@sapphire.(none) |
b6ab455a8d0a5f4d52bfdbe564b7367c472a530a | 3e1e78cd64328f947fdd721213f75b47a810d68c | /windows/src/ServiceManager.h | f0fafd326bc1454f02526445195d74906e0537e3 | [] | no_license | phuonglelephuong/dynamicipupdate | daeb10b891a06da80d345ced677cd96bdaa62d8f | 58eb721427f132900d81ee95acf3cb09ea133f59 | refs/heads/master | 2021-01-15T20:53:17.046848 | 2011-12-06T18:41:32 | 2011-12-06T18:45:38 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,607 | h | // Copyright (c) 2009 OpenDNS Inc. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef SERVICE_MANAGER_H__
#define SERVICE_MANAGER_H__
#define OPENDNS_UI_UPDATER_SERVICE_NAME _T("OpenDNS Dynamic IP")
enum ServiceStatus {
ServiceStatusUnknown,
ServiceStatusNotInstalled,
ServiceStatusNotRunning,
ServiceStatusStopPending,
ServiceStatusRunning
};
void CloseManagerService(SC_HANDLE *manager, SC_HANDLE *service);
class ServiceManager
{
public:
SC_HANDLE manager;
SC_HANDLE service;
ServiceManager() :
manager(NULL)
, service(NULL)
{}
~ServiceManager() {
CloseManagerService(&manager, &service);
}
int Open(DWORD managerRights, DWORD serviceRights) {
manager = OpenSCManager(NULL, NULL, managerRights);
if (NULL == manager)
return ErrOpenSCManagerFail;
service = OpenService(manager, OPENDNS_UI_UPDATER_SERVICE_NAME, serviceRights);
if (NULL == service)
return ErrOpenServiceFail;
return ErrNoError;
}
int OpenForStop() {
return Open(SC_MANAGER_CONNECT, SERVICE_STOP);
}
int OpenForStart() {
return Open(SC_MANAGER_CONNECT, SERVICE_START);
}
int Stop() {
if (!service || !manager) {
int err = OpenForStop();
if (ErrNoError != err)
return err;
}
assert(service && manager);
SERVICE_STATUS status;
BOOL ok = ControlService(service, SERVICE_CONTROL_STOP, &status);
if (ok)
return ErrNoError;
DWORD lastError = GetLastError();
if (ERROR_SERVICE_NOT_ACTIVE == lastError)
return ErrNoError;
return ErrControlServiceStopFail;
}
int Start() {
if (!service || !manager) {
int err = OpenForStart();
if (ErrNoError != err)
return err;
}
BOOL ok = StartService(service, 0, NULL);
if (ok)
return ErrNoError;
return ErrStartServiceFail;
}
BOOL Delete() {
return DeleteService(service);
}
bool GetStatus(DWORD& state) {
SERVICE_STATUS status;
BOOL ok = QueryServiceStatus(service, &status);
if (!ok)
return false;
state = status.dwCurrentState;
return true;
}
};
static inline int StartUpdateService()
{
ServiceManager sc;
return sc.Start();
}
static inline int StopUpdateService()
{
ServiceManager sc;
return sc.Stop();
}
ServiceStatus GetUpdaterServiceStatus();
TCHAR* FindServiceExePath();
TCHAR* FindGuiExePath();
void InstallService();
void RemoveService();
void StartServiceIfNotStarted();
void StopServiceIfNotStopped();
void StopAndStartServiceIfNeeded();
#endif
| [
"kkowalczyk@gmail.com"
] | kkowalczyk@gmail.com |
6048c604c08113c0dc9b96e89e7c8463d1e00733 | d32424b20ae663a143464a9277f8090bd017a7f6 | /leetcode/674-LongestContinuousIncreasingSubsequence.cpp | 15e5753ac8e9e9ad9545e6f50f57e25fb3ce57cc | [] | no_license | Vesion/Misirlou | a8df716c17a3072e5cf84b5e279c06e2eac9e6a7 | 95274c8ccb3b457d5e884bf26948b03967b40b32 | refs/heads/master | 2023-05-01T10:05:40.709033 | 2023-04-22T18:41:29 | 2023-04-22T18:43:05 | 51,061,447 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 407 | cpp | #include <iostream>
#include <algorithm>
#include <vector>
#include <string>
using namespace std;
class Solution {
public:
int findLengthOfLCIS(vector<int>& nums) {
if (nums.empty()) return 0;
int res = 1, len = 1;
for (int i = 1; i < (int)nums.size(); ++i) {
if (nums[i] > nums[i-1]) res = max(res, ++len);
else len = 1;
}
return res;
}
};
int main() {
return 0;
}
| [
"xuxiang19930924@126.com"
] | xuxiang19930924@126.com |
8c97a956c27fd5b4e017cb0b0add822933e0e937 | e50b5f066628ef65fd7f79078b4b1088f9d11e87 | /llvm/.svn/pristine/1c/1cbe4c9f94b54f87b3d7b3141236a9496dd6e095.svn-base | 36edb34b90f821ea57a2b927a1cde07df00ec7fd | [
"NCSA"
] | permissive | uzleo/coast | 1471e03b2a1ffc9883392bf80711e6159917dca1 | 04bd688ac9a18d2327c59ea0c90f72e9b49df0f4 | refs/heads/master | 2020-05-16T11:46:24.870750 | 2019-04-23T13:57:53 | 2019-04-23T13:57:53 | 183,025,687 | 0 | 0 | null | 2019-04-23T13:52:28 | 2019-04-23T13:52:27 | null | UTF-8 | C++ | false | false | 24,988 | //===- ELFYAML.cpp - ELF YAMLIO implementation ----------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
//
// This file defines classes for handling the YAML representation of ELF.
//
//===----------------------------------------------------------------------===//
#include "llvm/ObjectYAML/ELFYAML.h"
#include "llvm/Support/Casting.h"
#include "llvm/Support/MipsABIFlags.h"
namespace llvm {
ELFYAML::Section::~Section() {}
namespace yaml {
void
ScalarEnumerationTraits<ELFYAML::ELF_ET>::enumeration(IO &IO,
ELFYAML::ELF_ET &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
ECase(ET_NONE)
ECase(ET_REL)
ECase(ET_EXEC)
ECase(ET_DYN)
ECase(ET_CORE)
#undef ECase
IO.enumFallback<Hex16>(Value);
}
void
ScalarEnumerationTraits<ELFYAML::ELF_EM>::enumeration(IO &IO,
ELFYAML::ELF_EM &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
ECase(EM_NONE)
ECase(EM_M32)
ECase(EM_SPARC)
ECase(EM_386)
ECase(EM_68K)
ECase(EM_88K)
ECase(EM_IAMCU)
ECase(EM_860)
ECase(EM_MIPS)
ECase(EM_S370)
ECase(EM_MIPS_RS3_LE)
ECase(EM_PARISC)
ECase(EM_VPP500)
ECase(EM_SPARC32PLUS)
ECase(EM_960)
ECase(EM_PPC)
ECase(EM_PPC64)
ECase(EM_S390)
ECase(EM_SPU)
ECase(EM_V800)
ECase(EM_FR20)
ECase(EM_RH32)
ECase(EM_RCE)
ECase(EM_ARM)
ECase(EM_ALPHA)
ECase(EM_SH)
ECase(EM_SPARCV9)
ECase(EM_TRICORE)
ECase(EM_ARC)
ECase(EM_H8_300)
ECase(EM_H8_300H)
ECase(EM_H8S)
ECase(EM_H8_500)
ECase(EM_IA_64)
ECase(EM_MIPS_X)
ECase(EM_COLDFIRE)
ECase(EM_68HC12)
ECase(EM_MMA)
ECase(EM_PCP)
ECase(EM_NCPU)
ECase(EM_NDR1)
ECase(EM_STARCORE)
ECase(EM_ME16)
ECase(EM_ST100)
ECase(EM_TINYJ)
ECase(EM_X86_64)
ECase(EM_PDSP)
ECase(EM_PDP10)
ECase(EM_PDP11)
ECase(EM_FX66)
ECase(EM_ST9PLUS)
ECase(EM_ST7)
ECase(EM_68HC16)
ECase(EM_68HC11)
ECase(EM_68HC08)
ECase(EM_68HC05)
ECase(EM_SVX)
ECase(EM_ST19)
ECase(EM_VAX)
ECase(EM_CRIS)
ECase(EM_JAVELIN)
ECase(EM_FIREPATH)
ECase(EM_ZSP)
ECase(EM_MMIX)
ECase(EM_HUANY)
ECase(EM_PRISM)
ECase(EM_AVR)
ECase(EM_FR30)
ECase(EM_D10V)
ECase(EM_D30V)
ECase(EM_V850)
ECase(EM_M32R)
ECase(EM_MN10300)
ECase(EM_MN10200)
ECase(EM_PJ)
ECase(EM_OPENRISC)
ECase(EM_ARC_COMPACT)
ECase(EM_XTENSA)
ECase(EM_VIDEOCORE)
ECase(EM_TMM_GPP)
ECase(EM_NS32K)
ECase(EM_TPC)
ECase(EM_SNP1K)
ECase(EM_ST200)
ECase(EM_IP2K)
ECase(EM_MAX)
ECase(EM_CR)
ECase(EM_F2MC16)
ECase(EM_MSP430)
ECase(EM_BLACKFIN)
ECase(EM_SE_C33)
ECase(EM_SEP)
ECase(EM_ARCA)
ECase(EM_UNICORE)
ECase(EM_EXCESS)
ECase(EM_DXP)
ECase(EM_ALTERA_NIOS2)
ECase(EM_CRX)
ECase(EM_XGATE)
ECase(EM_C166)
ECase(EM_M16C)
ECase(EM_DSPIC30F)
ECase(EM_CE)
ECase(EM_M32C)
ECase(EM_TSK3000)
ECase(EM_RS08)
ECase(EM_SHARC)
ECase(EM_ECOG2)
ECase(EM_SCORE7)
ECase(EM_DSP24)
ECase(EM_VIDEOCORE3)
ECase(EM_LATTICEMICO32)
ECase(EM_SE_C17)
ECase(EM_TI_C6000)
ECase(EM_TI_C2000)
ECase(EM_TI_C5500)
ECase(EM_MMDSP_PLUS)
ECase(EM_CYPRESS_M8C)
ECase(EM_R32C)
ECase(EM_TRIMEDIA)
ECase(EM_HEXAGON)
ECase(EM_8051)
ECase(EM_STXP7X)
ECase(EM_NDS32)
ECase(EM_ECOG1)
ECase(EM_ECOG1X)
ECase(EM_MAXQ30)
ECase(EM_XIMO16)
ECase(EM_MANIK)
ECase(EM_CRAYNV2)
ECase(EM_RX)
ECase(EM_METAG)
ECase(EM_MCST_ELBRUS)
ECase(EM_ECOG16)
ECase(EM_CR16)
ECase(EM_ETPU)
ECase(EM_SLE9X)
ECase(EM_L10M)
ECase(EM_K10M)
ECase(EM_AARCH64)
ECase(EM_AVR32)
ECase(EM_STM8)
ECase(EM_TILE64)
ECase(EM_TILEPRO)
ECase(EM_CUDA)
ECase(EM_TILEGX)
ECase(EM_CLOUDSHIELD)
ECase(EM_COREA_1ST)
ECase(EM_COREA_2ND)
ECase(EM_ARC_COMPACT2)
ECase(EM_OPEN8)
ECase(EM_RL78)
ECase(EM_VIDEOCORE5)
ECase(EM_78KOR)
ECase(EM_56800EX)
ECase(EM_AMDGPU)
ECase(EM_LANAI)
ECase(EM_BPF)
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::ELF_ELFCLASS>::enumeration(
IO &IO, ELFYAML::ELF_ELFCLASS &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
// Since the semantics of ELFCLASSNONE is "invalid", just don't accept it
// here.
ECase(ELFCLASS32)
ECase(ELFCLASS64)
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::ELF_ELFDATA>::enumeration(
IO &IO, ELFYAML::ELF_ELFDATA &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
// Since the semantics of ELFDATANONE is "invalid", just don't accept it
// here.
ECase(ELFDATA2LSB)
ECase(ELFDATA2MSB)
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::ELF_ELFOSABI>::enumeration(
IO &IO, ELFYAML::ELF_ELFOSABI &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
ECase(ELFOSABI_NONE)
ECase(ELFOSABI_HPUX)
ECase(ELFOSABI_NETBSD)
ECase(ELFOSABI_GNU)
ECase(ELFOSABI_GNU)
ECase(ELFOSABI_HURD)
ECase(ELFOSABI_SOLARIS)
ECase(ELFOSABI_AIX)
ECase(ELFOSABI_IRIX)
ECase(ELFOSABI_FREEBSD)
ECase(ELFOSABI_TRU64)
ECase(ELFOSABI_MODESTO)
ECase(ELFOSABI_OPENBSD)
ECase(ELFOSABI_OPENVMS)
ECase(ELFOSABI_NSK)
ECase(ELFOSABI_AROS)
ECase(ELFOSABI_FENIXOS)
ECase(ELFOSABI_CLOUDABI)
ECase(ELFOSABI_C6000_ELFABI)
ECase(ELFOSABI_AMDGPU_HSA)
ECase(ELFOSABI_C6000_LINUX)
ECase(ELFOSABI_ARM)
ECase(ELFOSABI_STANDALONE)
#undef ECase
}
void ScalarBitSetTraits<ELFYAML::ELF_EF>::bitset(IO &IO,
ELFYAML::ELF_EF &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X);
#define BCaseMask(X, M) IO.maskedBitSetCase(Value, #X, ELF::X, ELF::M);
switch (Object->Header.Machine) {
case ELF::EM_ARM:
BCase(EF_ARM_SOFT_FLOAT)
BCase(EF_ARM_VFP_FLOAT)
BCaseMask(EF_ARM_EABI_UNKNOWN, EF_ARM_EABIMASK)
BCaseMask(EF_ARM_EABI_VER1, EF_ARM_EABIMASK)
BCaseMask(EF_ARM_EABI_VER2, EF_ARM_EABIMASK)
BCaseMask(EF_ARM_EABI_VER3, EF_ARM_EABIMASK)
BCaseMask(EF_ARM_EABI_VER4, EF_ARM_EABIMASK)
BCaseMask(EF_ARM_EABI_VER5, EF_ARM_EABIMASK)
break;
case ELF::EM_MIPS:
BCase(EF_MIPS_NOREORDER)
BCase(EF_MIPS_PIC)
BCase(EF_MIPS_CPIC)
BCase(EF_MIPS_ABI2)
BCase(EF_MIPS_32BITMODE)
BCase(EF_MIPS_FP64)
BCase(EF_MIPS_NAN2008)
BCase(EF_MIPS_MICROMIPS)
BCase(EF_MIPS_ARCH_ASE_M16)
BCase(EF_MIPS_ARCH_ASE_MDMX)
BCaseMask(EF_MIPS_ABI_O32, EF_MIPS_ABI)
BCaseMask(EF_MIPS_ABI_O64, EF_MIPS_ABI)
BCaseMask(EF_MIPS_ABI_EABI32, EF_MIPS_ABI)
BCaseMask(EF_MIPS_ABI_EABI64, EF_MIPS_ABI)
BCaseMask(EF_MIPS_MACH_3900, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_4010, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_4100, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_4650, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_4120, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_4111, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_SB1, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_OCTEON, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_XLR, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_OCTEON2, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_OCTEON3, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_5400, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_5900, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_5500, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_9000, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_LS2E, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_LS2F, EF_MIPS_MACH)
BCaseMask(EF_MIPS_MACH_LS3A, EF_MIPS_MACH)
BCaseMask(EF_MIPS_ARCH_1, EF_MIPS_ARCH)
BCaseMask(EF_MIPS_ARCH_2, EF_MIPS_ARCH)
BCaseMask(EF_MIPS_ARCH_3, EF_MIPS_ARCH)
BCaseMask(EF_MIPS_ARCH_4, EF_MIPS_ARCH)
BCaseMask(EF_MIPS_ARCH_5, EF_MIPS_ARCH)
BCaseMask(EF_MIPS_ARCH_32, EF_MIPS_ARCH)
BCaseMask(EF_MIPS_ARCH_64, EF_MIPS_ARCH)
BCaseMask(EF_MIPS_ARCH_32R2, EF_MIPS_ARCH)
BCaseMask(EF_MIPS_ARCH_64R2, EF_MIPS_ARCH)
BCaseMask(EF_MIPS_ARCH_32R6, EF_MIPS_ARCH)
BCaseMask(EF_MIPS_ARCH_64R6, EF_MIPS_ARCH)
break;
case ELF::EM_HEXAGON:
BCase(EF_HEXAGON_MACH_V2)
BCase(EF_HEXAGON_MACH_V3)
BCase(EF_HEXAGON_MACH_V4)
BCase(EF_HEXAGON_MACH_V5)
BCase(EF_HEXAGON_ISA_V2)
BCase(EF_HEXAGON_ISA_V3)
BCase(EF_HEXAGON_ISA_V4)
BCase(EF_HEXAGON_ISA_V5)
break;
case ELF::EM_AVR:
BCase(EF_AVR_ARCH_AVR1)
BCase(EF_AVR_ARCH_AVR2)
BCase(EF_AVR_ARCH_AVR25)
BCase(EF_AVR_ARCH_AVR3)
BCase(EF_AVR_ARCH_AVR31)
BCase(EF_AVR_ARCH_AVR35)
BCase(EF_AVR_ARCH_AVR4)
BCase(EF_AVR_ARCH_AVR51)
BCase(EF_AVR_ARCH_AVR6)
BCase(EF_AVR_ARCH_AVRTINY)
BCase(EF_AVR_ARCH_XMEGA1)
BCase(EF_AVR_ARCH_XMEGA2)
BCase(EF_AVR_ARCH_XMEGA3)
BCase(EF_AVR_ARCH_XMEGA4)
BCase(EF_AVR_ARCH_XMEGA5)
BCase(EF_AVR_ARCH_XMEGA6)
BCase(EF_AVR_ARCH_XMEGA7)
break;
case ELF::EM_AMDGPU:
case ELF::EM_X86_64:
break;
default:
llvm_unreachable("Unsupported architecture");
}
#undef BCase
#undef BCaseMask
}
void ScalarEnumerationTraits<ELFYAML::ELF_SHT>::enumeration(
IO &IO, ELFYAML::ELF_SHT &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
ECase(SHT_NULL)
ECase(SHT_PROGBITS)
// No SHT_SYMTAB. Use the top-level `Symbols` key instead.
// FIXME: Issue a diagnostic with this information.
ECase(SHT_STRTAB)
ECase(SHT_RELA)
ECase(SHT_HASH)
ECase(SHT_DYNAMIC)
ECase(SHT_NOTE)
ECase(SHT_NOBITS)
ECase(SHT_REL)
ECase(SHT_SHLIB)
ECase(SHT_DYNSYM)
ECase(SHT_INIT_ARRAY)
ECase(SHT_FINI_ARRAY)
ECase(SHT_PREINIT_ARRAY)
ECase(SHT_GROUP)
ECase(SHT_SYMTAB_SHNDX)
ECase(SHT_LOOS)
ECase(SHT_GNU_ATTRIBUTES)
ECase(SHT_GNU_HASH)
ECase(SHT_GNU_verdef)
ECase(SHT_GNU_verneed)
ECase(SHT_GNU_versym)
ECase(SHT_HIOS)
ECase(SHT_LOPROC)
switch (Object->Header.Machine) {
case ELF::EM_ARM:
ECase(SHT_ARM_EXIDX)
ECase(SHT_ARM_PREEMPTMAP)
ECase(SHT_ARM_ATTRIBUTES)
ECase(SHT_ARM_DEBUGOVERLAY)
ECase(SHT_ARM_OVERLAYSECTION)
break;
case ELF::EM_HEXAGON:
ECase(SHT_HEX_ORDERED)
break;
case ELF::EM_X86_64:
ECase(SHT_X86_64_UNWIND)
break;
case ELF::EM_MIPS:
ECase(SHT_MIPS_REGINFO)
ECase(SHT_MIPS_OPTIONS)
ECase(SHT_MIPS_ABIFLAGS)
break;
default:
// Nothing to do.
break;
}
#undef ECase
}
void ScalarBitSetTraits<ELFYAML::ELF_SHF>::bitset(IO &IO,
ELFYAML::ELF_SHF &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X);
BCase(SHF_WRITE)
BCase(SHF_ALLOC)
BCase(SHF_EXCLUDE)
BCase(SHF_EXECINSTR)
BCase(SHF_MERGE)
BCase(SHF_STRINGS)
BCase(SHF_INFO_LINK)
BCase(SHF_LINK_ORDER)
BCase(SHF_OS_NONCONFORMING)
BCase(SHF_GROUP)
BCase(SHF_TLS)
switch(Object->Header.Machine) {
case ELF::EM_AMDGPU:
BCase(SHF_AMDGPU_HSA_GLOBAL)
BCase(SHF_AMDGPU_HSA_READONLY)
BCase(SHF_AMDGPU_HSA_CODE)
BCase(SHF_AMDGPU_HSA_AGENT)
break;
case ELF::EM_HEXAGON:
BCase(SHF_HEX_GPREL)
break;
case ELF::EM_MIPS:
BCase(SHF_MIPS_NODUPES)
BCase(SHF_MIPS_NAMES)
BCase(SHF_MIPS_LOCAL)
BCase(SHF_MIPS_NOSTRIP)
BCase(SHF_MIPS_GPREL)
BCase(SHF_MIPS_MERGE)
BCase(SHF_MIPS_ADDR)
BCase(SHF_MIPS_STRING)
break;
case ELF::EM_X86_64:
BCase(SHF_X86_64_LARGE)
break;
default:
// Nothing to do.
break;
}
#undef BCase
}
void ScalarEnumerationTraits<ELFYAML::ELF_STT>::enumeration(
IO &IO, ELFYAML::ELF_STT &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
ECase(STT_NOTYPE)
ECase(STT_OBJECT)
ECase(STT_FUNC)
ECase(STT_SECTION)
ECase(STT_FILE)
ECase(STT_COMMON)
ECase(STT_TLS)
ECase(STT_GNU_IFUNC)
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::ELF_STV>::enumeration(
IO &IO, ELFYAML::ELF_STV &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
ECase(STV_DEFAULT)
ECase(STV_INTERNAL)
ECase(STV_HIDDEN)
ECase(STV_PROTECTED)
#undef ECase
}
void ScalarBitSetTraits<ELFYAML::ELF_STO>::bitset(IO &IO,
ELFYAML::ELF_STO &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
#define BCase(X) IO.bitSetCase(Value, #X, ELF::X);
switch (Object->Header.Machine) {
case ELF::EM_MIPS:
BCase(STO_MIPS_OPTIONAL)
BCase(STO_MIPS_PLT)
BCase(STO_MIPS_PIC)
BCase(STO_MIPS_MICROMIPS)
break;
default:
break; // Nothing to do
}
#undef BCase
#undef BCaseMask
}
void ScalarEnumerationTraits<ELFYAML::ELF_RSS>::enumeration(
IO &IO, ELFYAML::ELF_RSS &Value) {
#define ECase(X) IO.enumCase(Value, #X, ELF::X);
ECase(RSS_UNDEF)
ECase(RSS_GP)
ECase(RSS_GP0)
ECase(RSS_LOC)
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::ELF_REL>::enumeration(
IO &IO, ELFYAML::ELF_REL &Value) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
#define ELF_RELOC(X, Y) IO.enumCase(Value, #X, ELF::X);
switch (Object->Header.Machine) {
case ELF::EM_X86_64:
#include "llvm/Support/ELFRelocs/x86_64.def"
break;
case ELF::EM_MIPS:
#include "llvm/Support/ELFRelocs/Mips.def"
break;
case ELF::EM_HEXAGON:
#include "llvm/Support/ELFRelocs/Hexagon.def"
break;
case ELF::EM_386:
case ELF::EM_IAMCU:
#include "llvm/Support/ELFRelocs/i386.def"
break;
case ELF::EM_AARCH64:
#include "llvm/Support/ELFRelocs/AArch64.def"
break;
case ELF::EM_ARM:
#include "llvm/Support/ELFRelocs/ARM.def"
break;
case ELF::EM_LANAI:
#include "llvm/Support/ELFRelocs/Lanai.def"
break;
case ELF::EM_AMDGPU:
#include "llvm/Support/ELFRelocs/AMDGPU.def"
break;
case ELF::EM_BPF:
#include "llvm/Support/ELFRelocs/BPF.def"
break;
default:
llvm_unreachable("Unsupported architecture");
}
#undef ELF_RELOC
}
void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_REG>::enumeration(
IO &IO, ELFYAML::MIPS_AFL_REG &Value) {
#define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X);
ECase(REG_NONE)
ECase(REG_32)
ECase(REG_64)
ECase(REG_128)
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::MIPS_ABI_FP>::enumeration(
IO &IO, ELFYAML::MIPS_ABI_FP &Value) {
#define ECase(X) IO.enumCase(Value, #X, Mips::Val_GNU_MIPS_ABI_##X);
ECase(FP_ANY)
ECase(FP_DOUBLE)
ECase(FP_SINGLE)
ECase(FP_SOFT)
ECase(FP_OLD_64)
ECase(FP_XX)
ECase(FP_64)
ECase(FP_64A)
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::MIPS_AFL_EXT>::enumeration(
IO &IO, ELFYAML::MIPS_AFL_EXT &Value) {
#define ECase(X) IO.enumCase(Value, #X, Mips::AFL_##X);
ECase(EXT_NONE)
ECase(EXT_XLR)
ECase(EXT_OCTEON2)
ECase(EXT_OCTEONP)
ECase(EXT_LOONGSON_3A)
ECase(EXT_OCTEON)
ECase(EXT_5900)
ECase(EXT_4650)
ECase(EXT_4010)
ECase(EXT_4100)
ECase(EXT_3900)
ECase(EXT_10000)
ECase(EXT_SB1)
ECase(EXT_4111)
ECase(EXT_4120)
ECase(EXT_5400)
ECase(EXT_5500)
ECase(EXT_LOONGSON_2E)
ECase(EXT_LOONGSON_2F)
ECase(EXT_OCTEON3)
#undef ECase
}
void ScalarEnumerationTraits<ELFYAML::MIPS_ISA>::enumeration(
IO &IO, ELFYAML::MIPS_ISA &Value) {
IO.enumCase(Value, "MIPS1", 1);
IO.enumCase(Value, "MIPS2", 2);
IO.enumCase(Value, "MIPS3", 3);
IO.enumCase(Value, "MIPS4", 4);
IO.enumCase(Value, "MIPS5", 5);
IO.enumCase(Value, "MIPS32", 32);
IO.enumCase(Value, "MIPS64", 64);
}
void ScalarBitSetTraits<ELFYAML::MIPS_AFL_ASE>::bitset(
IO &IO, ELFYAML::MIPS_AFL_ASE &Value) {
#define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_ASE_##X);
BCase(DSP)
BCase(DSPR2)
BCase(EVA)
BCase(MCU)
BCase(MDMX)
BCase(MIPS3D)
BCase(MT)
BCase(SMARTMIPS)
BCase(VIRT)
BCase(MSA)
BCase(MIPS16)
BCase(MICROMIPS)
BCase(XPA)
#undef BCase
}
void ScalarBitSetTraits<ELFYAML::MIPS_AFL_FLAGS1>::bitset(
IO &IO, ELFYAML::MIPS_AFL_FLAGS1 &Value) {
#define BCase(X) IO.bitSetCase(Value, #X, Mips::AFL_FLAGS1_##X);
BCase(ODDSPREG)
#undef BCase
}
void MappingTraits<ELFYAML::FileHeader>::mapping(IO &IO,
ELFYAML::FileHeader &FileHdr) {
IO.mapRequired("Class", FileHdr.Class);
IO.mapRequired("Data", FileHdr.Data);
IO.mapOptional("OSABI", FileHdr.OSABI, ELFYAML::ELF_ELFOSABI(0));
IO.mapRequired("Type", FileHdr.Type);
IO.mapRequired("Machine", FileHdr.Machine);
IO.mapOptional("Flags", FileHdr.Flags, ELFYAML::ELF_EF(0));
IO.mapOptional("Entry", FileHdr.Entry, Hex64(0));
}
namespace {
struct NormalizedOther {
NormalizedOther(IO &)
: Visibility(ELFYAML::ELF_STV(0)), Other(ELFYAML::ELF_STO(0)) {}
NormalizedOther(IO &, uint8_t Original)
: Visibility(Original & 0x3), Other(Original & ~0x3) {}
uint8_t denormalize(IO &) { return Visibility | Other; }
ELFYAML::ELF_STV Visibility;
ELFYAML::ELF_STO Other;
};
}
void MappingTraits<ELFYAML::Symbol>::mapping(IO &IO, ELFYAML::Symbol &Symbol) {
IO.mapOptional("Name", Symbol.Name, StringRef());
IO.mapOptional("Type", Symbol.Type, ELFYAML::ELF_STT(0));
IO.mapOptional("Section", Symbol.Section, StringRef());
IO.mapOptional("Value", Symbol.Value, Hex64(0));
IO.mapOptional("Size", Symbol.Size, Hex64(0));
MappingNormalization<NormalizedOther, uint8_t> Keys(IO, Symbol.Other);
IO.mapOptional("Visibility", Keys->Visibility, ELFYAML::ELF_STV(0));
IO.mapOptional("Other", Keys->Other, ELFYAML::ELF_STO(0));
}
void MappingTraits<ELFYAML::LocalGlobalWeakSymbols>::mapping(
IO &IO, ELFYAML::LocalGlobalWeakSymbols &Symbols) {
IO.mapOptional("Local", Symbols.Local);
IO.mapOptional("Global", Symbols.Global);
IO.mapOptional("Weak", Symbols.Weak);
}
static void commonSectionMapping(IO &IO, ELFYAML::Section &Section) {
IO.mapOptional("Name", Section.Name, StringRef());
IO.mapRequired("Type", Section.Type);
IO.mapOptional("Flags", Section.Flags, ELFYAML::ELF_SHF(0));
IO.mapOptional("Address", Section.Address, Hex64(0));
IO.mapOptional("Link", Section.Link, StringRef());
IO.mapOptional("AddressAlign", Section.AddressAlign, Hex64(0));
IO.mapOptional("Info", Section.Info, StringRef());
}
static void sectionMapping(IO &IO, ELFYAML::RawContentSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Content", Section.Content);
IO.mapOptional("Size", Section.Size, Hex64(Section.Content.binary_size()));
}
static void sectionMapping(IO &IO, ELFYAML::NoBitsSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Size", Section.Size, Hex64(0));
}
static void sectionMapping(IO &IO, ELFYAML::RelocationSection &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Relocations", Section.Relocations);
}
static void groupSectionMapping(IO &IO, ELFYAML::Group &group) {
commonSectionMapping(IO, group);
IO.mapRequired("Members", group.Members);
}
void MappingTraits<ELFYAML::SectionOrType>::mapping(
IO &IO, ELFYAML::SectionOrType §ionOrType) {
IO.mapRequired("SectionOrType", sectionOrType.sectionNameOrType);
}
static void sectionMapping(IO &IO, ELFYAML::MipsABIFlags &Section) {
commonSectionMapping(IO, Section);
IO.mapOptional("Version", Section.Version, Hex16(0));
IO.mapRequired("ISA", Section.ISALevel);
IO.mapOptional("ISARevision", Section.ISARevision, Hex8(0));
IO.mapOptional("ISAExtension", Section.ISAExtension,
ELFYAML::MIPS_AFL_EXT(Mips::AFL_EXT_NONE));
IO.mapOptional("ASEs", Section.ASEs, ELFYAML::MIPS_AFL_ASE(0));
IO.mapOptional("FpABI", Section.FpABI,
ELFYAML::MIPS_ABI_FP(Mips::Val_GNU_MIPS_ABI_FP_ANY));
IO.mapOptional("GPRSize", Section.GPRSize,
ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
IO.mapOptional("CPR1Size", Section.CPR1Size,
ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
IO.mapOptional("CPR2Size", Section.CPR2Size,
ELFYAML::MIPS_AFL_REG(Mips::AFL_REG_NONE));
IO.mapOptional("Flags1", Section.Flags1, ELFYAML::MIPS_AFL_FLAGS1(0));
IO.mapOptional("Flags2", Section.Flags2, Hex32(0));
}
void MappingTraits<std::unique_ptr<ELFYAML::Section>>::mapping(
IO &IO, std::unique_ptr<ELFYAML::Section> &Section) {
ELFYAML::ELF_SHT sectionType;
if (IO.outputting())
sectionType = Section->Type;
else
IO.mapRequired("Type", sectionType);
switch (sectionType) {
case ELF::SHT_REL:
case ELF::SHT_RELA:
if (!IO.outputting())
Section.reset(new ELFYAML::RelocationSection());
sectionMapping(IO, *cast<ELFYAML::RelocationSection>(Section.get()));
break;
case ELF::SHT_GROUP:
if (!IO.outputting())
Section.reset(new ELFYAML::Group());
groupSectionMapping(IO, *cast<ELFYAML::Group>(Section.get()));
break;
case ELF::SHT_NOBITS:
if (!IO.outputting())
Section.reset(new ELFYAML::NoBitsSection());
sectionMapping(IO, *cast<ELFYAML::NoBitsSection>(Section.get()));
break;
case ELF::SHT_MIPS_ABIFLAGS:
if (!IO.outputting())
Section.reset(new ELFYAML::MipsABIFlags());
sectionMapping(IO, *cast<ELFYAML::MipsABIFlags>(Section.get()));
break;
default:
if (!IO.outputting())
Section.reset(new ELFYAML::RawContentSection());
sectionMapping(IO, *cast<ELFYAML::RawContentSection>(Section.get()));
}
}
StringRef MappingTraits<std::unique_ptr<ELFYAML::Section>>::validate(
IO &io, std::unique_ptr<ELFYAML::Section> &Section) {
const auto *RawSection = dyn_cast<ELFYAML::RawContentSection>(Section.get());
if (!RawSection || RawSection->Size >= RawSection->Content.binary_size())
return StringRef();
return "Section size must be greater or equal to the content size";
}
namespace {
struct NormalizedMips64RelType {
NormalizedMips64RelType(IO &)
: Type(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
Type2(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
Type3(ELFYAML::ELF_REL(ELF::R_MIPS_NONE)),
SpecSym(ELFYAML::ELF_REL(ELF::RSS_UNDEF)) {}
NormalizedMips64RelType(IO &, ELFYAML::ELF_REL Original)
: Type(Original & 0xFF), Type2(Original >> 8 & 0xFF),
Type3(Original >> 16 & 0xFF), SpecSym(Original >> 24 & 0xFF) {}
ELFYAML::ELF_REL denormalize(IO &) {
ELFYAML::ELF_REL Res = Type | Type2 << 8 | Type3 << 16 | SpecSym << 24;
return Res;
}
ELFYAML::ELF_REL Type;
ELFYAML::ELF_REL Type2;
ELFYAML::ELF_REL Type3;
ELFYAML::ELF_RSS SpecSym;
};
}
void MappingTraits<ELFYAML::Relocation>::mapping(IO &IO,
ELFYAML::Relocation &Rel) {
const auto *Object = static_cast<ELFYAML::Object *>(IO.getContext());
assert(Object && "The IO context is not initialized");
IO.mapRequired("Offset", Rel.Offset);
IO.mapRequired("Symbol", Rel.Symbol);
if (Object->Header.Machine == ELFYAML::ELF_EM(ELF::EM_MIPS) &&
Object->Header.Class == ELFYAML::ELF_ELFCLASS(ELF::ELFCLASS64)) {
MappingNormalization<NormalizedMips64RelType, ELFYAML::ELF_REL> Key(
IO, Rel.Type);
IO.mapRequired("Type", Key->Type);
IO.mapOptional("Type2", Key->Type2, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
IO.mapOptional("Type3", Key->Type3, ELFYAML::ELF_REL(ELF::R_MIPS_NONE));
IO.mapOptional("SpecSym", Key->SpecSym, ELFYAML::ELF_RSS(ELF::RSS_UNDEF));
} else
IO.mapRequired("Type", Rel.Type);
IO.mapOptional("Addend", Rel.Addend, (int64_t)0);
}
void MappingTraits<ELFYAML::Object>::mapping(IO &IO, ELFYAML::Object &Object) {
assert(!IO.getContext() && "The IO context is initialized already");
IO.setContext(&Object);
IO.mapTag("!ELF", true);
IO.mapRequired("FileHeader", Object.Header);
IO.mapOptional("Sections", Object.Sections);
IO.mapOptional("Symbols", Object.Symbols);
IO.setContext(nullptr);
}
LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_AFL_REG)
LLVM_YAML_STRONG_TYPEDEF(uint8_t, MIPS_ABI_FP)
LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_EXT)
LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_ASE)
LLVM_YAML_STRONG_TYPEDEF(uint32_t, MIPS_AFL_FLAGS1)
} // end namespace yaml
} // end namespace llvm
| [
"jeffrey.goeders@gmail.com"
] | jeffrey.goeders@gmail.com | |
7a18f60883f05c6dfdffecdb8a2695b5d1531153 | 48997fd1b34a7a1ed05bcee92e76beef39b8fb35 | /EngineCore/Shader.h | 6a69d565b851be4f1d85dad7e19ab2fd4af2dc6d | [] | no_license | EthanNichols/DataVox | db64ff0e2b2967f294d8b8d3baafb6f791e582d3 | cab758d1cc3cb512ac5ee3fe3d6bbe56dd7bd667 | refs/heads/master | 2023-01-14T16:31:51.479141 | 2020-11-20T18:31:11 | 2020-11-20T18:31:11 | 291,543,189 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 952 | h | #pragma once
#include <glm/glm.hpp>
#include <iostream>
#include <string>
class Shader
{
public:
Shader()
{
m_id = 0;
}
Shader(std::string& vertexPath, std::string& fragmentPath);
Shader(const std::string& vertexPath, const std::string& fragmentPath);
~Shader();
void Use();
uint32_t GetID() const;
void SetBool(const std::string& name, bool value) const;
void SetInt(const std::string& name, int value) const;
void SetFloat(const std::string& name, float value) const;
void SetVec2(const std::string& name, const glm::vec2& value) const;
void SetVec3(const std::string& name, const glm::vec3& value) const;
void SetVec4(const std::string& name, const glm::vec4& value) const;
void SetMat4(const std::string& name, const glm::mat4x4& value) const;
private:
void Create(const std::string& vertexPath, const std::string& fragmentPath);
int32_t GetUniformLocation(const std::string& name) const;
private:
uint32_t m_id;
};
| [
"ethan.thomas.nichols@gmail.com"
] | ethan.thomas.nichols@gmail.com |
be940f13c2a01ee8400100509ef0ef67d983bb4b | 8583b5bfc594b994f51d24d012e92ae66bf2e5ea | /src/BabylonCpp/include/babylon/meshes/builders/lathe_builder.h | 65c300ae8d70307bbca89a991a0ac50ac398c482 | [
"LicenseRef-scancode-free-unknown",
"Apache-2.0"
] | permissive | samdauwe/BabylonCpp | 84b8e51b59f04a847681a97fa6fe0a5c554e9e1f | 3dad13a666299cbcf2e2db5b24575c19743e1000 | refs/heads/master | 2022-01-09T02:49:55.057544 | 2022-01-02T19:27:12 | 2022-01-02T19:27:12 | 77,682,359 | 309 | 41 | Apache-2.0 | 2020-11-06T12:16:17 | 2016-12-30T11:29:05 | C++ | UTF-8 | C++ | false | false | 2,960 | h | #ifndef BABYLON_MESHES_BUILDERS_LATHE_BUILDER_H
#define BABYLON_MESHES_BUILDERS_LATHE_BUILDER_H
#include <memory>
#include <string>
#include <babylon/babylon_api.h>
#include <babylon/babylon_fwd.h>
namespace BABYLON {
class LatheOptions;
class Scene;
FWD_CLASS_SPTR(Mesh)
/**
* @brief Class containing static functions to help procedurally build meshes.
*/
struct BABYLON_SHARED_EXPORT LatheBuilder {
// clang-format off
/**
* @brief Creates lathe mesh.
* The lathe is a shape with a symmetry axis : a 2D model shape is rotated around this axis to design the lathe
* * The parameter `shape` is a required array of successive Vector3. This array depicts the shape to be rotated in its local space : the shape must be designed in the xOy plane and will be rotated around the Y axis. It's usually a 2D shape, so the Vector3 z coordinates are often set to zero
* * The parameter `radius` (positive float, default 1) is the radius value of the lathe
* * The parameter `tessellation` (positive integer, default 64) is the side number of the lathe
* * The parameter `clip` (positive integer, default 0) is the number of sides to not create without effecting the general shape of the sides
* * The parameter `arc` (positive float, default 1) is the ratio of the lathe. 0.5 builds for instance half a lathe, so an opened shape
* * The parameter `closed` (boolean, default true) opens/closes the lathe circumference. This should be set to false when used with the parameter "arc"
* * The parameter `cap` sets the way the extruded shape is capped. Possible values : BABYLON.Mesh.NO_CAP (default), BABYLON.Mesh.CAP_START, BABYLON.Mesh.CAP_END, BABYLON.Mesh.CAP_ALL
* * You can also set the mesh side orientation with the values : BABYLON.Mesh.FRONTSIDE (default), BABYLON.Mesh.BACKSIDE or BABYLON.Mesh.DOUBLESIDE
* * If you create a double-sided mesh, you can choose what parts of the texture image to crop and stick respectively on the front and the back sides with the parameters `frontUVs` and `backUVs` (Vector4). Detail here : https://doc.babylonjs.com/babylon101/discover_basic_elements#side-orientation
* * The optional parameter `invertUV` (boolean, default false) swaps in the geometry the U and V coordinates to apply a texture
* * The mesh can be set to updatable with the boolean parameter `updatable` (default false) if its internal geometry is supposed to change once created
* @param name defines the name of the mesh
* @param options defines the options used to create the mesh
* @param scene defines the hosting scene
* @returns the lathe mesh
* @see https://doc.babylonjs.com/how_to/parametric_shapes#lathe
*/
// clang-format on
static MeshPtr CreateLathe(const std::string& name, LatheOptions& options,
Scene* scene = nullptr);
}; // end of struct LatheBuilder
} // end of namespace BABYLON
#endif // end of BABYLON_MESHES_BUILDERS_LATHE_BUILDER_H
| [
"sam.dauwe@gmail.com"
] | sam.dauwe@gmail.com |
848a27f03d84943934f05ea9092650e501e0e1bd | d14b5d78b72711e4614808051c0364b7bd5d6d98 | /third_party/llvm-16.0/llvm/lib/ObjectYAML/MachOYAML.cpp | 8c8b4532dcdec726ad0bfc38b01c42afe5c03a01 | [
"Apache-2.0"
] | permissive | google/swiftshader | 76659addb1c12eb1477050fded1e7d067f2ed25b | 5be49d4aef266ae6dcc95085e1e3011dad0e7eb7 | refs/heads/master | 2023-07-21T23:19:29.415159 | 2023-07-21T19:58:29 | 2023-07-21T20:50:19 | 62,297,898 | 1,981 | 306 | Apache-2.0 | 2023-07-05T21:29:34 | 2016-06-30T09:25:24 | C++ | UTF-8 | C++ | false | false | 24,028 | cpp | //===- MachOYAML.cpp - MachO YAMLIO implementation ------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// This file defines classes for handling the YAML representation of MachO.
//
//===----------------------------------------------------------------------===//
#include "llvm/ObjectYAML/MachOYAML.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/BinaryFormat/MachO.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/Host.h"
#include "llvm/Support/YAMLTraits.h"
#include "llvm/Support/raw_ostream.h"
#include <cinttypes>
#include <cstdint>
#include <cstring>
namespace llvm {
MachOYAML::LoadCommand::~LoadCommand() = default;
bool MachOYAML::LinkEditData::isEmpty() const {
return 0 == RebaseOpcodes.size() + BindOpcodes.size() +
WeakBindOpcodes.size() + LazyBindOpcodes.size() +
ExportTrie.Children.size() + NameList.size() +
StringTable.size() + FunctionStarts.size() +
ChainedFixups.size() + DataInCode.size();
}
namespace yaml {
void ScalarTraits<char_16>::output(const char_16 &Val, void *,
raw_ostream &Out) {
auto Len = strnlen(&Val[0], 16);
Out << StringRef(&Val[0], Len);
}
StringRef ScalarTraits<char_16>::input(StringRef Scalar, void *, char_16 &Val) {
size_t CopySize = 16 >= Scalar.size() ? 16 : Scalar.size();
memcpy((void *)Val, Scalar.data(), CopySize);
if (Scalar.size() < 16) {
memset((void *)&Val[Scalar.size()], 0, 16 - Scalar.size());
}
return StringRef();
}
QuotingType ScalarTraits<char_16>::mustQuote(StringRef S) {
return needsQuotes(S);
}
void ScalarTraits<uuid_t>::output(const uuid_t &Val, void *, raw_ostream &Out) {
Out.write_uuid(Val);
}
StringRef ScalarTraits<uuid_t>::input(StringRef Scalar, void *, uuid_t &Val) {
size_t OutIdx = 0;
for (size_t Idx = 0; Idx < Scalar.size(); ++Idx) {
if (Scalar[Idx] == '-' || OutIdx >= 16)
continue;
unsigned long long TempInt;
if (getAsUnsignedInteger(Scalar.slice(Idx, Idx + 2), 16, TempInt))
return "invalid number";
if (TempInt > 0xFF)
return "out of range number";
Val[OutIdx] = static_cast<uint8_t>(TempInt);
++Idx; // increment idx an extra time because we're consuming 2 chars
++OutIdx;
}
return StringRef();
}
QuotingType ScalarTraits<uuid_t>::mustQuote(StringRef S) {
return needsQuotes(S);
}
void MappingTraits<MachOYAML::FileHeader>::mapping(
IO &IO, MachOYAML::FileHeader &FileHdr) {
IO.mapRequired("magic", FileHdr.magic);
IO.mapRequired("cputype", FileHdr.cputype);
IO.mapRequired("cpusubtype", FileHdr.cpusubtype);
IO.mapRequired("filetype", FileHdr.filetype);
IO.mapRequired("ncmds", FileHdr.ncmds);
IO.mapRequired("sizeofcmds", FileHdr.sizeofcmds);
IO.mapRequired("flags", FileHdr.flags);
if (FileHdr.magic == MachO::MH_MAGIC_64 ||
FileHdr.magic == MachO::MH_CIGAM_64)
IO.mapRequired("reserved", FileHdr.reserved);
}
void MappingTraits<MachOYAML::Object>::mapping(IO &IO,
MachOYAML::Object &Object) {
// If the context isn't already set, tag the document as !mach-o.
// For Fat files there will be a different tag so they can be differentiated.
if (!IO.getContext()) {
IO.setContext(&Object);
}
IO.mapTag("!mach-o", true);
IO.mapOptional("IsLittleEndian", Object.IsLittleEndian,
sys::IsLittleEndianHost);
Object.DWARF.IsLittleEndian = Object.IsLittleEndian;
IO.mapRequired("FileHeader", Object.Header);
Object.DWARF.Is64BitAddrSize = Object.Header.magic == MachO::MH_MAGIC_64 ||
Object.Header.magic == MachO::MH_CIGAM_64;
IO.mapOptional("LoadCommands", Object.LoadCommands);
if (Object.RawLinkEditSegment || !IO.outputting())
IO.mapOptional("__LINKEDIT", Object.RawLinkEditSegment);
if(!Object.LinkEdit.isEmpty() || !IO.outputting())
IO.mapOptional("LinkEditData", Object.LinkEdit);
if(!Object.DWARF.isEmpty() || !IO.outputting())
IO.mapOptional("DWARF", Object.DWARF);
if (IO.getContext() == &Object)
IO.setContext(nullptr);
}
void MappingTraits<MachOYAML::FatHeader>::mapping(
IO &IO, MachOYAML::FatHeader &FatHeader) {
IO.mapRequired("magic", FatHeader.magic);
IO.mapRequired("nfat_arch", FatHeader.nfat_arch);
}
void MappingTraits<MachOYAML::FatArch>::mapping(IO &IO,
MachOYAML::FatArch &FatArch) {
IO.mapRequired("cputype", FatArch.cputype);
IO.mapRequired("cpusubtype", FatArch.cpusubtype);
IO.mapRequired("offset", FatArch.offset);
IO.mapRequired("size", FatArch.size);
IO.mapRequired("align", FatArch.align);
IO.mapOptional("reserved", FatArch.reserved,
static_cast<llvm::yaml::Hex32>(0));
}
void MappingTraits<MachOYAML::UniversalBinary>::mapping(
IO &IO, MachOYAML::UniversalBinary &UniversalBinary) {
if (!IO.getContext()) {
IO.setContext(&UniversalBinary);
IO.mapTag("!fat-mach-o", true);
}
IO.mapRequired("FatHeader", UniversalBinary.Header);
IO.mapRequired("FatArchs", UniversalBinary.FatArchs);
IO.mapRequired("Slices", UniversalBinary.Slices);
if (IO.getContext() == &UniversalBinary)
IO.setContext(nullptr);
}
void MappingTraits<MachOYAML::LinkEditData>::mapping(
IO &IO, MachOYAML::LinkEditData &LinkEditData) {
IO.mapOptional("RebaseOpcodes", LinkEditData.RebaseOpcodes);
IO.mapOptional("BindOpcodes", LinkEditData.BindOpcodes);
IO.mapOptional("WeakBindOpcodes", LinkEditData.WeakBindOpcodes);
IO.mapOptional("LazyBindOpcodes", LinkEditData.LazyBindOpcodes);
if (!LinkEditData.ExportTrie.Children.empty() || !IO.outputting())
IO.mapOptional("ExportTrie", LinkEditData.ExportTrie);
IO.mapOptional("NameList", LinkEditData.NameList);
IO.mapOptional("StringTable", LinkEditData.StringTable);
IO.mapOptional("IndirectSymbols", LinkEditData.IndirectSymbols);
IO.mapOptional("FunctionStarts", LinkEditData.FunctionStarts);
IO.mapOptional("ChainedFixups", LinkEditData.ChainedFixups);
IO.mapOptional("DataInCode", LinkEditData.DataInCode);
}
void MappingTraits<MachOYAML::RebaseOpcode>::mapping(
IO &IO, MachOYAML::RebaseOpcode &RebaseOpcode) {
IO.mapRequired("Opcode", RebaseOpcode.Opcode);
IO.mapRequired("Imm", RebaseOpcode.Imm);
IO.mapOptional("ExtraData", RebaseOpcode.ExtraData);
}
void MappingTraits<MachOYAML::BindOpcode>::mapping(
IO &IO, MachOYAML::BindOpcode &BindOpcode) {
IO.mapRequired("Opcode", BindOpcode.Opcode);
IO.mapRequired("Imm", BindOpcode.Imm);
IO.mapOptional("ULEBExtraData", BindOpcode.ULEBExtraData);
IO.mapOptional("SLEBExtraData", BindOpcode.SLEBExtraData);
IO.mapOptional("Symbol", BindOpcode.Symbol);
}
void MappingTraits<MachOYAML::ExportEntry>::mapping(
IO &IO, MachOYAML::ExportEntry &ExportEntry) {
IO.mapRequired("TerminalSize", ExportEntry.TerminalSize);
IO.mapOptional("NodeOffset", ExportEntry.NodeOffset);
IO.mapOptional("Name", ExportEntry.Name);
IO.mapOptional("Flags", ExportEntry.Flags);
IO.mapOptional("Address", ExportEntry.Address);
IO.mapOptional("Other", ExportEntry.Other);
IO.mapOptional("ImportName", ExportEntry.ImportName);
IO.mapOptional("Children", ExportEntry.Children);
}
void MappingTraits<MachOYAML::NListEntry>::mapping(
IO &IO, MachOYAML::NListEntry &NListEntry) {
IO.mapRequired("n_strx", NListEntry.n_strx);
IO.mapRequired("n_type", NListEntry.n_type);
IO.mapRequired("n_sect", NListEntry.n_sect);
IO.mapRequired("n_desc", NListEntry.n_desc);
IO.mapRequired("n_value", NListEntry.n_value);
}
void MappingTraits<MachOYAML::DataInCodeEntry>::mapping(
IO &IO, MachOYAML::DataInCodeEntry &DataInCodeEntry) {
IO.mapRequired("Offset", DataInCodeEntry.Offset);
IO.mapRequired("Length", DataInCodeEntry.Length);
IO.mapRequired("Kind", DataInCodeEntry.Kind);
}
template <typename StructType>
void mapLoadCommandData(IO &IO, MachOYAML::LoadCommand &LoadCommand) {}
template <>
void mapLoadCommandData<MachO::segment_command>(
IO &IO, MachOYAML::LoadCommand &LoadCommand) {
IO.mapOptional("Sections", LoadCommand.Sections);
}
template <>
void mapLoadCommandData<MachO::segment_command_64>(
IO &IO, MachOYAML::LoadCommand &LoadCommand) {
IO.mapOptional("Sections", LoadCommand.Sections);
}
template <>
void mapLoadCommandData<MachO::dylib_command>(
IO &IO, MachOYAML::LoadCommand &LoadCommand) {
IO.mapOptional("Content", LoadCommand.Content);
}
template <>
void mapLoadCommandData<MachO::rpath_command>(
IO &IO, MachOYAML::LoadCommand &LoadCommand) {
IO.mapOptional("Content", LoadCommand.Content);
}
template <>
void mapLoadCommandData<MachO::dylinker_command>(
IO &IO, MachOYAML::LoadCommand &LoadCommand) {
IO.mapOptional("Content", LoadCommand.Content);
}
template <>
void mapLoadCommandData<MachO::sub_framework_command>(
IO &IO, MachOYAML::LoadCommand &LoadCommand) {
IO.mapOptional("Content", LoadCommand.Content);
}
template <>
void mapLoadCommandData<MachO::sub_umbrella_command>(
IO &IO, MachOYAML::LoadCommand &LoadCommand) {
IO.mapOptional("Content", LoadCommand.Content);
}
template <>
void mapLoadCommandData<MachO::sub_client_command>(
IO &IO, MachOYAML::LoadCommand &LoadCommand) {
IO.mapOptional("Content", LoadCommand.Content);
}
template <>
void mapLoadCommandData<MachO::sub_library_command>(
IO &IO, MachOYAML::LoadCommand &LoadCommand) {
IO.mapOptional("Content", LoadCommand.Content);
}
template <>
void mapLoadCommandData<MachO::build_version_command>(
IO &IO, MachOYAML::LoadCommand &LoadCommand) {
IO.mapOptional("Tools", LoadCommand.Tools);
}
void MappingTraits<MachOYAML::LoadCommand>::mapping(
IO &IO, MachOYAML::LoadCommand &LoadCommand) {
MachO::LoadCommandType TempCmd = static_cast<MachO::LoadCommandType>(
LoadCommand.Data.load_command_data.cmd);
IO.mapRequired("cmd", TempCmd);
LoadCommand.Data.load_command_data.cmd = TempCmd;
IO.mapRequired("cmdsize", LoadCommand.Data.load_command_data.cmdsize);
#define HANDLE_LOAD_COMMAND(LCName, LCValue, LCStruct) \
case MachO::LCName: \
MappingTraits<MachO::LCStruct>::mapping(IO, \
LoadCommand.Data.LCStruct##_data); \
mapLoadCommandData<MachO::LCStruct>(IO, LoadCommand); \
break;
switch (LoadCommand.Data.load_command_data.cmd) {
#include "llvm/BinaryFormat/MachO.def"
}
IO.mapOptional("PayloadBytes", LoadCommand.PayloadBytes);
IO.mapOptional("ZeroPadBytes", LoadCommand.ZeroPadBytes, (uint64_t)0ull);
}
void MappingTraits<MachO::dyld_info_command>::mapping(
IO &IO, MachO::dyld_info_command &LoadCommand) {
IO.mapRequired("rebase_off", LoadCommand.rebase_off);
IO.mapRequired("rebase_size", LoadCommand.rebase_size);
IO.mapRequired("bind_off", LoadCommand.bind_off);
IO.mapRequired("bind_size", LoadCommand.bind_size);
IO.mapRequired("weak_bind_off", LoadCommand.weak_bind_off);
IO.mapRequired("weak_bind_size", LoadCommand.weak_bind_size);
IO.mapRequired("lazy_bind_off", LoadCommand.lazy_bind_off);
IO.mapRequired("lazy_bind_size", LoadCommand.lazy_bind_size);
IO.mapRequired("export_off", LoadCommand.export_off);
IO.mapRequired("export_size", LoadCommand.export_size);
}
void MappingTraits<MachOYAML::Relocation>::mapping(
IO &IO, MachOYAML::Relocation &Relocation) {
IO.mapRequired("address", Relocation.address);
IO.mapRequired("symbolnum", Relocation.symbolnum);
IO.mapRequired("pcrel", Relocation.is_pcrel);
IO.mapRequired("length", Relocation.length);
IO.mapRequired("extern", Relocation.is_extern);
IO.mapRequired("type", Relocation.type);
IO.mapRequired("scattered", Relocation.is_scattered);
IO.mapRequired("value", Relocation.value);
}
void MappingTraits<MachOYAML::Section>::mapping(IO &IO,
MachOYAML::Section &Section) {
IO.mapRequired("sectname", Section.sectname);
IO.mapRequired("segname", Section.segname);
IO.mapRequired("addr", Section.addr);
IO.mapRequired("size", Section.size);
IO.mapRequired("offset", Section.offset);
IO.mapRequired("align", Section.align);
IO.mapRequired("reloff", Section.reloff);
IO.mapRequired("nreloc", Section.nreloc);
IO.mapRequired("flags", Section.flags);
IO.mapRequired("reserved1", Section.reserved1);
IO.mapRequired("reserved2", Section.reserved2);
IO.mapOptional("reserved3", Section.reserved3);
IO.mapOptional("content", Section.content);
IO.mapOptional("relocations", Section.relocations);
}
std::string
MappingTraits<MachOYAML::Section>::validate(IO &IO,
MachOYAML::Section &Section) {
if (Section.content && Section.size < Section.content->binary_size())
return "Section size must be greater than or equal to the content size";
return "";
}
void MappingTraits<MachO::build_tool_version>::mapping(
IO &IO, MachO::build_tool_version &tool) {
IO.mapRequired("tool", tool.tool);
IO.mapRequired("version", tool.version);
}
void MappingTraits<MachO::dylib>::mapping(IO &IO, MachO::dylib &DylibStruct) {
IO.mapRequired("name", DylibStruct.name);
IO.mapRequired("timestamp", DylibStruct.timestamp);
IO.mapRequired("current_version", DylibStruct.current_version);
IO.mapRequired("compatibility_version", DylibStruct.compatibility_version);
}
void MappingTraits<MachO::dylib_command>::mapping(
IO &IO, MachO::dylib_command &LoadCommand) {
IO.mapRequired("dylib", LoadCommand.dylib);
}
void MappingTraits<MachO::dylinker_command>::mapping(
IO &IO, MachO::dylinker_command &LoadCommand) {
IO.mapRequired("name", LoadCommand.name);
}
void MappingTraits<MachO::dysymtab_command>::mapping(
IO &IO, MachO::dysymtab_command &LoadCommand) {
IO.mapRequired("ilocalsym", LoadCommand.ilocalsym);
IO.mapRequired("nlocalsym", LoadCommand.nlocalsym);
IO.mapRequired("iextdefsym", LoadCommand.iextdefsym);
IO.mapRequired("nextdefsym", LoadCommand.nextdefsym);
IO.mapRequired("iundefsym", LoadCommand.iundefsym);
IO.mapRequired("nundefsym", LoadCommand.nundefsym);
IO.mapRequired("tocoff", LoadCommand.tocoff);
IO.mapRequired("ntoc", LoadCommand.ntoc);
IO.mapRequired("modtaboff", LoadCommand.modtaboff);
IO.mapRequired("nmodtab", LoadCommand.nmodtab);
IO.mapRequired("extrefsymoff", LoadCommand.extrefsymoff);
IO.mapRequired("nextrefsyms", LoadCommand.nextrefsyms);
IO.mapRequired("indirectsymoff", LoadCommand.indirectsymoff);
IO.mapRequired("nindirectsyms", LoadCommand.nindirectsyms);
IO.mapRequired("extreloff", LoadCommand.extreloff);
IO.mapRequired("nextrel", LoadCommand.nextrel);
IO.mapRequired("locreloff", LoadCommand.locreloff);
IO.mapRequired("nlocrel", LoadCommand.nlocrel);
}
void MappingTraits<MachO::encryption_info_command>::mapping(
IO &IO, MachO::encryption_info_command &LoadCommand) {
IO.mapRequired("cryptoff", LoadCommand.cryptoff);
IO.mapRequired("cryptsize", LoadCommand.cryptsize);
IO.mapRequired("cryptid", LoadCommand.cryptid);
}
void MappingTraits<MachO::encryption_info_command_64>::mapping(
IO &IO, MachO::encryption_info_command_64 &LoadCommand) {
IO.mapRequired("cryptoff", LoadCommand.cryptoff);
IO.mapRequired("cryptsize", LoadCommand.cryptsize);
IO.mapRequired("cryptid", LoadCommand.cryptid);
IO.mapRequired("pad", LoadCommand.pad);
}
void MappingTraits<MachO::entry_point_command>::mapping(
IO &IO, MachO::entry_point_command &LoadCommand) {
IO.mapRequired("entryoff", LoadCommand.entryoff);
IO.mapRequired("stacksize", LoadCommand.stacksize);
}
void MappingTraits<MachO::fvmfile_command>::mapping(
IO &IO, MachO::fvmfile_command &LoadCommand) {
IO.mapRequired("name", LoadCommand.name);
IO.mapRequired("header_addr", LoadCommand.header_addr);
}
void MappingTraits<MachO::fvmlib>::mapping(IO &IO, MachO::fvmlib &FVMLib) {
IO.mapRequired("name", FVMLib.name);
IO.mapRequired("minor_version", FVMLib.minor_version);
IO.mapRequired("header_addr", FVMLib.header_addr);
}
void MappingTraits<MachO::fvmlib_command>::mapping(
IO &IO, MachO::fvmlib_command &LoadCommand) {
IO.mapRequired("fvmlib", LoadCommand.fvmlib);
}
void MappingTraits<MachO::ident_command>::mapping(
IO &IO, MachO::ident_command &LoadCommand) {}
void MappingTraits<MachO::linkedit_data_command>::mapping(
IO &IO, MachO::linkedit_data_command &LoadCommand) {
IO.mapRequired("dataoff", LoadCommand.dataoff);
IO.mapRequired("datasize", LoadCommand.datasize);
}
void MappingTraits<MachO::linker_option_command>::mapping(
IO &IO, MachO::linker_option_command &LoadCommand) {
IO.mapRequired("count", LoadCommand.count);
}
void MappingTraits<MachO::prebind_cksum_command>::mapping(
IO &IO, MachO::prebind_cksum_command &LoadCommand) {
IO.mapRequired("cksum", LoadCommand.cksum);
}
void MappingTraits<MachO::load_command>::mapping(
IO &IO, MachO::load_command &LoadCommand) {}
void MappingTraits<MachO::prebound_dylib_command>::mapping(
IO &IO, MachO::prebound_dylib_command &LoadCommand) {
IO.mapRequired("name", LoadCommand.name);
IO.mapRequired("nmodules", LoadCommand.nmodules);
IO.mapRequired("linked_modules", LoadCommand.linked_modules);
}
void MappingTraits<MachO::routines_command>::mapping(
IO &IO, MachO::routines_command &LoadCommand) {
IO.mapRequired("init_address", LoadCommand.init_address);
IO.mapRequired("init_module", LoadCommand.init_module);
IO.mapRequired("reserved1", LoadCommand.reserved1);
IO.mapRequired("reserved2", LoadCommand.reserved2);
IO.mapRequired("reserved3", LoadCommand.reserved3);
IO.mapRequired("reserved4", LoadCommand.reserved4);
IO.mapRequired("reserved5", LoadCommand.reserved5);
IO.mapRequired("reserved6", LoadCommand.reserved6);
}
void MappingTraits<MachO::routines_command_64>::mapping(
IO &IO, MachO::routines_command_64 &LoadCommand) {
IO.mapRequired("init_address", LoadCommand.init_address);
IO.mapRequired("init_module", LoadCommand.init_module);
IO.mapRequired("reserved1", LoadCommand.reserved1);
IO.mapRequired("reserved2", LoadCommand.reserved2);
IO.mapRequired("reserved3", LoadCommand.reserved3);
IO.mapRequired("reserved4", LoadCommand.reserved4);
IO.mapRequired("reserved5", LoadCommand.reserved5);
IO.mapRequired("reserved6", LoadCommand.reserved6);
}
void MappingTraits<MachO::rpath_command>::mapping(
IO &IO, MachO::rpath_command &LoadCommand) {
IO.mapRequired("path", LoadCommand.path);
}
void MappingTraits<MachO::section>::mapping(IO &IO, MachO::section &Section) {
IO.mapRequired("sectname", Section.sectname);
IO.mapRequired("segname", Section.segname);
IO.mapRequired("addr", Section.addr);
IO.mapRequired("size", Section.size);
IO.mapRequired("offset", Section.offset);
IO.mapRequired("align", Section.align);
IO.mapRequired("reloff", Section.reloff);
IO.mapRequired("nreloc", Section.nreloc);
IO.mapRequired("flags", Section.flags);
IO.mapRequired("reserved1", Section.reserved1);
IO.mapRequired("reserved2", Section.reserved2);
}
void MappingTraits<MachO::section_64>::mapping(IO &IO,
MachO::section_64 &Section) {
IO.mapRequired("sectname", Section.sectname);
IO.mapRequired("segname", Section.segname);
IO.mapRequired("addr", Section.addr);
IO.mapRequired("size", Section.size);
IO.mapRequired("offset", Section.offset);
IO.mapRequired("align", Section.align);
IO.mapRequired("reloff", Section.reloff);
IO.mapRequired("nreloc", Section.nreloc);
IO.mapRequired("flags", Section.flags);
IO.mapRequired("reserved1", Section.reserved1);
IO.mapRequired("reserved2", Section.reserved2);
IO.mapRequired("reserved3", Section.reserved3);
}
void MappingTraits<MachO::segment_command>::mapping(
IO &IO, MachO::segment_command &LoadCommand) {
IO.mapRequired("segname", LoadCommand.segname);
IO.mapRequired("vmaddr", LoadCommand.vmaddr);
IO.mapRequired("vmsize", LoadCommand.vmsize);
IO.mapRequired("fileoff", LoadCommand.fileoff);
IO.mapRequired("filesize", LoadCommand.filesize);
IO.mapRequired("maxprot", LoadCommand.maxprot);
IO.mapRequired("initprot", LoadCommand.initprot);
IO.mapRequired("nsects", LoadCommand.nsects);
IO.mapRequired("flags", LoadCommand.flags);
}
void MappingTraits<MachO::segment_command_64>::mapping(
IO &IO, MachO::segment_command_64 &LoadCommand) {
IO.mapRequired("segname", LoadCommand.segname);
IO.mapRequired("vmaddr", LoadCommand.vmaddr);
IO.mapRequired("vmsize", LoadCommand.vmsize);
IO.mapRequired("fileoff", LoadCommand.fileoff);
IO.mapRequired("filesize", LoadCommand.filesize);
IO.mapRequired("maxprot", LoadCommand.maxprot);
IO.mapRequired("initprot", LoadCommand.initprot);
IO.mapRequired("nsects", LoadCommand.nsects);
IO.mapRequired("flags", LoadCommand.flags);
}
void MappingTraits<MachO::source_version_command>::mapping(
IO &IO, MachO::source_version_command &LoadCommand) {
IO.mapRequired("version", LoadCommand.version);
}
void MappingTraits<MachO::sub_client_command>::mapping(
IO &IO, MachO::sub_client_command &LoadCommand) {
IO.mapRequired("client", LoadCommand.client);
}
void MappingTraits<MachO::sub_framework_command>::mapping(
IO &IO, MachO::sub_framework_command &LoadCommand) {
IO.mapRequired("umbrella", LoadCommand.umbrella);
}
void MappingTraits<MachO::sub_library_command>::mapping(
IO &IO, MachO::sub_library_command &LoadCommand) {
IO.mapRequired("sub_library", LoadCommand.sub_library);
}
void MappingTraits<MachO::sub_umbrella_command>::mapping(
IO &IO, MachO::sub_umbrella_command &LoadCommand) {
IO.mapRequired("sub_umbrella", LoadCommand.sub_umbrella);
}
void MappingTraits<MachO::symseg_command>::mapping(
IO &IO, MachO::symseg_command &LoadCommand) {
IO.mapRequired("offset", LoadCommand.offset);
IO.mapRequired("size", LoadCommand.size);
}
void MappingTraits<MachO::symtab_command>::mapping(
IO &IO, MachO::symtab_command &LoadCommand) {
IO.mapRequired("symoff", LoadCommand.symoff);
IO.mapRequired("nsyms", LoadCommand.nsyms);
IO.mapRequired("stroff", LoadCommand.stroff);
IO.mapRequired("strsize", LoadCommand.strsize);
}
void MappingTraits<MachO::thread_command>::mapping(
IO &IO, MachO::thread_command &LoadCommand) {}
void MappingTraits<MachO::twolevel_hints_command>::mapping(
IO &IO, MachO::twolevel_hints_command &LoadCommand) {
IO.mapRequired("offset", LoadCommand.offset);
IO.mapRequired("nhints", LoadCommand.nhints);
}
void MappingTraits<MachO::uuid_command>::mapping(
IO &IO, MachO::uuid_command &LoadCommand) {
IO.mapRequired("uuid", LoadCommand.uuid);
}
void MappingTraits<MachO::version_min_command>::mapping(
IO &IO, MachO::version_min_command &LoadCommand) {
IO.mapRequired("version", LoadCommand.version);
IO.mapRequired("sdk", LoadCommand.sdk);
}
void MappingTraits<MachO::note_command>::mapping(
IO &IO, MachO::note_command &LoadCommand) {
IO.mapRequired("data_owner", LoadCommand.data_owner);
IO.mapRequired("offset", LoadCommand.offset);
IO.mapRequired("size", LoadCommand.size);
}
void MappingTraits<MachO::build_version_command>::mapping(
IO &IO, MachO::build_version_command &LoadCommand) {
IO.mapRequired("platform", LoadCommand.platform);
IO.mapRequired("minos", LoadCommand.minos);
IO.mapRequired("sdk", LoadCommand.sdk);
IO.mapRequired("ntools", LoadCommand.ntools);
}
void MappingTraits<MachO::fileset_entry_command>::mapping(
IO &IO, MachO::fileset_entry_command &LoadCommand) {
IO.mapRequired("vmaddr", LoadCommand.vmaddr);
IO.mapRequired("fileoff", LoadCommand.fileoff);
IO.mapRequired("id", LoadCommand.entry_id);
}
} // end namespace yaml
} // end namespace llvm
| [
"swiftshader-scoped@luci-project-accounts.iam.gserviceaccount.com"
] | swiftshader-scoped@luci-project-accounts.iam.gserviceaccount.com |
bfddb7ff274ffdf562e03ae09a06bd1d629fdb1a | 43edde90fdb5ca509b43e43f0c16864f32227c98 | /MSerialsCore/Preferences/Preferences.cpp | e176013e7bd0810a6494ce5efa2184a0cbc7c119 | [] | no_license | MSerials/PunchNew | 97183ba79b89d95a91013d6ba719211be341b2c9 | 93cd7ea9a2b86a4ee8c0c36ac7207f9de7fc4b63 | refs/heads/master | 2020-08-18T05:21:46.249881 | 2019-11-14T08:19:59 | 2019-11-14T08:19:59 | 215,752,172 | 2 | 1 | null | null | null | null | GB18030 | C++ | false | false | 34,979 | cpp | #include "../../stdafx.h"
// Preferences.cpp: implementation of the CPreferences class.
//
//////////////////////////////////////////////////////////////////////
#include "Preferences.h"
#include <fstream>
#pragma warning(disable:4996)
using namespace std;
//CPreferences *ini = NULL;
//////////////////////////////////////////////////////////////////////
// Construction/Destruction
//////////////////////////////////////////////////////////////////////
CPreferences::CPreferences()
{
path = L"";
dir = L"";
Reset();
initData();
}
CPreferences::~CPreferences()
{
}
//constructor, can specify pathname here instead of using SetPath later
void CPreferences::CreateIniFile(CString fileName)
{
CString strCurDir;
strCurDir = dir + L"\\" + fileName;
HANDLE hf = CreateFile(strCurDir, GENERIC_WRITE, FILE_SHARE_READ, NULL,CREATE_NEW, NULL, NULL);
CloseHandle(hf);
path = strCurDir;
}
void CPreferences::DeleteIniFile(CString fileName)
{
CString strCurDir;
strCurDir = dir + "\\" + fileName;
DeleteFile(strCurDir);
}
void CPreferences::CopyIniFile(CString srcName, CString dstName)
{
CString strOldPath,strNewPath;
strOldPath = dir + "\\" + srcName;
strNewPath = dir + "\\" + dstName;
CopyFile(strOldPath,strNewPath,FALSE);
}
int CPreferences::SetIniFile(CString fileName)
{
if (dir == "")
{
AfxMessageBox(L"่ฏทๅ
่ฎพ็ฝฎๆไปถ็ฎๅฝ!");
return -1;
}
else
{
path = dir + L"\\" + fileName;
}
if (!PathFileExists(path))
{
HANDLE hf = CreateFile(path, GENERIC_WRITE, FILE_SHARE_READ, NULL,CREATE_NEW, NULL, NULL);
CloseHandle(hf);
return 0;
}
return 1;
}
CString CPreferences::GetAllFileName(CString suffix, int &nCnt, TCHAR separ)
{
CString sFileName;
CFileFind finder;
CString rStr;
CString strWildcard;
rStr.Empty();
nCnt=0;
strWildcard = dir + L"\\*" + suffix;
BOOL bWorking = finder.FindFile(strWildcard);
if (dir == L"")
{
AfxMessageBox(L"่ฏทๅ
่ฎพ็ฝฎๆไปถ็ฎๅฝ!");
return L"";
}
while (bWorking)
{
sFileName.Empty();
bWorking = finder.FindNextFile();
if (finder.IsDots()) continue;
sFileName = finder.GetFileName();
sFileName = sFileName.Left(sFileName.ReverseFind('.')) + separ;
rStr += sFileName;
nCnt++;
}
rStr.TrimRight(separ);
return rStr;
}
CString CPreferences::SplitString(CString srcStr, int nIndex, TCHAR separ/* = */)
{
int i, len =0;
CString strSplit;
srcStr.TrimRight(separ);
for(i=0; i<srcStr.GetLength(); i++)
{
if(srcStr[i] == separ) len++;
}
if ((nIndex>len) || (srcStr==L"")) return L"";
AfxExtractSubString(strSplit, srcStr, nIndex, separ);
return strSplit;
}
/////////////////////////////////////////////////////////////////////
// Public Functions
/////////////////////////////////////////////////////////////////////
//sets path of ini file to read and write from
bool CPreferences::SetIniDir(CString filedir, bool bmodule/* =true */)
{
if (bmodule)
dir = GetModulePath() + "\\" + filedir;
else
dir = filedir;
return CreateMultipleDirectory(dir);
}
//reads ini file specified using CIniFile::SetPath()
//returns true if successful, false otherwise
bool CPreferences::ReadFile()
{
CFile file;
CFileStatus status;
if (!file.GetStatus(path,status))
return 0;
ifstream inifile;
CString readinfo;
inifile.open(path);
int curkey = -1, curval = -1;
if (inifile.fail())
{
error = "ๆๅผๆไปถๅบ้.";
return 0;
}
CString keyname, valuename, _value;
CString temp;
while (getline(inifile,readinfo))
{
if (readinfo != "")
{
if (readinfo[0] == '[' && readinfo[readinfo.GetLength()-1] == ']') //if a section heading
{
//ๅปๆ[]
keyname = readinfo;
keyname.TrimLeft('[');
keyname.TrimRight(']');
}
else //if a value
{
valuename = readinfo.Left(readinfo.Find(L"="));
_value = readinfo.Right(readinfo.GetLength()-valuename.GetLength()-1);
SetValue(keyname,valuename,_value);
}
}
}
inifile.close();
return 1;
}
//writes data stored in class to ini file
void CPreferences::WriteFile()
{
FILE *fp;
fp=_tfopen(path,L"wt");
if(fp==(FILE*)NULL)
{
return ;
}
for (int keynum = 0; keynum <= names.GetUpperBound(); keynum++)
{
if (keys[keynum].names.GetSize() != 0)
{
_ftprintf(fp,_T("[%s]\n"),names[keynum]);
for (int valuenum = 0; valuenum <= keys[keynum].names.GetUpperBound(); valuenum++)
{
CString strtemp=keys[keynum].names[valuenum];
CString strtemp1=keys[keynum].values[valuenum];
_ftprintf(fp,_T("%s=%s"),strtemp,strtemp1);
if (valuenum != keys[keynum].names.GetUpperBound())
_ftprintf(fp,_T("\n"));
else
if (keynum < names.GetSize())
_ftprintf(fp,_T("\n"));
}
if (keynum < names.GetSize())
_ftprintf(fp,_T("\n"));
}
}
fclose(fp);
}
//deletes all stored ini data
void CPreferences::Reset()
{
keys.SetSize(0);
names.SetSize(0);
}
//returns number of keys currently in the ini
int CPreferences::GetNumKeys()
{
return keys.GetSize();
}
//returns number of values stored for specified key, or -1 if key found
int CPreferences::GetNumValues(CString keyname)
{
int keynum = FindKey(keyname);
if (keynum == -1)
return -1;
else
return keys[keynum].names.GetSize();
}
//gets value of [keyname] valuename =
//overloaded to return CString, int, and double
CString CPreferences::GetValue(CString keyname, CString valuename)
{
int keynum = FindKey(keyname), valuenum = FindValue(keynum,valuename);
if (keynum == -1)
{
error = L"ๆฒกๆๆญค้กน"+keyname;
return L"";
}
if (valuenum == -1)
{
error = L"ๆฒกๆๆญค้กน"+valuename;
return L"";
}
return keys[keynum].values[valuenum];
}
//gets value of [keyname] valuename =
//overloaded to return CString, int, and double
int CPreferences::GetValueI(CString keyname, CString valuename)
{
return _tstoi(GetValue(keyname,valuename));
}
//gets value of [keyname] valuename =
//overloaded to return CString, int, and double
double CPreferences::GetValueF(CString keyname, CString valuename)
{
return _tstof(GetValue(keyname, valuename));
}
CString CPreferences::GetValueStr(CString keyname, CString valuename)
{
return GetValue(keyname, valuename);
}
bool CPreferences::GetValuebool(CString keyname,CString valuename)
{
return (GetValue(keyname,valuename)==L"0")?false:true;
}
//sets value of [keyname] valuename =.
//specify the optional paramter as false (0) if you do not want it to create
//the key if it doesn't exist. Returns true if data entered, false otherwise
//overloaded to accept CString, int, and double
bool CPreferences::SetValue(CString keyname, CString valuename, CString value, bool create)
{
int keynum = FindKey(keyname), valuenum = 0;
//find key
if (keynum == -1) //if key doesn't exist
{
if (!create) //and user does not want to create it,
return 0; //stop entering this key
names.SetSize(names.GetSize()+1);
keys.SetSize(keys.GetSize()+1);
keynum = names.GetSize()-1;
names[keynum] = keyname;
}
//find value
valuenum = FindValue(keynum,valuename);
if (valuenum == -1)
{
if (!create)
return 0;
keys[keynum].names.SetSize(keys[keynum].names.GetSize()+1);
keys[keynum].values.SetSize(keys[keynum].names.GetSize()+1);
valuenum = keys[keynum].names.GetSize()-1;
keys[keynum].names[valuenum] = valuename;
}
keys[keynum].values[valuenum] = value;
return 1;
}
//sets value of [keyname] valuename =.
//specify the optional paramter as false (0) if you do not want it to create
//the key if it doesn't exist. Returns true if data entered, false otherwise
//overloaded to accept CString, int, and double
bool CPreferences::SetValueI(CString keyname, CString valuename, int value, bool create)
{
CString temp;
temp.Format(L"%d",value);
return SetValue(keyname, valuename, temp, create);
}
//sets value of [keyname] valuename =.
//specify the optional paramter as false (0) if you do not want it to create
//the key if it doesn't exist. Returns true if data entered, false otherwise
//overloaded to accept CString, int, and double
bool CPreferences::SetValueF(CString keyname, CString valuename, double value, bool create)
{
CString temp;
temp.Format(L"%e",value);
return SetValue(keyname, valuename, temp, create);
}
bool CPreferences::SetValueStr(CString keyname, CString valuename,CString value,bool create)
{
return SetValue(keyname, valuename, value, create);
}
bool CPreferences::SetValuebool(CString keyname,CString valuename,bool value,bool create)
{
CString temp;
if(value==false)
temp=L"0";
else
temp=L"1";
return SetValue(keyname, valuename, temp, create);
}
/////////////////////////////////////////////////////////////////////
// Private Functions
/////////////////////////////////////////////////////////////////////
//returns index of specified key, or -1 if not found
int CPreferences::FindKey(CString keyname)
{
int keynum = 0;
while ( keynum < keys.GetSize() && names[keynum] != keyname)
keynum++;
if (keynum == keys.GetSize())
return -1;
return keynum;
}
//returns index of specified value, in the specified key, or -1 if not found
int CPreferences::FindValue(int keynum, CString valuename)
{
if (keynum == -1)
return -1;
int valuenum = 0;
while (valuenum < keys[keynum].names.GetSize() && keys[keynum].names[valuenum] != valuename)
valuenum++;
if (valuenum == keys[keynum].names.GetSize())
return -1;
return valuenum;
}
//overloaded from original getline to take CString
istream & CPreferences:: getline(istream & is, CString & str)
{
char buf[2048];
is.getline(buf,2048);
str = buf;
return is;
}
void CPreferences::OpenIniFile()
{
::ShellExecute(NULL,L"open",path,NULL,NULL,SW_SHOW);
}
CString CPreferences::GetFilePath()
{
return path;
}
CString CPreferences::GetFileDir()
{
return dir;
}
CString CPreferences::GetModulePath()
{
TCHAR szModulePath[MAX_PATH] = {0};
CString strCurDir;
::GetModuleFileName(NULL,szModulePath,_MAX_PATH);
strCurDir = szModulePath;
strCurDir = strCurDir.Left(strCurDir.ReverseFind(TEXT('\\')));
return strCurDir;
}
bool CPreferences::CreateMultipleDirectory(CString szPath)
{
if (szPath == _T("")) return false;
CString strDir(szPath);
if (strDir.GetAt(strDir.GetLength()-1)!=_T('\\'))
{
strDir += _T('\\');
}
std::vector<CString> vPath;
CString strTemp;
bool bSuccess = false;
for (int i=0;i<strDir.GetLength();++i)
{
if (strDir.GetAt(i) != _T('\\'))
{
strTemp += strDir.GetAt(i);
}
else
{
vPath.push_back(strTemp);
strTemp += _T('\\');
}
}
std::vector<CString>::const_iterator vIter;
for (vIter = vPath.begin(); vIter != vPath.end(); vIter++)
{
bSuccess = CreateDirectory(*vIter, NULL) ? true : false;
}
return bSuccess;
}
int CPreferences::SelFolder(CWnd *pWnd, CString &strFolder)
{
HWND hParent = pWnd->m_hWnd;
LPMALLOC lpMalloc;
strFolder.Empty();
if (::SHGetMalloc(&lpMalloc) != NOERROR) return 0;
TCHAR szDisplayName[_MAX_PATH];
TCHAR szBuffer[_MAX_PATH];
BROWSEINFO browseInfo;
browseInfo.hwndOwner = hParent;
browseInfo.pidlRoot = NULL; // set root at Desktop
browseInfo.pszDisplayName = szDisplayName;
browseInfo.lpszTitle = L"Select a folder";
browseInfo.ulFlags = BIF_RETURNFSANCESTORS|BIF_RETURNONLYFSDIRS;
browseInfo.lpfn = NULL;
browseInfo.lParam = 0;
LPITEMIDLIST lpItemIDList;
if ((lpItemIDList = ::SHBrowseForFolder(&browseInfo)) != NULL)
{
// Get the path of the selected folder from the item ID list.
if (::SHGetPathFromIDList(lpItemIDList, szBuffer))
{
// At this point, szBuffer contains the path the user chose.
if (szBuffer[0] == '\0') return 0;
// We have a path in szBuffer! Return it.
strFolder = szBuffer;
return 1;
}
else return 1; // strResult is empty
lpMalloc->Free(lpItemIDList);
lpMalloc->Release();
}
return 1;
}
CString CPreferences::Encrypt(CString Source, WORD Key) // ๅ ๅฏๅฝๆฐ
{
CString Result,str;
int i,j;
Result=Source; // ๅๅงๅ็ปๆๅญ็ฌฆไธฒ
for(i=0; i<Source.GetLength(); i++) // ไพๆฌกๅฏนๅญ็ฌฆไธฒไธญๅๅญ็ฌฆ่ฟ่กๆไฝ
{
Result.SetAt(i, Source.GetAt(i)^(Key>>8)); // ๅฐๅฏ้ฅ็งปไฝๅไธๅญ็ฌฆๅผๆ
Key = ((BYTE)Result.GetAt(i)+Key)*C1+C2; // ไบง็ไธไธไธชๅฏ้ฅ
}
Source=Result; // ไฟๅญ็ปๆ
Result.Empty(); // ๆธ
้ค็ปๆ
for(i=0; i<Source.GetLength(); i++) // ๅฏนๅ ๅฏ็ปๆ่ฟ่ก่ฝฌๆข
{
j=(BYTE)Source.GetAt(i); // ๆๅๅญ็ฌฆ
// ๅฐๅญ็ฌฆ่ฝฌๆขไธบไธคไธชๅญๆฏไฟๅญ
str=L"12"; // ่ฎพ็ฝฎstr้ฟๅบฆไธบ2
str.SetAt(0, SHIFT+j/26);//่ฟ้ๅฐ65ๆนๅคง็น็ๆฐไพๅฆ256๏ผๅฏๆๅฐฑไผๅไนฑ็ ๏ผๆๆๆดๅฅฝ๏ผ็ธๅบ็๏ผ่งฃๅฏๅค่ฆๆนไธบ็ธๅ็ๆฐ
str.SetAt(1, SHIFT+j%26);
Result += str;
}
return Result;
}
CString CPreferences::Decrypt(CString Source, WORD Key) // ่งฃๅฏๅฝๆฐ
{
CString Result,str;
int i,j;
Result.Empty(); // ๆธ
้ค็ปๆ
for(i=0; i < Source.GetLength()/2; i++) // ๅฐๅญ็ฌฆไธฒไธคไธชๅญๆฏไธ็ป่ฟ่กๅค็
{
j = ((BYTE)Source.GetAt(2*i)-SHIFT)*26;//็ธๅบ็๏ผ่งฃๅฏๅค่ฆๆนไธบ็ธๅ็ๆฐ
j += (BYTE)Source.GetAt(2*i+1)-SHIFT;
str="1"; // ่ฎพ็ฝฎstr้ฟๅบฆไธบ1
str.SetAt(0, j);
Result+=str; // ่ฟฝๅ ๅญ็ฌฆ๏ผ่ฟๅๅญ็ฌฆไธฒ
}
Source=Result; // ไฟๅญไธญ้ด็ปๆ
for(i=0; i<Source.GetLength(); i++) // ไพๆฌกๅฏนๅญ็ฌฆไธฒไธญๅๅญ็ฌฆ่ฟ่กๆไฝ
{
Result.SetAt(i, (BYTE)Source.GetAt(i)^(Key>>8)); // ๅฐๅฏ้ฅ็งปไฝๅไธๅญ็ฌฆๅผๆ
Key = ((BYTE)Source.GetAt(i)+Key)*C1+C2; // ไบง็ไธไธไธชๅฏ้ฅ
}
return Result;
}
void CPreferences::LoadParaFile(UINT item)
{
UINT mask = item;
if (ReadFile())
{
////////////////////////////////////
if (PARA_PRJ == (mask&PARA_PRJ))
{
//m_strCurrentProjectName = GetValue(L"projectSetting",L"CurrentProject");
m_Prj_Vector = GetValue(L"projectSetting", L"PRJ_VECTOR");
m_Prj_Index =GetValueI(L"projectSetting", L"PRJ_IDX");
m_isAlertStop = GetValueI(L"projectSetting", L"ALMSTOP");
m_isNotMark = GetValueI(L"projectSetting", L"NOMARK");
m_idCamera = GetValueI(L"projectSetting", L"CAMERAID");
m_nTriggerOutForBack = GetValueI(L"projectSetting", L"TRGOUTBACK");
m_nTriggerOutForFront = GetValueI(L"projectSetting", L"TRGOUTFRONT");
m_nTriggerOutForFinish = GetValueI(L"projectSetting", L"TRGOUTFINISH");
m_nSetTimerIntervals = GetValueI(L"projectSetting", L"TIMERINTERVALS");
m_nSnapTimeDelay = GetValueI(L"projectSetting", L"SANPDELAY");
m_shutter = GetValueF(L"projectSetting", L"SHUTTER");
m_markdelay = GetValueI(L"projectSetting", L"MARKDELAY");
m_direction = GetValueI(L"projectSetting", L"DIR");
m_password = GetValue(L"projectSetting", L"PWD");
m_nTotal = GetValueI(L"projectSetting", L"TOTAL_QTY");
m_nUp = GetValueI(L"projectSetting", L"UP_QTY");
m_nDown = GetValueI(L"projectSetting", L"DOWN_QTY");
m_nLeft = GetValueI(L"projectSetting", L"LEFT_QTY");
m_nRight = GetValueI(L"projectSetting", L"RIGHT_QTY");
m_nVoid = GetValueI(L"projectSetting", L"VOID_QTY");
}
if (PARA_IMAGE == (mask&PARA_IMAGE))
{
m_nESCPixel = GetValueI(L"IMAGE_SETTING", L"EscPixel");
m_idThreshNoise = GetValueI(L"IMAGE_SETTING", L"idThreshNoise");
m_idOfThreshold = GetValueI(L"IMAGE_SETTING", L"idOfThreshold");
m_idFixThreshold = GetValueI(L"IMAGE_SETTING", L"idFixThreshold");
m_iThreshNoiseLow = GetValueI(L"IMAGE_SETTING", L"iThreshNoiseLow");
m_iThreshNoiseHi = GetValueI(L"IMAGE_SETTING", L"iThreshNoiseHi");
m_iCanBeRecognisedLenMin = GetValueI(L"IMAGE_SETTING", L"RECOGNISED_LEN_MIN");
m_iCanBeRecognisedLenMax = GetValueI(L"IMAGE_SETTING", L"RECOGNISED_LEN_MAX");
m_iExistMax = GetValueI(L"IMAGE_SETTING", L"EXIST_PX_MAX");
m_iExistMin = GetValueI(L"IMAGE_SETTING", L"EXIST_PX_MIN");
m_iExistHeightMax = GetValueI(L"IMAGE_SETTING", L"HEIGHT_MAX");
m_iExistHeightMin = GetValueI(L"IMAGE_SETTING", L"HEIGHT_MIN");
m_iExistWidthMax = GetValueI(L"IMAGE_SETTING", L"WIDTH_MAX");
m_iExistWidthMin = GetValueI(L"IMAGE_SETTING", L"WIDTH_MIN");
m_bDisplayImageEffect = GetValueI(L"IMAGE_SETTING", L"EFFECT_KIND");
m_nWHRatio = (float)GetValueF(L"IMAGE_SETTING", L"WHRATIO");
m_imageDealMode = GetValueI(L"IMAGE_SETTING", L"m_imagedealmode");
m_blocksize = GetValueI(L"IMAGE_SETTING", L"BLOCKSIZE");
m_threshold2 = GetValueI(L"IMAGE_SETTING", L"THRESHOLD2");
//ๅ่พนๆปคๆณข็ไธไธชๅๆฐ
d = GetValueI(L"IMAGE_SETTING", L"biFilterd");
sigmaColor = GetValueF(L"IMAGE_SETTING", L"biFilterc");
sigmaSpace = GetValueF(L"IMAGE_SETTING", L"biFilters");
top_inv.r1 = GetValueF(L"IMAGE_SETTING", L"TINVR1");
top_inv.c1 = GetValueF(L"IMAGE_SETTING", L"TINVC1");
top_inv.r2 = GetValueF(L"IMAGE_SETTING", L"TINVR2");
top_inv.c2 = GetValueF(L"IMAGE_SETTING", L"TINVC2");
bottom_inv.r1 = GetValueF(L"IMAGE_SETTING", L"BINVR1");
bottom_inv.c1 = GetValueF(L"IMAGE_SETTING", L"BINVC1");
bottom_inv.r2 = GetValueF(L"IMAGE_SETTING", L"BINVR2");
bottom_inv.c2 = GetValueF(L"IMAGE_SETTING", L"BINVC2");
top_char.r1 = GetValueF(L"IMAGE_SETTING", L"TCHARR1");
top_char.c1 = GetValueF(L"IMAGE_SETTING", L"TCHARC1");
top_char.r2 = GetValueF(L"IMAGE_SETTING", L"TCHARR2");
top_char.c2 = GetValueF(L"IMAGE_SETTING", L"TCHARC2");
bottom_char.r1 = GetValueF(L"IMAGE_SETTING", L"BCHARR1");
bottom_char.c1 = GetValueF(L"IMAGE_SETTING", L"BCHARC1");
bottom_char.r2 = GetValueF(L"IMAGE_SETTING", L"BCHARR2");
bottom_char.c2 = GetValueF(L"IMAGE_SETTING", L"BCHARC2");
top_knife.r1 = GetValueF(L"IMAGE_SETTING", L"TKNIFER1");
top_knife.c1 = GetValueF(L"IMAGE_SETTING", L"TKNIFEC1");
top_knife.r2 = GetValueF(L"IMAGE_SETTING", L"TKNIFER2");
top_knife.c2 = GetValueF(L"IMAGE_SETTING", L"TKNIFEC2");
bottom_knife.r1 = GetValueF(L"IMAGE_SETTING", L"BKNIFER1");
bottom_knife.c1 = GetValueF(L"IMAGE_SETTING", L"BKNIFEC1");
bottom_knife.r2 = GetValueF(L"IMAGE_SETTING", L"BKNIFER2");
bottom_knife.c2 = GetValueF(L"IMAGE_SETTING", L"BKNIFEC2");
top_unbolt.r1 = GetValueF(L"IMAGE_SETTING", L"TUBOLTR1");
top_unbolt.c1 = GetValueF(L"IMAGE_SETTING", L"TUBOLTC1");
top_unbolt.r2 = GetValueF(L"IMAGE_SETTING", L"TUBOLTR2");
top_unbolt.c2 = GetValueF(L"IMAGE_SETTING", L"TUBOLTC2");
bottom_unbolt.r1 = GetValueF(L"IMAGE_SETTING", L"BUBOLTR1");
bottom_unbolt.c1 = GetValueF(L"IMAGE_SETTING", L"BUBOLTC1");
bottom_unbolt.r2 = GetValueF(L"IMAGE_SETTING", L"BUBOLTR2");
bottom_unbolt.c2 = GetValueF(L"IMAGE_SETTING", L"BUBOLTC2");
TopPara.thresholdvalue = GetValueF(L"IMAGE_SETTING", L"TPTHRES");
TopPara.minarea = GetValueF(L"IMAGE_SETTING", L"TPMINAREA");
TopPara.maxarea = GetValueF(L"IMAGE_SETTING", L"TPMAXAREA");
BottomPara.thresholdvalue = GetValueF(L"IMAGE_SETTING", L"BPTHRES");
BottomPara.minarea = GetValueF(L"IMAGE_SETTING", L"BPMINAREA");
BottomPara.maxarea = GetValueF(L"IMAGE_SETTING", L"BPMAXAREA");
Tacc = GetValueF(L"IMAGE_SETTING", L"TACC");
MaxVel = GetValueI(L"IMAGE_SETTING", L"MAXVEL");
waves = GetValueI(L"IMAGE_SETTING", L"WAVES");
m_ChainLength = GetValueI(L"IMAGE_SETTING", L"CHAINLEN");
TopPara.knife_threshold = GetValueF(L"IMAGE_SETTING", L"TKNIFETHRES");
TopPara.minlen = GetValueF(L"IMAGE_SETTING", L"TKNIFEMNLEN");
TopPara.maxlen = GetValueF(L"IMAGE_SETTING", L"TKNIFEMXLEN");
BottomPara.knife_threshold = GetValueF(L"IMAGE_SETTING", L"BKNIFETHRES");
BottomPara.minlen = GetValueF(L"IMAGE_SETTING", L"BKNIFEMNLEN");
BottomPara.maxlen = GetValueF(L"IMAGE_SETTING", L"BKNIFEMXLEN");
TopPara.match_acc = GetValueF(L"IMAGE_SETTING", L"TMATCHACC");
BottomPara.match_acc = GetValueF(L"IMAGE_SETTING", L"BMATCHACC");
}
if (PARA_IO == (mask&PARA_IO))
{
m_mode1 = GetValueI(L"IOCARD_SETTING", L"mode1");
g_RailLenght = GetValueI(L"IOCARD_SETTING", L"g_RailLenght");
IN_Start_Camera_SENSOR = GetValueI(L"IOCARD_SETTING", L"IN_Start_Camera_SENSOR");
IN_CHECK_BREAK = GetValueI(L"IOCARD_SETTING", L"IN_CHECK_BREAK");
IN_Check_UP_TIPPEDUP = GetValueI(L"IOCARD_SETTING", L"IN_Check_UP_TIPPEDUP");
IN_CYL_Magnet_SENSOR = GetValueI(L"IOCARD_SETTING", L"IN_CYL_Magnet_SENSOR");
IN_Check_BT_TIPPEDUP = GetValueI(L"IOCARD_SETTING", L"IN_Check_BT_TIPPEDUP");
IN_START_BTN = GetValueI(L"IOCARD_SETTING", L"IN_START_BTN");
IN_BTN_STOP = GetValueI(L"IOCARD_SETTING", L"IN_BTN_STOP");
IN_Check_Double_Sword2 = GetValueI(L"IOCARD_SETTING", L"IN_Check_Double_Sword2");
IN_CYL_Mark3_UP_SENSOR = GetValueI(L"IOCARD_SETTING", L"IN_CYL_Mark3_UP_SENSOR");
IN_CHECK_SENSOR = GetValueI(L"IOCARD_SETTING", L"IN_CHECK_SENSOR");
IN_DIED_KNOED_SENSOR = GetValueI(L"IOCARD_SETTING", L"IN_DIED_KNOED_SENSOR");
IN_Check_Double_Sword1 = GetValueI(L"IOCARD_SETTING", L"IN_Check_Double_Sword1");
IN_CYL_Mark1_UP_SENSOR = GetValueI(L"IOCARD_SETTING", L"IN_CYL_Mark1_UP_SENSOR");
IN_Foot_Switch = GetValueI(L"IOCARD_SETTING", L"IN_Foot_Switch");
IN_CYL_Mark2_UP_SENSOR = GetValueI(L"IOCARD_SETTING", L"IN_CYL_Mark2_UP_SENSOR");
IN_CHECK_SENSOR1 = GetValueI(L"IOCARD_SETTING", L"IN_CHECK_SENSOR1");
IN_CYL_Press_UP_SENSOR = GetValueI(L"IOCARD_SETTING", L"IN_CYL_Press_UP_SENSOR");
IN_ESTOP_BTN = GetValueI(L"IOCARD_SETTING", L"IN_ESTOP_BTN");
IN_Check_UP_DaJi = GetValueI(L"IOCARD_SETTING", L"IN_Check_UP_DaJi");
IN_Check_BT_DaJi = GetValueI(L"IOCARD_SETTING", L"IN_Check_BT_DaJi");
IN_CYL_Push_UP_SENSOR = GetValueI(L"IOCARD_SETTING", L"IN_CYL_Push_UP_SENSOR");
g_UpTippedPos = GetValueI(L"IOCARD_SETTING", L"g_UpTippedPos");
g_BtTippedPos = GetValueI(L"IOCARD_SETTING", L"g_BtTippedPos");
g_UpCameraPos = GetValueI(L"IOCARD_SETTING", L"g_UpCameraPos");
g_BtDaJiPos = GetValueI(L"IOCARD_SETTING", L"g_BtDaJiPos");
g_UpDaJiPos = GetValueI(L"IOCARD_SETTING", L"g_UpDaJiPos");
g_DoubleKnifePos = GetValueI(L"IOCARD_SETTING", L"g_DoubleKnifePos");
g_DoubleKnifePos1 = GetValueI(L"IOCARD_SETTING", L"g_DoubleKnifePos1");
g_BtCameraPos = GetValueI(L"IOCARD_SETTING", L"g_BtCameraPos");
g_Mark1CylinderPos = GetValueI(L"IOCARD_SETTING", L"g_Mark1CylinderPos");
g_Mark2CylinderPos = GetValueI(L"IOCARD_SETTING", L"g_Mark2CylinderPos");
g_MarkPos = GetValueI(L"IOCARD_SETTING", L"g_MarkPos");
g_ThirdDiedKnodePos = GetValueI(L"IOCARD_SETTING", L"g_ThirdDiedKnodePos");
}
}
}
void CPreferences::SaveParaFile(UINT item)
{
UINT mask = item;
////////////////////////////////////
if (PARA_PRJ==(mask&PARA_PRJ))
{
//m_strCurrentProjectName = GetValue(L"projectSetting",L"CurrentProject");
SetValue(L"projectSetting", L"PRJ_VECTOR", m_Prj_Vector);
SetValueI(L"projectSetting", L"PRJ_IDX", m_Prj_Index);
SetValueI(L"projectSetting", L"ALMSTOP", m_isAlertStop);
SetValueI(L"projectSetting", L"NOMARK", m_isNotMark);
SetValueI(L"projectSetting", L"CAMERAID", m_idCamera);
SetValueI(L"projectSetting", L"TRGOUTBACK", m_nTriggerOutForBack);
SetValueI(L"projectSetting", L"TRGOUTFRONT", m_nTriggerOutForFront);
SetValueI(L"projectSetting", L"TRGOUTFINISH", m_nTriggerOutForFinish);
SetValueI(L"projectSetting", L"TIMERINTERVALS", m_nSetTimerIntervals);
SetValueI(L"projectSetting", L"SANPDELAY", m_nSnapTimeDelay);
SetValueF(L"projectSetting", L"SHUTTER", m_shutter);
SetValueI(L"projectSetting", L"MARKDELAY", m_markdelay);
SetValueI(L"projectSetting", L"DIR", m_direction);
SetValue(L"projectSetting", L"PWD", m_password);
SetValueI(L"projectSetting", L"TOTAL_QTY", m_nTotal);
SetValueI(L"projectSetting", L"UP_QTY", m_nUp);
SetValueI(L"projectSetting", L"DOWN_QTY", m_nDown);
SetValueI(L"projectSetting", L"LEFT_QTY", m_nLeft);
SetValueI(L"projectSetting", L"RIGHT_QTY", m_nRight);
SetValueI(L"projectSetting", L"VOID_QTY", m_nVoid);
}
if(PARA_IMAGE==(mask&PARA_IMAGE))
{
SetValueI(L"IMAGE_SETTING",L"EscPixel",m_nESCPixel);
SetValueI(L"IMAGE_SETTING",L"idThreshNoise",m_idThreshNoise); //่ๆฏๅค็ๆนๅผ
SetValueI(L"IMAGE_SETTING",L"idOfThreshold",m_idOfThreshold); //ไบๅผๅ็ฎๆณ้ๆฉ
SetValueI(L"IMAGE_SETTING",L"idFixThreshold",m_idFixThreshold ); //ไบๅผๅ
SetValueI(L"IMAGE_SETTING", L"iThreshNoiseLow", m_iThreshNoiseLow); //่ๆฏไฝๅ็ด ้
SetValueI(L"IMAGE_SETTING", L"iThreshNoiseHi", m_iThreshNoiseHi); //่ๆฏ้ซๅ็ด ้
SetValueI(L"IMAGE_SETTING", L"RECOGNISED_LEN_MIN", m_iCanBeRecognisedLenMin); //็ฉไฝๆญฃๅ้ข้ขๅ็ด ้
SetValueI(L"IMAGE_SETTING", L"RECOGNISED_LEN_MAX", m_iCanBeRecognisedLenMax); //็ฉไฝๅญๅจๅ็ด ้
SetValueI(L"IMAGE_SETTING", L"EXIST_PX_MAX", m_iExistMax); //้็ฉไฝ้ซ้
SetValueI(L"IMAGE_SETTING", L"EXIST_PX_MIN", m_iExistMin); //็ปๆๆพ็คบๅพๅๅๅพๆๅค็ๅๅพๅ
SetValueI(L"IMAGE_SETTING", L"HEIGHT_MAX", m_iExistHeightMax);
SetValueI(L"IMAGE_SETTING", L"HEIGHT_MIN", m_iExistHeightMin);
SetValueI(L"IMAGE_SETTING", L"WIDTH_MAX", m_iExistWidthMax);
SetValueI(L"IMAGE_SETTING", L"WIDTH_MIN", m_iExistWidthMin);
SetValueI(L"IMAGE_SETTING", L"EFFECT_KIND", m_bDisplayImageEffect);
SetValueF(L"IMAGE_SETTING", L"WHRATIO", m_nWHRatio);
SetValueI(L"IMAGE_SETTING", L"m_imagedealmode", m_imageDealMode);
SetValueI(L"IMAGE_SETTING", L"BLOCKSIZE", m_blocksize);
SetValueI(L"IMAGE_SETTING", L"THRESHOLD2", m_threshold2);
//ๅ่พนๆปคๆณข็ไธไธชๅๆฐ
SetValueI(L"IMAGE_SETTING", L"biFilterd", d);
SetValueF(L"IMAGE_SETTING", L"biFilterc", sigmaColor);
SetValueF(L"IMAGE_SETTING", L"biFilters", sigmaSpace);
SetValueF(L"IMAGE_SETTING", L"TINVR1", top_inv.r1);
SetValueF(L"IMAGE_SETTING", L"TINVC1", top_inv.c1);
SetValueF(L"IMAGE_SETTING", L"TINVR2", top_inv.r2);
SetValueF(L"IMAGE_SETTING", L"TINVC2", top_inv.c2);
SetValueF(L"IMAGE_SETTING", L"BINVR1", bottom_inv.r1);
SetValueF(L"IMAGE_SETTING", L"BINVC1", bottom_inv.c1);
SetValueF(L"IMAGE_SETTING", L"BINVR2", bottom_inv.r2);
SetValueF(L"IMAGE_SETTING", L"BINVC2", bottom_inv.c2);
SetValueF(L"IMAGE_SETTING", L"TCHARR1", top_char.r1);
SetValueF(L"IMAGE_SETTING", L"TCHARC1", top_char.c1);
SetValueF(L"IMAGE_SETTING", L"TCHARR2", top_char.r2);
SetValueF(L"IMAGE_SETTING", L"TCHARC2", top_char.c2);
SetValueF(L"IMAGE_SETTING", L"BCHARR1", bottom_char.r1);
SetValueF(L"IMAGE_SETTING", L"BCHARC1", bottom_char.c1);
SetValueF(L"IMAGE_SETTING", L"BCHARR2", bottom_char.r2);
SetValueF(L"IMAGE_SETTING", L"BCHARC2", bottom_char.c2);
SetValueF(L"IMAGE_SETTING", L"TKNIFER1", top_knife.r1);
SetValueF(L"IMAGE_SETTING", L"TKNIFEC1", top_knife.c1);
SetValueF(L"IMAGE_SETTING", L"TKNIFER2", top_knife.r2);
SetValueF(L"IMAGE_SETTING", L"TKNIFEC2", top_knife.c2);
SetValueF(L"IMAGE_SETTING", L"BKNIFER1", bottom_knife.r1);
SetValueF(L"IMAGE_SETTING", L"BKNIFEC1", bottom_knife.c1);
SetValueF(L"IMAGE_SETTING", L"BKNIFER2", bottom_knife.r2);
SetValueF(L"IMAGE_SETTING", L"BKNIFEC2", bottom_knife.c2);
SetValueF(L"IMAGE_SETTING", L"TUBOLTR1", top_unbolt.r1);
SetValueF(L"IMAGE_SETTING", L"TUBOLTC1", top_unbolt.c1);
SetValueF(L"IMAGE_SETTING", L"TUBOLTR2", top_unbolt.r2);
SetValueF(L"IMAGE_SETTING", L"TUBOLTC2", top_unbolt.c2);
SetValueF(L"IMAGE_SETTING", L"BUBOLTR1", bottom_unbolt.r1);
SetValueF(L"IMAGE_SETTING", L"BUBOLTC1", bottom_unbolt.c1);
SetValueF(L"IMAGE_SETTING", L"BUBOLTR2", bottom_unbolt.r2);
SetValueF(L"IMAGE_SETTING", L"BUBOLTC2", bottom_unbolt.c2);
SetValueF(L"IMAGE_SETTING", L"TPTHRES", TopPara.thresholdvalue);
SetValueF(L"IMAGE_SETTING", L"TPMINAREA", TopPara.minarea);
SetValueF(L"IMAGE_SETTING", L"TPMAXAREA", TopPara.maxarea);
SetValueF(L"IMAGE_SETTING", L"BPTHRES", BottomPara.thresholdvalue);
SetValueF(L"IMAGE_SETTING", L"BPMINAREA", BottomPara.minarea);
SetValueF(L"IMAGE_SETTING", L"BPMAXAREA", BottomPara.maxarea);
SetValueF(L"IMAGE_SETTING", L"TACC", Tacc);
SetValueI(L"IMAGE_SETTING", L"MAXVEL", MaxVel);
SetValueI(L"IMAGE_SETTING", L"WAVES",waves);
SetValueI(L"IMAGE_SETTING", L"CHAINLEN", m_ChainLength);
SetValueF(L"IMAGE_SETTING", L"TKNIFETHRES", TopPara.knife_threshold);
SetValueF(L"IMAGE_SETTING", L"TKNIFEMNLEN", TopPara.minlen);
SetValueF(L"IMAGE_SETTING", L"TKNIFEMXLEN", TopPara.maxlen);
SetValueF(L"IMAGE_SETTING", L"BKNIFETHRES", BottomPara.knife_threshold);
SetValueF(L"IMAGE_SETTING", L"BKNIFEMNLEN", BottomPara.minlen);
SetValueF(L"IMAGE_SETTING", L"BKNIFEMXLEN", BottomPara.maxlen);
SetValueF(L"IMAGE_SETTING", L"TMATCHACC", TopPara.match_acc);
SetValueF(L"IMAGE_SETTING", L"BMATCHACC", BottomPara.match_acc);
}
if(PARA_IO==(mask&PARA_IO))
{
SetValueI(L"IOCARD_SETTING", L"mode1", m_mode1);
SetValueI(L"IOCARD_SETTING", L"g_RailLenght", g_RailLenght);
SetValueI(L"IOCARD_SETTING", L"IN_Start_Camera_SENSOR", IN_Start_Camera_SENSOR);
SetValueI(L"IOCARD_SETTING", L"IN_CHECK_BREAK", IN_CHECK_BREAK);
SetValueI(L"IOCARD_SETTING", L"IN_Check_UP_TIPPEDUP", IN_Check_UP_TIPPEDUP);
SetValueI(L"IOCARD_SETTING", L"IN_CYL_Magnet_SENSOR", IN_CYL_Magnet_SENSOR);
SetValueI(L"IOCARD_SETTING", L"IN_Check_BT_TIPPEDUP", IN_Check_BT_TIPPEDUP);
SetValueI(L"IOCARD_SETTING", L"IN_START_BTN", IN_START_BTN);
SetValueI(L"IOCARD_SETTING", L"IN_BTN_STOP", IN_BTN_STOP);
SetValueI(L"IOCARD_SETTING", L"IN_Check_Double_Sword2", IN_Check_Double_Sword2);
SetValueI(L"IOCARD_SETTING", L"IN_CYL_Mark3_UP_SENSOR", IN_CYL_Mark3_UP_SENSOR);
SetValueI(L"IOCARD_SETTING", L"IN_CHECK_SENSOR", IN_CHECK_SENSOR);
SetValueI(L"IOCARD_SETTING", L"IN_DIED_KNOED_SENSOR", IN_DIED_KNOED_SENSOR);
SetValueI(L"IOCARD_SETTING", L"IN_Check_Double_Sword1", IN_Check_Double_Sword1);
SetValueI(L"IOCARD_SETTING", L"IN_CYL_Mark1_UP_SENSOR", IN_CYL_Mark1_UP_SENSOR);
SetValueI(L"IOCARD_SETTING", L"IN_Foot_Switch", IN_Foot_Switch);
SetValueI(L"IOCARD_SETTING", L"IN_CYL_Mark2_UP_SENSOR", IN_CYL_Mark2_UP_SENSOR);
SetValueI(L"IOCARD_SETTING", L"IN_CHECK_SENSOR1", IN_CHECK_SENSOR1);
SetValueI(L"IOCARD_SETTING", L"IN_CYL_Press_UP_SENSOR", IN_CYL_Press_UP_SENSOR);
SetValueI(L"IOCARD_SETTING", L"IN_ESTOP_BTN", IN_ESTOP_BTN);
SetValueI(L"IOCARD_SETTING", L"IN_Check_UP_DaJi", IN_Check_UP_DaJi);
SetValueI(L"IOCARD_SETTING", L"IN_Check_BT_DaJi", IN_Check_BT_DaJi);
SetValueI(L"IOCARD_SETTING", L"IN_CYL_Push_UP_SENSOR", IN_CYL_Push_UP_SENSOR);
SetValueI(L"IOCARD_SETTING", L"g_UpTippedPos", g_UpTippedPos);
SetValueI(L"IOCARD_SETTING", L"g_BtTippedPos", g_BtTippedPos);
SetValueI(L"IOCARD_SETTING", L"g_UpCameraPos", g_UpCameraPos);
SetValueI(L"IOCARD_SETTING", L"g_BtDaJiPos", g_BtDaJiPos);
SetValueI(L"IOCARD_SETTING", L"g_UpDaJiPos", g_UpDaJiPos);
SetValueI(L"IOCARD_SETTING", L"g_DoubleKnifePos", g_DoubleKnifePos);
SetValueI(L"IOCARD_SETTING", L"g_DoubleKnifePos1", g_DoubleKnifePos1);
SetValueI(L"IOCARD_SETTING", L"g_BtCameraPos", g_BtCameraPos);
SetValueI(L"IOCARD_SETTING", L"g_Mark1CylinderPos", g_Mark1CylinderPos);
SetValueI(L"IOCARD_SETTING", L"g_Mark2CylinderPos", g_Mark2CylinderPos);
SetValueI(L"IOCARD_SETTING", L"g_MarkPos", g_MarkPos);
SetValueI(L"IOCARD_SETTING", L"g_ThirdDiedKnodePos", g_ThirdDiedKnodePos);
}
//if(PARA_SN==(mask&PARA_SN))
//{
// SetValue(L"PRJ_SN",L"SN",m_password);
//}
WriteFile();
}
void CPreferences::initData()
{
//#define PARA_PRJ (0x1<<0)
m_Prj_Vector = L"example";
m_Prj_Index = 0;
m_ChainLength = 49;
m_isAlertStop = 0;
m_isNotMark = 0;
m_shutter = 2500.0;
m_idCamera = 0;
m_nTriggerOutForBack = 0;
m_nTriggerOutForFront = 0;
m_nTriggerOutForFinish = 0;
m_nSetTimerIntervals = 10;
m_nSnapTimeDelay = 1; //็ป้ชๅผ๏ผๅคงๆ็ธๆบๆๆๅปถ่ฟๆ35ms
m_markdelay = 700;
m_password = ""; //ๅฏ็
m_nTotal = 0;
m_nUp = 0;
m_nDown = 0;
m_nLeft = 0;
m_nRight = 0;
m_nVoid = 0; //็ป่ฎกไธไธๅทฆๅณๆฃๆตๅฐ็ๆฐ็ฎๅๆฒกๆ็ฉๅ็ๆฐ็ฎ
//IMAGE #define PARA_IMAGE (0x1<<1)
m_imageDealMode = 0; //OTSU
m_nESCPixel = 0;
m_idThreshNoise = 0; //่ๆฏๅค็ๆนๅผ
m_idOfThreshold = 0; //ไบๅผๅ็ฎๆณ้ๆฉ
m_idFixThreshold = 0;
m_iThreshNoiseLow = 50; //่ๆฏ่ฟ้ๅบๅไธ้
m_iThreshNoiseHi = 600000; //่ๆฏ่ฟ้ๅบๅไธ้
m_iCanBeRecognisedLenMin = 2; //่ฏๅซๅบๆนๅไธ้
m_iCanBeRecognisedLenMax = 800; //่ฏๅซๅบๆนๅไธ้
m_iExistMax = 200000; //็ฉไฝๅญๅจๅ็ด ไธ้
m_iExistMin = 600; //็ฉไฝๅญๅจๅ็ด ไธ้
m_iExistHeightMax = 2000; //็ฉไฝๅญๅจ้ซๅบฆๅ็ด ไธ้
m_iExistHeightMin = 20; //็ฉไฝๅญๅจ้ซๅบฆๅ็ด ไธ้
m_iExistWidthMax = 2000; //็ฉไฝๅญๅจๅฎฝๅบฆๅ็ด ไธ้
m_iExistWidthMin = 20; //็ฉไฝๅญๅจๅฎฝๅบฆๅ็ด ไธ้
m_bDisplayImageEffect = 0; //็ปๆๆพ็คบๅพๅๅๅพๆๅค็ๅๅพๅ
m_nWHRatio = 1.5; //ๅพๅ็้ฟๅฎฝๆฏ
m_blocksize = 75; //่ช้ๅบไบๅผๅๅคงๅฐ
//ๅฏนๅบ่ฎพ็ฝฎ็็้ข็ROI
m_threshold2 = 30;
//ๅ่พนๆปคๆณข็ไธไธชๅๆฐ
d = 9;
sigmaColor = 20;
sigmaSpace = 5;
m_mode1 = 0;
Tacc = 0.05;
MaxVel = 52000;
waves = 16000;//ไธ่่ๅฒๆฐ็ฎ
g_UpTippedPos = -66;
//ๅบ้จๆฑ่ตทๆฃๆต
g_BtTippedPos = -72;
//้กถ้จ็ธๆบไฝ็ฝฎ
g_UpCameraPos = 0;
//ๅบ้จๆๆบไฝ็ฝฎ
g_BtDaJiPos = 3;
//้กถ้จๆๆบไฝ็ฝฎ
g_UpDaJiPos = 3;
//้กถ้จๅๅ็ฒไฝ็ฝฎ
g_DoubleKnifePos = 5;
//ๅบ้จๅๅ็ฒไฝ็ฝฎ
g_DoubleKnifePos1 = -4;
//ๅบ้จ็ธๆบไฝ็ฝฎ
g_BtCameraPos = 8;
//Mark1ๆฐ็ผธไฝ็ฝฎ
g_Mark1CylinderPos = 11;
//Mark2ๆฐ็ผธไฝ็ฝฎ
g_Mark2CylinderPos = 16;
//Markไฝ็ฝฎ
g_MarkPos = 33;
//ๆก้ขๆญป็ปๆๅบๅจ
g_ThirdDiedKnodePos = -21;// = -21;
//ๅฏผ่ฝจ้ฟๅบฆ
g_RailLenght = 48;
//่งฆๅๆ็
งๆๅบๅจ
IN_Start_Camera_SENSOR = 1;
//ๆๆญๆฃๆตๆๅบๅจ
IN_CHECK_BREAK = 3;
//้ขๅ
็ญ้ๅไธๆๅปๅๆฑ่ตทๆฅ็
IN_Check_UP_TIPPEDUP = 6;
//ๅธๆฃๆฐ็ผธไธ้ๆๅบๅจ
IN_CYL_Magnet_SENSOR = 7;
//้ขๅ
็ญ้ๅไธๆๅปๅๆฑ่ตทๆฅ็
IN_Check_BT_TIPPEDUP = 8;
//ๅฏๅจๆ้ฎ
IN_START_BTN = 16;
//ๅๆญขๆ้ฎ
IN_BTN_STOP = 17;
//ๅบ้จๅๅ็ฒๆๅบๅจ
IN_Check_Double_Sword2 = 18;
//Mark3ๆฐ็ผธไธ้
IN_CYL_Mark3_UP_SENSOR = 19;
//ๆญป็ปๆๅบๅจ๏ผ่ฟ
IN_CHECK_SENSOR = 25;
//ๆก้ขๆญป็ปๆๅบๅจ
IN_DIED_KNOED_SENSOR = 25;
//้กถ้จๅๅ็ฒๆๅบๅจ
IN_Check_Double_Sword1 = 21;
//Mark1ๆฐ็ผธๆๅบๅจ
IN_CYL_Mark1_UP_SENSOR = 22;
//ๆฅๆๆ้ฎๆ่
่่ธๅผๅ
ณ
IN_Foot_Switch = 23;
//Mark2ๆฐ็ผธไธ้ๆๅบๅจ
IN_CYL_Mark2_UP_SENSOR = 24;
//ๆญป็ปๆๅบๅจ๏ผๅบ
IN_CHECK_SENSOR1 = 20;
//ไธๅๆฐ็ผธไธ้ๆๅบๅจ
IN_CYL_Press_UP_SENSOR = 26;
//ๆฅๅๆ้ฎ
IN_ESTOP_BTN = 27;
//้กถ้จๆๆบๆๅบๅจ
IN_Check_UP_DaJi = 28;
//ๅบ้จๆๆบๆๅบๅจ
IN_Check_BT_DaJi = 29;
//ๆจ้พๆฐ็ผธไธ้ๆๅบๅจ
IN_CYL_Push_UP_SENSOR = 30;
top_inv.c1 = top_inv.r1 = 0.0;
top_inv.c2 = top_inv.r2 = 300;
bottom_inv = top_char = bottom_char = top_knife = bottom_knife = top_unbolt = bottom_unbolt = top_inv;
TopPara.thresholdvalue = 245;
TopPara.minarea = 2500;
TopPara.maxarea = 35000;
TopPara.knife_threshold = 235;
TopPara.minlen = 300.0;
TopPara.maxlen = 460.0;
TopPara.match_acc = 0.5;
BottomPara = TopPara;
} | [
"prayedsoul@qq.com"
] | prayedsoul@qq.com |
9a062053ed0538780bcbc490b79d5dc1aa784055 | 8aa9a970895b0b2cf639f75738e33b0a4487208e | /DataStructures/Stack/valid_parentheses.cpp | ebdf3334acad9d37a9d6be57da28e73f1f8ff439 | [] | no_license | VladAdGad/leetcode-solutions | 09d24c3cdd1f95ea45746a67a71ebfb944933152 | 0431f983ab86a53b5a22dc9deca62746c877e7e7 | refs/heads/master | 2023-01-30T16:14:37.235018 | 2020-12-11T19:24:45 | 2020-12-11T19:24:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,036 | cpp | #include <catch2/catch_all.hpp>
#include <stack>
#include <iostream>
bool isValid(const std::string& s) {
std::stack<char> data;
const std::map<char, char> parentheses = {
{'(', ')'},
{'[', ']'},
{'{', '}'}
};
for (const char& elem : s) {
if (elem == '(' || elem == '[' || elem == '{') {
data.push(elem);
} else {
if (!data.empty()) {
if (parentheses.find(data.top())->second == elem) {
data.pop();
} else {
return false;
}
} else {
return false;
}
}
}
return data.empty();
}
TEST_CASE("Valid Parentheses", "[Data Structures]") {
REQUIRE(isValid("()") == true);
REQUIRE(isValid("]") == false);
REQUIRE(isValid("(])") == false);
REQUIRE(isValid("()[]{}") == true);
REQUIRE(isValid("(]") == false);
REQUIRE(isValid("([)]") == false);
REQUIRE(isValid("{[]}") == true);
}
| [
"vladadgad@gmail.com"
] | vladadgad@gmail.com |
03ca725db80a104a2ad7e959f65333bd082a0429 | 22a794a73503d4dd1dd4a5833c74d851910d72b7 | /W9/Data.h | bf447cbf6d35257f3c06ff036e564c0b9c3c977c | [] | no_license | skim33/OOP244 | ee0a195a24291a2ce50f3f39d0dfd034a468c506 | 7dc36efce8b6c0798a1d3dcdbe6f947fad85c4bd | refs/heads/master | 2020-03-30T03:38:17.953367 | 2018-09-28T07:06:42 | 2018-09-28T07:06:42 | 150,699,411 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,545 | h | // OOP244 Workshop 9: Function Templates
// File: Data.h
// Date: 2018/04/02
// Author: Woohyuk Kim
// E-mail: wkim33@myseneca.ca
// Description:
// This file contains declarations.
///////////////////////////////////////////////////
#include<iostream>
using namespace std;
namespace sict {
// These numbers define
// the range of data we expect to see in this workshop
// 0 to 1 billion
// use them in the min and max function
// the output column width for a single data field
const int LARGEST_NUMBER = 1000000000; // 1,000,000,000
const int SMALLEST_NUMBER = 0;
const int COLUMN_WIDTH = 15;
// max returns the largest item in data
//
template <typename T>
T max(const T* data, int n) {\
T num = data[0];
for (int i = 0; i < n; i++) {
if (data[i] > num) {
num = data[i];
}
}
return static_cast<int>(num);
}
// min returns the smallest item in data
//
template <typename T>
T min(const T* data, int n) {
T num = data[0];
for (int i = 0; i < n; i++) {
if (data[i] < num) {
num = data[i];
}
}
return static_cast<int>(num);
}
// sum returns the sum of n items in data
//
template <typename T>
T sum(const T* data, int n) {
T num;
for (int i = 0; i < n; i++) {
if (data[i] < num) {
num += data[i];
}
}
return static_cast<int>(num);
}
// average returns the average of n items in data
//
template <typename T>
double average(const T* data, int n) {
double num;
for (int i = 0; i < n; i++) {
num += data[i];
}
num /= 5;
return num;
}
// read extracts n items from input and stores them in data
// - the items are comma separated
// - this function assumes that a comma exists at the next field to be read
// - for example: ,data1, data2,data3, ...., datan
//
template <typename T>
bool read(istream& input, T* data, int n) {
for (int i = 0; i < n; i++) {
input.ignore();
input >> data[i];
}
if (input.fail()) {
return false;
}
return true;
}
// display inserts n items of data into std::cout
//
template <typename T>
void display(const char* name, const T* data, int n) {
cout.setf(ios::right);
cout.width(20);
cout << name;
for (int i = 0; i < n; i++) {
cout.width(COLUMN_WIDTH);
cout << data[i];
}
cout << endl;
}
bool readRow(std::istream& input, const char* name, int* data, int n);
bool readRow(std::istream& input, const char* name, double* data, int n);
void answers(const int*, const int*, const int*, const double*, const int*, const int n);
}
| [
"shawnkimwk@gmail.com"
] | shawnkimwk@gmail.com |
cd487d3f6c3fe9fd35cb048806797003ee676543 | ce71ba08e9094a4d76c8cc1e0cc7891ae016ff60 | /Lib/Chip/CM4/STMicro/STM32F469/OTG_FS_GLOBAL.hpp | 4ff03a55d2e87b1aa8c25df80da9d483734641ec | [
"Apache-2.0"
] | permissive | operativeF/Kvasir | 9bfe25e1844d41ffefe527f16117c618af50cde9 | dfbcbdc9993d326ef8cc73d99129e78459c561fd | refs/heads/master | 2020-04-06T13:12:59.381009 | 2019-01-25T18:43:17 | 2019-01-25T18:43:17 | 157,489,295 | 0 | 0 | Apache-2.0 | 2018-11-14T04:12:05 | 2018-11-14T04:12:04 | null | UTF-8 | C++ | false | false | 25,420 | hpp | #pragma once
#include <Register/Utility.hpp>
namespace Kvasir {
//USB on the go full speed
namespace OtgFsGlobalFsGotgctl{ ///<OTG_FS control and status register (OTG_FS_GOTGCTL)
using Addr = Register::Address<0x50000000,0xfff0f0fc,0x00000000,std::uint32_t>;
///Session request success
constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> srqscs{};
///Session request
constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> srq{};
///Host negotiation success
constexpr Register::FieldLocation<Addr,Register::maskFromRange(8,8),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> hngscs{};
///HNP request
constexpr Register::FieldLocation<Addr,Register::maskFromRange(9,9),Register::ReadWriteAccess,unsigned> hnprq{};
///Host set HNP enable
constexpr Register::FieldLocation<Addr,Register::maskFromRange(10,10),Register::ReadWriteAccess,unsigned> hshnpen{};
///Device HNP enabled
constexpr Register::FieldLocation<Addr,Register::maskFromRange(11,11),Register::ReadWriteAccess,unsigned> dhnpen{};
///Connector ID status
constexpr Register::FieldLocation<Addr,Register::maskFromRange(16,16),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> cidsts{};
///Long/short debounce time
constexpr Register::FieldLocation<Addr,Register::maskFromRange(17,17),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> dbct{};
///A-session valid
constexpr Register::FieldLocation<Addr,Register::maskFromRange(18,18),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> asvld{};
///B-session valid
constexpr Register::FieldLocation<Addr,Register::maskFromRange(19,19),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> bsvld{};
}
namespace OtgFsGlobalFsGotgint{ ///<OTG_FS interrupt register (OTG_FS_GOTGINT)
using Addr = Register::Address<0x50000004,0xfff1fcfb,0x00000000,std::uint32_t>;
///Session end detected
constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,unsigned> sedet{};
///Session request success status change
constexpr Register::FieldLocation<Addr,Register::maskFromRange(8,8),Register::ReadWriteAccess,unsigned> srsschg{};
///Host negotiation success status change
constexpr Register::FieldLocation<Addr,Register::maskFromRange(9,9),Register::ReadWriteAccess,unsigned> hnsschg{};
///Host negotiation detected
constexpr Register::FieldLocation<Addr,Register::maskFromRange(17,17),Register::ReadWriteAccess,unsigned> hngdet{};
///A-device timeout change
constexpr Register::FieldLocation<Addr,Register::maskFromRange(18,18),Register::ReadWriteAccess,unsigned> adtochg{};
///Debounce done
constexpr Register::FieldLocation<Addr,Register::maskFromRange(19,19),Register::ReadWriteAccess,unsigned> dbcdne{};
}
namespace OtgFsGlobalFsGahbcfg{ ///<OTG_FS AHB configuration register (OTG_FS_GAHBCFG)
using Addr = Register::Address<0x50000008,0xfffffe7e,0x00000000,std::uint32_t>;
///Global interrupt mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,unsigned> gint{};
///TxFIFO empty level
constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,unsigned> txfelvl{};
///Periodic TxFIFO empty level
constexpr Register::FieldLocation<Addr,Register::maskFromRange(8,8),Register::ReadWriteAccess,unsigned> ptxfelvl{};
}
namespace OtgFsGlobalFsGusbcfg{ ///<OTG_FS USB configuration register (OTG_FS_GUSBCFG)
using Addr = Register::Address<0x5000000c,0x1fffc0b8,0x00000000,std::uint32_t>;
///FS timeout calibration
constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,0),Register::ReadWriteAccess,unsigned> tocal{};
///Full Speed serial transceiver select
constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::Access<Register::AccessType::writeOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> physel{};
///SRP-capable
constexpr Register::FieldLocation<Addr,Register::maskFromRange(8,8),Register::ReadWriteAccess,unsigned> srpcap{};
///HNP-capable
constexpr Register::FieldLocation<Addr,Register::maskFromRange(9,9),Register::ReadWriteAccess,unsigned> hnpcap{};
///USB turnaround time
constexpr Register::FieldLocation<Addr,Register::maskFromRange(13,10),Register::ReadWriteAccess,unsigned> trdt{};
///Force host mode
constexpr Register::FieldLocation<Addr,Register::maskFromRange(29,29),Register::ReadWriteAccess,unsigned> fhmod{};
///Force device mode
constexpr Register::FieldLocation<Addr,Register::maskFromRange(30,30),Register::ReadWriteAccess,unsigned> fdmod{};
///Corrupt Tx packet
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,31),Register::ReadWriteAccess,unsigned> ctxpkt{};
}
namespace OtgFsGlobalFsGrstctl{ ///<OTG_FS reset register (OTG_FS_GRSTCTL)
using Addr = Register::Address<0x50000010,0x7ffff808,0x00000000,std::uint32_t>;
///Core soft reset
constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::ReadWriteAccess,unsigned> csrst{};
///HCLK soft reset
constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> hsrst{};
///Host frame counter reset
constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,unsigned> fcrst{};
///RxFIFO flush
constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::ReadWriteAccess,unsigned> rxfflsh{};
///TxFIFO flush
constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::ReadWriteAccess,unsigned> txfflsh{};
///TxFIFO number
constexpr Register::FieldLocation<Addr,Register::maskFromRange(10,6),Register::ReadWriteAccess,unsigned> txfnum{};
///AHB master idle
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,31),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ahbidl{};
}
namespace OtgFsGlobalFsGintsts{ ///<OTG_FS core interrupt register (OTG_FS_GINTSTS)
using Addr = Register::Address<0x50000014,0x08c30300,0x00000000,std::uint32_t>;
///Current mode of operation
constexpr Register::FieldLocation<Addr,Register::maskFromRange(0,0),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> cmod{};
///Mode mismatch interrupt
constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> mmis{};
///OTG interrupt
constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> otgint{};
///Start of frame
constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,unsigned> sof{};
///RxFIFO non-empty
constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> rxflvl{};
///Non-periodic TxFIFO empty
constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> nptxfe{};
///Global IN non-periodic NAK effective
constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ginakeff{};
///Global OUT NAK effective
constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> goutnakeff{};
///Early suspend
constexpr Register::FieldLocation<Addr,Register::maskFromRange(10,10),Register::ReadWriteAccess,unsigned> esusp{};
///USB suspend
constexpr Register::FieldLocation<Addr,Register::maskFromRange(11,11),Register::ReadWriteAccess,unsigned> usbsusp{};
///USB reset
constexpr Register::FieldLocation<Addr,Register::maskFromRange(12,12),Register::ReadWriteAccess,unsigned> usbrst{};
///Enumeration done
constexpr Register::FieldLocation<Addr,Register::maskFromRange(13,13),Register::ReadWriteAccess,unsigned> enumdne{};
///Isochronous OUT packet dropped interrupt
constexpr Register::FieldLocation<Addr,Register::maskFromRange(14,14),Register::ReadWriteAccess,unsigned> isoodrp{};
///End of periodic frame interrupt
constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,15),Register::ReadWriteAccess,unsigned> eopf{};
///IN endpoint interrupt
constexpr Register::FieldLocation<Addr,Register::maskFromRange(18,18),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> iepint{};
///OUT endpoint interrupt
constexpr Register::FieldLocation<Addr,Register::maskFromRange(19,19),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> oepint{};
///Incomplete isochronous IN transfer
constexpr Register::FieldLocation<Addr,Register::maskFromRange(20,20),Register::ReadWriteAccess,unsigned> iisoixfr{};
///Incomplete periodic transfer(Host mode)/Incomplete isochronous OUT transfer(Device mode)
constexpr Register::FieldLocation<Addr,Register::maskFromRange(21,21),Register::ReadWriteAccess,unsigned> ipxfrIncompisoout{};
///Host port interrupt
constexpr Register::FieldLocation<Addr,Register::maskFromRange(24,24),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> hprtint{};
///Host channels interrupt
constexpr Register::FieldLocation<Addr,Register::maskFromRange(25,25),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> hcint{};
///Periodic TxFIFO empty
constexpr Register::FieldLocation<Addr,Register::maskFromRange(26,26),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> ptxfe{};
///Connector ID status change
constexpr Register::FieldLocation<Addr,Register::maskFromRange(28,28),Register::ReadWriteAccess,unsigned> cidschg{};
///Disconnect detected interrupt
constexpr Register::FieldLocation<Addr,Register::maskFromRange(29,29),Register::ReadWriteAccess,unsigned> discint{};
///Session request/new session detected interrupt
constexpr Register::FieldLocation<Addr,Register::maskFromRange(30,30),Register::ReadWriteAccess,unsigned> srqint{};
///Resume/remote wakeup detected interrupt
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,31),Register::ReadWriteAccess,unsigned> wkupint{};
}
namespace OtgFsGlobalFsGintmsk{ ///<OTG_FS interrupt mask register (OTG_FS_GINTMSK)
using Addr = Register::Address<0x50000018,0x08c10301,0x00000000,std::uint32_t>;
///Mode mismatch interrupt mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(1,1),Register::ReadWriteAccess,unsigned> mmism{};
///OTG interrupt mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(2,2),Register::ReadWriteAccess,unsigned> otgint{};
///Start of frame mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,3),Register::ReadWriteAccess,unsigned> sofm{};
///Receive FIFO non-empty mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(4,4),Register::ReadWriteAccess,unsigned> rxflvlm{};
///Non-periodic TxFIFO empty mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(5,5),Register::ReadWriteAccess,unsigned> nptxfem{};
///Global non-periodic IN NAK effective mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(6,6),Register::ReadWriteAccess,unsigned> ginakeffm{};
///Global OUT NAK effective mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(7,7),Register::ReadWriteAccess,unsigned> gonakeffm{};
///Early suspend mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(10,10),Register::ReadWriteAccess,unsigned> esuspm{};
///USB suspend mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(11,11),Register::ReadWriteAccess,unsigned> usbsuspm{};
///USB reset mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(12,12),Register::ReadWriteAccess,unsigned> usbrst{};
///Enumeration done mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(13,13),Register::ReadWriteAccess,unsigned> enumdnem{};
///Isochronous OUT packet dropped interrupt mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(14,14),Register::ReadWriteAccess,unsigned> isoodrpm{};
///End of periodic frame interrupt mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,15),Register::ReadWriteAccess,unsigned> eopfm{};
///Endpoint mismatch interrupt mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(17,17),Register::ReadWriteAccess,unsigned> epmism{};
///IN endpoints interrupt mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(18,18),Register::ReadWriteAccess,unsigned> iepint{};
///OUT endpoints interrupt mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(19,19),Register::ReadWriteAccess,unsigned> oepint{};
///Incomplete isochronous IN transfer mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(20,20),Register::ReadWriteAccess,unsigned> iisoixfrm{};
///Incomplete periodic transfer mask(Host mode)/Incomplete isochronous OUT transfer mask(Device mode)
constexpr Register::FieldLocation<Addr,Register::maskFromRange(21,21),Register::ReadWriteAccess,unsigned> ipxfrmIisooxfrm{};
///Host port interrupt mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(24,24),Register::Access<Register::AccessType::readOnly,Register::ReadActionType::normal,Register::ModifiedWriteValueType::normal>,unsigned> prtim{};
///Host channels interrupt mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(25,25),Register::ReadWriteAccess,unsigned> hcim{};
///Periodic TxFIFO empty mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(26,26),Register::ReadWriteAccess,unsigned> ptxfem{};
///Connector ID status change mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(28,28),Register::ReadWriteAccess,unsigned> cidschgm{};
///Disconnect detected interrupt mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(29,29),Register::ReadWriteAccess,unsigned> discint{};
///Session request/new session detected interrupt mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(30,30),Register::ReadWriteAccess,unsigned> srqim{};
///Resume/remote wakeup detected interrupt mask
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,31),Register::ReadWriteAccess,unsigned> wuim{};
}
namespace OtgFsGlobalFsGrxstsrDevice{ ///<OTG_FS Receive status debug read(Device mode)
using Addr = Register::Address<0x5000001c,0xfe000000,0x00000000,std::uint32_t>;
///Endpoint number
constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,0),Register::ReadWriteAccess,unsigned> epnum{};
///Byte count
constexpr Register::FieldLocation<Addr,Register::maskFromRange(14,4),Register::ReadWriteAccess,unsigned> bcnt{};
///Data PID
constexpr Register::FieldLocation<Addr,Register::maskFromRange(16,15),Register::ReadWriteAccess,unsigned> dpid{};
///Packet status
constexpr Register::FieldLocation<Addr,Register::maskFromRange(20,17),Register::ReadWriteAccess,unsigned> pktsts{};
///Frame number
constexpr Register::FieldLocation<Addr,Register::maskFromRange(24,21),Register::ReadWriteAccess,unsigned> frmnum{};
}
namespace OtgFsGlobalFsGrxstsrHost{ ///<OTG_FS Receive status debug read(Hostmode)
using Addr = Register::Address<0x5000001c,0xfe000000,0x00000000,std::uint32_t>;
///Endpoint number
constexpr Register::FieldLocation<Addr,Register::maskFromRange(3,0),Register::ReadWriteAccess,unsigned> epnum{};
///Byte count
constexpr Register::FieldLocation<Addr,Register::maskFromRange(14,4),Register::ReadWriteAccess,unsigned> bcnt{};
///Data PID
constexpr Register::FieldLocation<Addr,Register::maskFromRange(16,15),Register::ReadWriteAccess,unsigned> dpid{};
///Packet status
constexpr Register::FieldLocation<Addr,Register::maskFromRange(20,17),Register::ReadWriteAccess,unsigned> pktsts{};
///Frame number
constexpr Register::FieldLocation<Addr,Register::maskFromRange(24,21),Register::ReadWriteAccess,unsigned> frmnum{};
}
namespace OtgFsGlobalFsGrxfsiz{ ///<OTG_FS Receive FIFO size register (OTG_FS_GRXFSIZ)
using Addr = Register::Address<0x50000024,0xffff0000,0x00000000,std::uint32_t>;
///RxFIFO depth
constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,0),Register::ReadWriteAccess,unsigned> rxfd{};
}
namespace OtgFsGlobalFsGnptxfsizDevice{ ///<OTG_FS non-periodic transmit FIFO size register (Device mode)
using Addr = Register::Address<0x50000028,0x00000000,0x00000000,std::uint32_t>;
///Endpoint 0 transmit RAM start address
constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,0),Register::ReadWriteAccess,unsigned> tx0fsa{};
///Endpoint 0 TxFIFO depth
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,16),Register::ReadWriteAccess,unsigned> tx0fd{};
}
namespace OtgFsGlobalFsGnptxfsizHost{ ///<OTG_FS non-periodic transmit FIFO size register (Host mode)
using Addr = Register::Address<0x50000028,0x00000000,0x00000000,std::uint32_t>;
///Non-periodic transmit RAM start address
constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,0),Register::ReadWriteAccess,unsigned> nptxfsa{};
///Non-periodic TxFIFO depth
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,16),Register::ReadWriteAccess,unsigned> nptxfd{};
}
namespace OtgFsGlobalFsGnptxsts{ ///<OTG_FS non-periodic transmit FIFO/queue status register (OTG_FS_GNPTXSTS)
using Addr = Register::Address<0x5000002c,0x80000000,0x00000000,std::uint32_t>;
///Non-periodic TxFIFO space available
constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,0),Register::ReadWriteAccess,unsigned> nptxfsav{};
///Non-periodic transmit request queue space available
constexpr Register::FieldLocation<Addr,Register::maskFromRange(23,16),Register::ReadWriteAccess,unsigned> nptqxsav{};
///Top of the non-periodic transmit request queue
constexpr Register::FieldLocation<Addr,Register::maskFromRange(30,24),Register::ReadWriteAccess,unsigned> nptxqtop{};
}
namespace OtgFsGlobalFsGccfg{ ///<OTG_FS general core configuration register (OTG_FS_GCCFG)
using Addr = Register::Address<0x50000038,0xffe2ffff,0x00000000,std::uint32_t>;
///Power down
constexpr Register::FieldLocation<Addr,Register::maskFromRange(16,16),Register::ReadWriteAccess,unsigned> pwrdwn{};
///Enable the VBUS sensing device
constexpr Register::FieldLocation<Addr,Register::maskFromRange(18,18),Register::ReadWriteAccess,unsigned> vbusasen{};
///Enable the VBUS sensing device
constexpr Register::FieldLocation<Addr,Register::maskFromRange(19,19),Register::ReadWriteAccess,unsigned> vbusbsen{};
///SOF output enable
constexpr Register::FieldLocation<Addr,Register::maskFromRange(20,20),Register::ReadWriteAccess,unsigned> sofouten{};
}
namespace OtgFsGlobalFsCid{ ///<core ID register
using Addr = Register::Address<0x5000003c,0x00000000,0x00000000,std::uint32_t>;
///Product ID field
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,0),Register::ReadWriteAccess,unsigned> productId{};
}
namespace OtgFsGlobalFsHptxfsiz{ ///<OTG_FS Host periodic transmit FIFO size register (OTG_FS_HPTXFSIZ)
using Addr = Register::Address<0x50000100,0x00000000,0x00000000,std::uint32_t>;
///Host periodic TxFIFO start address
constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,0),Register::ReadWriteAccess,unsigned> ptxsa{};
///Host periodic TxFIFO depth
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,16),Register::ReadWriteAccess,unsigned> ptxfsiz{};
}
namespace OtgFsGlobalFsDieptxf1{ ///<OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF1)
using Addr = Register::Address<0x50000104,0x00000000,0x00000000,std::uint32_t>;
///IN endpoint FIFO2 transmit RAM start address
constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,0),Register::ReadWriteAccess,unsigned> ineptxsa{};
///IN endpoint TxFIFO depth
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,16),Register::ReadWriteAccess,unsigned> ineptxfd{};
}
namespace OtgFsGlobalFsDieptxf2{ ///<OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF2)
using Addr = Register::Address<0x50000108,0x00000000,0x00000000,std::uint32_t>;
///IN endpoint FIFO3 transmit RAM start address
constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,0),Register::ReadWriteAccess,unsigned> ineptxsa{};
///IN endpoint TxFIFO depth
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,16),Register::ReadWriteAccess,unsigned> ineptxfd{};
}
namespace OtgFsGlobalFsDieptxf3{ ///<OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF3)
using Addr = Register::Address<0x5000010c,0x00000000,0x00000000,std::uint32_t>;
///IN endpoint FIFO4 transmit RAM start address
constexpr Register::FieldLocation<Addr,Register::maskFromRange(15,0),Register::ReadWriteAccess,unsigned> ineptxsa{};
///IN endpoint TxFIFO depth
constexpr Register::FieldLocation<Addr,Register::maskFromRange(31,16),Register::ReadWriteAccess,unsigned> ineptxfd{};
}
namespace OtgFsGlobalFsDieptxf4{ ///<OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF4)
using Addr = Register::Address<0x50000110,0xffffffff,0x00000000,std::uint32_t>;
}
namespace OtgFsGlobalFsDieptxf5{ ///<OTG_FS device IN endpoint transmit FIFO size register (OTG_FS_DIEPTXF5)
using Addr = Register::Address<0x50000114,0xffffffff,0x00000000,std::uint32_t>;
}
}
| [
"thomas@dwarfcraft.com"
] | thomas@dwarfcraft.com |
7bb60e86ed724fe8cce9713e6da36fd3fc2c0100 | 69ea183c1bb6fcea7e2a0cb4d9d5fff67c9cd143 | /Academy_ํน์ดํ์์/์๊ฒฝ.cpp | 61dcd0b1a23d04420315ff9fc3188ab4125e0f48 | [] | no_license | moonps/ProblemSolving | fa2d0e1da998f8f2be7bd485bb035dacf5aa8ab9 | b15c8fa0effe9b3d21cf13a90dba77940059c815 | refs/heads/master | 2020-06-14T16:32:15.284981 | 2019-10-19T15:18:19 | 2019-10-19T15:18:19 | 195,056,594 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,732 | cpp | #include<cstdio>
#include<vector>
#include<cstring>
#include<math.h>
using namespace std;
vector<pair<int, int>> v;
int arr[5][10];
int is_move[5];
// ๋๋ฆฌ์
void circle(){
for(int i=1; i<=4; i++){
if(is_move[i]==1){
int temp=arr[i][8];
for(int j=7; j>=1; j--){
arr[i][j+1]=arr[i][j];
}
arr[i][1]=temp;
} else if (is_move[i]== -1){
int temp=arr[i][1];
for(int j=2; j<=8; j++){
arr[i][j-1]=arr[i][j];
}
arr[i][8]=temp;
}
}
}
// ๋๋ ค์ผ๋๋์ง ํ์ธ
void check_arr(int num, int dir){
is_move[num]=dir;
for(int i=num; i<=3; i++){
if(arr[i][3]!=arr[i+1][7])
is_move[i+1]=is_move[i]*-1;
else
break;
}
for(int i=num; i>=2; i--){
if(arr[i][7]!=arr[i-1][3])
is_move[i-1]=is_move[i]*-1;
else
break;
}
circle();
memset(is_move,0,sizeof(is_move));
}
int main(void){
int t; scanf("%d", &t);
for(int tc=1; tc<=t; tc++){
int k; scanf("%d", &k);
for(int i=1; i<=4; i++){
for(int j=1; j<=8; j++)
scanf("%d", &arr[i][j]);
}
for(int i=1; i<=k; i++) {
int a,b; scanf("%d %d", &a, &b);
v.push_back(make_pair(a,b));
}
for(int i=0; i<v.size(); i++)
check_arr(v[i].first, v[i].second);
v.clear();
int sum=0;
for(int i=1; i<=4; i++){
if(arr[i][1]==1)
sum+=pow(2,i-1);
}
printf("#%d %d\n", tc, sum);
}
return 0;
} | [
"ch-aa@naver.com"
] | ch-aa@naver.com |
3038d71c883e38831a5a0ef8cecf5b375e17e8c4 | b3145d9bc238f87b541954f7ca007274eef04b71 | /test/string.cpp | b3fdf4ac784f72016b74a8b7cacf88b52fa90418 | [] | no_license | maksimus1210/compile_time | 92bb49a3009d22917be3105f99b802ab1721911b | 252c7d11be997404fef498b6f54b654b261dd0a5 | refs/heads/master | 2020-04-05T07:48:46.498360 | 2017-10-31T06:36:51 | 2017-11-23T16:45:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,100 | cpp | #define BOOST_TEST_DYN_LINK
#define BOOST_TEST_MODULE "String"
#include <string>
#include <boost/test/unit_test.hpp>
#include "compile_time/string.hpp"
#include "common.hpp"
namespace CT = compile_time;
BOOST_AUTO_TEST_CASE(strlen_test) {
CART_CHECK_EQUAL(CT::strlen(""), ::strlen(""));
CART_CHECK_EQUAL(CT::strlen("test string"), ::strlen("test string"));
CART_CHECK_EQUAL(CT::strlen("this is a very very long string"),
::strlen("this is a very very long string"));
}
BOOST_AUTO_TEST_CASE(strcmp_test) {
constexpr char empty[] = "";
constexpr char str[] = "small string";
constexpr char str1[] = "small string";
constexpr char str2[] = "a longer string";
constexpr char caps[] = "SMALL STRING";
CART_CHECK_EQUAL(sgn(CT::strcmp(str1, str1)), sgn(::strcmp(str1, str1)));
CART_CHECK_EQUAL(sgn(CT::strcmp(str, str1)), sgn(::strcmp(str, str1)));
CART_CHECK_EQUAL(sgn(CT::strcmp(str1, str2)), sgn(::strcmp(str1, str2)));
CART_CHECK_EQUAL(sgn(CT::strcmp(caps, str1)), sgn(::strcmp(caps, str1)));
CART_CHECK_EQUAL(sgn(CT::strcmp(empty, str1)), sgn(::strcmp(empty, str1)));
}
BOOST_AUTO_TEST_CASE(isalnum_test) CHAR_TEST(CT::isalnum, ::isalnum);
BOOST_AUTO_TEST_CASE(isalpha_test) CHAR_TEST(CT::isalpha, ::isalpha);
BOOST_AUTO_TEST_CASE(islower_test) CHAR_TEST(CT::islower, ::islower);
BOOST_AUTO_TEST_CASE(isupper_test) CHAR_TEST(CT::isupper, ::isupper);
BOOST_AUTO_TEST_CASE(isdigit_test) CHAR_TEST(CT::isdigit, ::isdigit);
BOOST_AUTO_TEST_CASE(iscntrl_test) CHAR_TEST(CT::iscntrl, ::iscntrl);
BOOST_AUTO_TEST_CASE(isgraph_test) CHAR_TEST(CT::isgraph, ::isgraph);
BOOST_AUTO_TEST_CASE(isspace_test) CHAR_TEST(CT::isspace, ::isspace);
BOOST_AUTO_TEST_CASE(isblank_test) CHAR_TEST(CT::isblank, ::isblank);
BOOST_AUTO_TEST_CASE(isprint_test) CHAR_TEST(CT::isprint, ::isprint);
BOOST_AUTO_TEST_CASE(ispunct_test) CHAR_TEST(CT::ispunct, ::ispunct);
BOOST_AUTO_TEST_CASE(tolower_test) CHAR_TEST(CT::tolower, ::tolower);
BOOST_AUTO_TEST_CASE(toupper_test) CHAR_TEST(CT::toupper, ::toupper);
BOOST_AUTO_TEST_CASE(isxdigit_test) CHAR_TEST(CT::isxdigit, ::isxdigit); | [
"lakshayg@outlook.in"
] | lakshayg@outlook.in |
60e9ba3004966bff9492b3d31645712c9cce44ac | a84b013cd995870071589cefe0ab060ff3105f35 | /webdriver/branches/chrome/chrome/src/cpp/include/chrome/Release/obj/V8Bindings/DerivedSources/V8CSSMediaRule.h | f53bac44b871dcb8c94adc52f8ed07d4819c9230 | [
"Apache-2.0"
] | permissive | vdt/selenium | 137bcad58b7184690b8785859d77da0cd9f745a0 | 30e5e122b068aadf31bcd010d00a58afd8075217 | refs/heads/master | 2020-12-27T21:35:06.461381 | 2009-08-18T15:56:32 | 2009-08-18T15:56:32 | 13,650,409 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,364 | h | /*
This file is part of the WebKit open source project.
This file has been generated by generate-bindings.pl. DO NOT MODIFY!
This library is free software; you can redistribute it and/or
modify it under the terms of the GNU Library 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
Library General Public License for more details.
You should have received a copy of the GNU Library General Public License
along with this library; see the file COPYING.LIB. If not, write to
the Free Software Foundation, Inc., 59 Temple Place - Suite 330,
Boston, MA 02111-1307, USA.
*/
#ifndef V8CSSMediaRule_H
#define V8CSSMediaRule_H
#include <v8.h>
#include <wtf/HashMap.h>
#include "StringHash.h"
namespace WebCore {
class V8ClassIndex;
class V8CSSMediaRule {
public:
static bool HasInstance(v8::Handle<v8::Value> value);
static v8::Persistent<v8::FunctionTemplate> GetRawTemplate();
private:
static v8::Persistent<v8::FunctionTemplate> GetTemplate();
friend class V8ClassIndex;
};
}
#endif // V8CSSMediaRule_H
| [
"noel.gordon@07704840-8298-11de-bf8c-fd130f914ac9"
] | noel.gordon@07704840-8298-11de-bf8c-fd130f914ac9 |
c9db0b4fe66725e74e44c89f511fd38f66410fa6 | ba63cfe1d4b142375ec65223dded3a74372da876 | /third_party/dawn/src/dawn_native/Format.h | 82b40d81ccee2aac6cab367fbddbaef2e330f642 | [
"Apache-2.0",
"LicenseRef-scancode-unknown-license-reference",
"BSD-3-Clause",
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT"
] | permissive | iseeyo/src | 5843b9c612769628480e2e218ea6a0974ebdf5fd | 1517a4f7cdab5e0688339edecb9f9e77f9cb8bf2 | refs/heads/master | 2023-06-01T09:11:21.303692 | 2021-07-11T13:00:23 | 2021-07-11T13:00:23 | 300,853,336 | 0 | 0 | BSD-3-Clause | 2020-12-02T11:09:16 | 2020-10-03T10:25:55 | null | UTF-8 | C++ | false | false | 2,698 | h | // Copyright 2019 The Dawn Authors
//
// 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 DAWNNATIVE_FORMAT_H_
#define DAWNNATIVE_FORMAT_H_
#include "dawn_native/dawn_platform.h"
#include "dawn_native/Error.h"
#include <array>
namespace dawn_native {
class DeviceBase;
// The number of formats Dawn knows about. Asserts in BuildFormatTable ensure that this is the
// exact number of known format.
static constexpr size_t kKnownFormatCount = 52;
// A wgpu::TextureFormat along with all the information about it necessary for validation.
struct Format {
enum Aspect {
Color,
Depth,
Stencil,
DepthStencil,
};
enum Type {
Float,
Sint,
Uint,
Other,
};
wgpu::TextureFormat format;
bool isRenderable;
bool isCompressed;
// A format can be known but not supported because it is part of a disabled extension.
bool isSupported;
bool supportsStorageUsage;
Aspect aspect;
Type type;
uint32_t blockByteSize;
uint32_t blockWidth;
uint32_t blockHeight;
static Type TextureComponentTypeToFormatType(wgpu::TextureComponentType componentType);
static wgpu::TextureComponentType FormatTypeToTextureComponentType(Type type);
bool IsColor() const;
bool HasDepth() const;
bool HasStencil() const;
bool HasDepthOrStencil() const;
bool HasComponentType(Type componentType) const;
// The index of the format in the list of all known formats: a unique number for each format
// in [0, kKnownFormatCount)
size_t GetIndex() const;
};
// Implementation details of the format table in the device.
using FormatTable = std::array<Format, kKnownFormatCount>;
// Returns the index of a format in the FormatTable.
size_t ComputeFormatIndex(wgpu::TextureFormat format);
// Builds the format table with the extensions enabled on the device.
FormatTable BuildFormatTable(const DeviceBase* device);
} // namespace dawn_native
#endif // DAWNNATIVE_FORMAT_H_
| [
"arnaud@geometry.ee"
] | arnaud@geometry.ee |
e70fb060fd5e952329da6bfadb3f2183eb5c2502 | 5427bd70e08a4fb7966aad2a907673a8af77ed5e | /ljutova_ts/Practice/Practice7/main.cpp | 7a43611b31df5e2419294d632f744dc29d138305 | [] | no_license | lutovatanya/mp1-practice | 5e34c507233cbe9721bea2bdcd4c813bc838dd2d | 51e9315196548d694d4f512a6f1208326cade352 | refs/heads/master | 2020-03-28T10:43:39.197875 | 2019-06-03T07:41:42 | 2019-06-03T07:41:42 | 148,138,657 | 0 | 0 | null | 2019-06-03T10:29:04 | 2018-09-10T10:28:07 | C++ | UTF-8 | C++ | false | false | 2,386 | cpp | ๏ปฟ#include "Vector.h"
#include "main.h"
using namespace std;
int main()
{
int n1;
cout << "Enter size vector 1: ";
cin >> n1;
Vector v1(n1);
cout << " Enter coordinats" << " V1 = " << endl;
cin >> v1;
cout << "Coordinates of your vector: ";
cout << v1;
cout << endl << endl;
int n2;
cout << "Enter size vector 2: ";
cin >> n2;
Vector v2(n2);
cout << " Enter coordinates" << " V2 = " << endl;
cin >> v2;
cout << "Coordinates of your vector: ";
cout << v2;
cout << endl << endl;
int a;
double l, m;
try
{
cout << "Addition of this vector: ";
cout << " V1 + V2 = V ( " << (v1 + v2) << ")" << endl;
}
catch (Vector1)
{
cout << "Different size \n";
}
try
{
cout << "Subtraction of this vector: ";
cout << " V1 - V2 = V ( " << (v1 - v2) << ")" << endl << endl;
}
catch (Vector1)
{
cout << "Different size \n";
}
try
{
cout << "Scalar product of two vectors = " << (v1 * v2);
cout << endl;
}
catch (Vector1)
{
cout << "Different size \n";
}
try
{
cout << "Enter const for addition with Vector 1: ";
cin >> a;
cout << " V1 + const = V ( " << (v1 + a) << ")" << endl;
cout << "Enter const for subtraction with Vector 1: ";
cin >> a;
cout << " V1 - const = V ( " << (v1 - a) << ")" << endl;
cout << "Enter const for multiplication with Vector 1: ";
cin >> a;
cout << " V1 * const = V ( " << (v1 * a) << ")" << endl;
cout << endl;
v1 += v2;
cout << " V1 += V2 = V ( " << v1 << ")" << endl;
v1 -= v2;
cout << " V1 -= V2 = V ( " << v1 << ")" << endl;
cout << endl;
cout << "Enter const for addition with Vector 1 (+=): ";
cin >> a;
v1 += a;
cout << " V1 += const = V ( " << v1 << ")" << endl;
cout << "Enter const for subtraction with Vector 1(-=): ";
cin >> a;
v1 -= a;
cout << " V1 -= const = V ( " << v1 << ")" << endl << endl;
l = v1.Lenght(v1);
cout << "Lenght of vector 1: " << l << endl;
m = v2.Lenght(v2);
cout << "Lenght of vector 2: " << m << endl;
}
catch (Vector1)
{
cout << "Different size \n";
}
} | [
"lutovat20@gmail.com"
] | lutovat20@gmail.com |
6688ede0fbcd3749738f2844354e8d597d4f95a0 | ad59cfb990622e8e66ea5719f73b1c8f58544835 | /src/main.cpp | 914aac759d79f75398ed3c8065838b2ea0c85c5a | [] | no_license | balduvian/Language568 | 48af8c94d88de79e06c1c74e6d4f1a47b89abe06 | c12520f923e9da7aff2c0e2a1f3adb19752e8bec | refs/heads/master | 2023-02-23T15:03:02.878091 | 2021-01-30T03:59:39 | 2021-01-30T03:59:39 | 225,721,152 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 684 | cpp |
#include <iostream>
#include "image/image.h"
#include "engine568.h"
int main(int argc, char ** argv) {
if (argc != 2) {
std::cout << "need 1 argument" << std::endl;
return 2;
}
auto image = CNGE::Image::fromPNG(argv[1]);
if (image == nullptr || !image->isValid()) {
std::cout << "invalid filename" << std::endl;
return 2;
}
auto engine = Engine568();
engine.load(image->getWidth(), image->getHeight(), image->getPixels());
engine.pushInt(5);
engine.run();
std::cout << std::endl;
auto err = engine.getError();
if (!err.empty()) std::cout << err << std::endl;
std::cout << "Exited at " << engine.getX() << ", " << engine.getY() << std::endl;
return 0;
}
| [
"emmettglaser@gmail.com"
] | emmettglaser@gmail.com |
8fd95bc3210c022101dcabcd2fd02c2825712cb4 | a349be8a5d6ba5a4af843f918a6fe6eff01dc33b | /Source/GOAPerDemo/GOAPerDemo.cpp | d2fe7f2ab74a28ca66d2f386df632a56d5b2912f | [
"LicenseRef-scancode-warranty-disclaimer",
"MIT"
] | permissive | denfrost/GOAPerDemo | 59c82ad506dfda4e7c29e07c9cc177fd24be2c17 | d5d7fbc6bd9079e15a5aaa64e86f7d0fcc501105 | refs/heads/master | 2020-03-27T02:26:35.450414 | 2018-09-21T03:35:31 | 2018-09-21T03:35:31 | 145,790,605 | 0 | 0 | MIT | 2018-08-23T02:42:05 | 2018-08-23T02:42:05 | null | UTF-8 | C++ | false | false | 188 | cpp | // Fill out your copyright notice in the Description page of Project Settings.
#include "GOAPerDemo.h"
IMPLEMENT_PRIMARY_GAME_MODULE( FDefaultGameModuleImpl, GOAPerDemo, "GOAPerDemo" );
| [
"chrisashworth@appzeit.com"
] | chrisashworth@appzeit.com |
43a85b603ea768fbca118762317f2f5927080e9e | f0dbabac157fc79094062513cfcc28be253d9b70 | /modules/log/src/Log.cpp | f75e89b42b96c2a9ef898299aaf058435fa6bb27 | [
"Apache-2.0"
] | permissive | TankerHQ/sdk-native | 4c3a81d83a9e144c432ca74c3e327225e6814e91 | c062edc4b6ad26ce90e0aebcc2359adde4ca65db | refs/heads/master | 2023-08-19T02:59:40.445973 | 2023-08-09T12:04:46 | 2023-08-09T12:04:46 | 160,206,027 | 20 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 515 | cpp |
#include <Tanker/Log/Log.hpp>
#include <Tanker/Log/LogHandler.hpp>
#include <Tanker/Log/Record.hpp>
namespace Tanker::Log
{
void format(Log::Level level,
char const* cat,
char const* file,
std::uint32_t line,
fmt::string_view format,
fmt::format_args args)
{
auto const message = fmt::vformat(format, args);
auto const record = Record{
cat,
level,
file,
line,
message.c_str(),
};
detail::currentHandler(record);
}
} | [
"alexandre.bossard@tanker.io"
] | alexandre.bossard@tanker.io |
fbb8c5fd322ab57aaf9049a8f469705c7e1bd8b3 | 2f53b2c0264f982ccd9a50772f8bdfe1c2c2d890 | /Samsung/Samsung/17140_์ด์ฐจ์_๋ฐฐ์ด๊ณผ_์ฐ์ฐ.cpp | 73bd7d54a83746301b97751ea5b562d77d9a03cc | [] | no_license | GGimDong/SAMSUNG-CODING-TEST | 2518e3648a6297920a72b9ed8f4650d54a49cb1a | 6406dab799ce2ff7238b99b3301168eba12d7bfd | refs/heads/master | 2022-12-23T11:22:55.019301 | 2020-09-29T10:53:28 | 2020-09-29T10:53:28 | 266,772,685 | 0 | 0 | null | null | null | null | WINDOWS-1252 | C++ | false | false | 2,632 | cpp | #include <iostream>
#include <vector>
#include <algorithm>
using namespace std;
int r, c, k;
int arr[101][101];
int X = 3, Y = 3;
int temp_X, temp_Y;
struct p {
int idx;
int num = 0;
};
p make_p(int a) {
p t;
t.idx = a, t.num = 1;
return t;
}
bool cmp(p a, p b) {
if (a.num < b.num) return true;
else if (a.num == b.num && a.idx < b.idx) return true;
return false;
}
void R(int idx) {
vector<p> v;
/*ยตรฐยนรถยฑรซ*/ //cout << "work line " << idx << ": ";
for (int i = 1; i <= Y; i++) {
int t = arr[idx][i];
if (t == 0) continue;
arr[idx][i] = 0;
/*ยตรฐยนรถยฑรซ*/ //cout << t << " ";
bool is_new = true;
for (int j = 0; j < v.size(); j++)
if (v[j].idx == t) {
is_new = false;
v[j].num++;
break;
}
if (is_new) v.push_back(make_p(t));
}
sort(v.begin(), v.end(), cmp);
/*ยตรฐยนรถยฑรซ*/// cout << endl; for (int i = 0; i < v.size(); i++) cout << v[i].idx << " " << v[i].num << " "; cout << endl;
int size = 2 * v.size();
if (size > 100) size = 100;
temp_Y = max(temp_Y, size);
for (int i = 0; i < size / 2; i++) {
arr[idx][1+2*i] = v[i].idx, arr[idx][2+2*i] = v[i].num;
}
}
void C(int idx) {
vector<p> v;
/*ยตรฐยนรถยฑรซ*/ //cout << "work line " << idx << ": ";
for (int i = 1; i <= Y; i++) {
int t = arr[i][idx];
if (t == 0) continue;
arr[i][idx] = 0;
/*ยตรฐยนรถยฑรซ*/ //cout << t << " ";
bool is_new = true;
for (int j = 0; j < v.size(); j++)
if (v[j].idx == t) {
is_new = false;
v[j].num++;
break;
}
if (is_new) v.push_back(make_p(t));
}
sort(v.begin(), v.end(), cmp);
/*ยตรฐยนรถยฑรซ*/ //cout << endl; for (int i = 0; i < v.size(); i++) cout << v[i].idx << " " << v[i].num << " "; cout << endl;
int size = 2 * v.size();
if (size > 100) size = 100;
temp_X = max(temp_X, size);
for (int i = 0; i < size/2; i++) {
arr[1 + 2 * i][idx] = v[i].idx, arr[2 + 2 * i][idx] = v[i].num;
}
}
int main() {
cin >> r >> c >> k;
for (int i = 1; i <= 3; i++)
for (int j = 1; j <= 3; j++)
cin >> arr[i][j];
int ans = -1;
for (int time = 0; time <= 100; time++) {
if (arr[r][c] == k) {
ans = time;
break;
}
temp_X = -1, temp_Y = -1;
if (X >= Y) { // R ยฟยฌยปรช
for (int i = 1; i <= X; i++) R(i);
Y = temp_Y;
/*ยตรฐยนรถยฑรซ*/ //cout << "New Y: " << Y << endl;
}
else { // C ยฟยฌยปรช
for (int i = 1; i <= Y; i++) C(i);
X = temp_X;
/*ยตรฐยนรถยฑรซ*/ //cout << "New X: " << X << endl;
}
/*ยตรฐยนรถยฑรซ*/
/*for (int i = 1; i <= X; i++) {
for (int j = 1; j <= Y; j++) {
cout << arr[i][j] << " ";
}cout << endl;
}*/
/*ยตรฐยนรถยฑรซ*///system("pause");
}
cout << ans;
return 0;
} | [
"boramatlulu@gmail.com"
] | boramatlulu@gmail.com |
40bbb1676d74105f53850cf443caff79ee1627b7 | f2b71319845eda397df343d3e6963d7e8de85543 | /cpp/include/Packet.h | 133fd01dccdbfec7a61f792c7c0860bb930dc0f1 | [] | no_license | jonturner53/forest-net | a2730d6bd1d336736ceb2f94f0c5394d8df80220 | ce22e8a6419da4af35b60ba97e05c2b6b8f90814 | refs/heads/master | 2020-05-17T16:24:03.670402 | 2015-03-14T13:54:46 | 2015-03-14T13:54:46 | 32,215,782 | 4 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,852 | h | /** @file Packet.h
*
* @author Jon Turner
* @date 2011
* This is open source software licensed under the Apache 2.0 license.
* See http://www.apache.org/licenses/LICENSE-2.0 for details.
*/
#ifndef PACKET_H
#define PACKET_H
#include "Forest.h"
namespace forest {
/** Class that defines fields in Forest packets.
* Note, packet fields and buffer are directly accessible. Use with care.
*/
class Packet {
public:
Packet();
~Packet();
int static const HDRLEN = 5*sizeof(uint32_t);
int static const OVERHEAD = HDRLEN + sizeof(uint32_t);
bool unpack();
bool pack();
uint32_t* payload() const { return &((*buffer)[5]); };
/** buffer error checking */
bool hdrErrCheck() const;
bool payErrCheck() const;
void hdrErrUpdate();
void payErrUpdate();
/** input/output */
bool read(istream&);
string toString() const;
static string pktTyp2string(Forest::ptyp_t);
static bool string2pktTyp(string&, Forest::ptyp_t&);
friend ostream& operator<<(ostream& out, const Packet& p) {
return out << p.toString();
}
// packet fields - note: all public
int version; ///< version number field
int length; ///< length field
Forest::ptyp_t type; ///< packet type field
flgs_t flags; ///< flags
comt_t comtree; ///< comtree field
fAdr_t srcAdr; ///< source address
fAdr_t dstAdr; ///< destination address
int inLink; ///< link on which packet arrived
int outLink; ///< outgoing link for packet
int outQueue; ///< outgoing queue for packet
ipa_t tunIp; ///< peer IP addr from substrate header
ipp_t tunPort; ///< peer port # from substrate header
int64_t rcvSeqNum; ///< used by router to identify packets
int bufferLen; ///< number of valid bytes in buffer
buffer_t* buffer; ///< pointer to packet buffer
private:
};
} // ends namespace
#endif
| [
"jonturneratwustl@gmail.com@859b52aa-9282-db45-41ff-2f5699c6ee4d"
] | jonturneratwustl@gmail.com@859b52aa-9282-db45-41ff-2f5699c6ee4d |
9c7422b2111576f4c4a1e3f2116e4a23c50e1862 | 53733f73b922407a958bebde5e674ec7f045d1ba | /VIR/0904pm/agc047_a/main0.cpp | 04ba673a7d23642a24e713d855c4a0e044c78e97 | [] | no_license | makio93/atcoder | 040c3982e5e867b00a0d0c34b2a918dd15e95796 | 694a3fd87b065049f01f7a3beb856f8260645d94 | refs/heads/master | 2021-07-23T06:22:59.674242 | 2021-03-31T02:25:55 | 2021-03-31T02:25:55 | 245,409,583 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,603 | cpp | #include <bits/stdc++.h>
using namespace std;
const long long mod = 1e9 + 7;
using ll = long long;
using pii = pair<int, int>;
using pll = pair<ll, ll>;
#define ull unsigned long long
#define ld long double
#define vi vector<int>
#define vll vector<ll>
#define vc vector<char>
#define vs vector<string>
#define vpii vector<pii>
#define vpll vector<pll>
#define rep(i, n) for (int i = 0, i##_len = (n); i < i##_len; i++)
#define rep1(i, n) for (int i = 1, i##_len = (n); i <= i##_len; i++)
#define repr(i, n) for (int i = ((int)(n)-1); i >= 0; i--)
#define rep1r(i, n) for (int i = ((int)(n)); i >= 1; i--)
#define sz(x) ((int)(x).size())
#define all(x) (x).begin(), (x).end()
#define rall(x) (x).rbegin(), (x).rend()
#define SORT(v, n) sort(v, v + n);
#define VSORT(v) sort(v.begin(), v.end());
#define RSORT(x) sort(rall(x));
#define pb push_back
#define mp make_pair
#define INF (1e9)
#define PI (acos(-1))
#define EPS (1e-7)
ull gcd(ull a, ull b) { return b ? gcd(b, a % b) : a; }
ull lcm(ull a, ull b) { return a / gcd(a, b) * b; }
int main(){
int n;
cin >> n;
vector<pair<ll, int>> a(n);
rep(i, n) {
string s;
cin >> s;
bool point = false;
rep(i, sz(s)) {
if (s[i] == '.') {
point = true;
a[i].second = sz(s) - i - 1;
a[i].first = stoll(s.substr(0, i)) * a[i].second + stoll(s.substr(i+1, a[i].second));
break;
}
}
if (!point) {
a[i].first = stoll(s);
a[i].second = 0;
}
}
vpii prime(n);
rep(i, n) {
ll num = a[i].first;
while (num%2==0 && num>0) {
num /= 2;
prime[i].first++;
}
while (num%5==0 && num>0) {
num /= 5;
prime[i].second++;
}
prime[i].first -= a[i].second - 10;
prime[i].second -= a[i].second - 10;
//if (prime[i].first<0 || prime[i].second<0) cout << "error" << endl;
}
vector<vi> cnt(61, vi(61));
vector<vll> csum(61, vll(61));
rep(i, n) cnt[prime[i].first][prime[i].second]++;
repr(i, 60) repr(j, 60) {
csum[i][j] = csum[i+1][j] + csum[i][j+1] - csum[i+1][j+1] + cnt[i][j];
}
ll ans = 0;
for (int i=0; i<=60; ++i) for (int j=0; j<=60; ++j) {
int nf = i-10, ns = j-10;
if (nf>=0 && ns>=0) continue;
int ti = -nf + 10, tj = -ns + 10;
ans += cnt[i][j] * csum[max(0,ti)][max(0,tj)] / 2;
}
ans /= 2;
ans += csum[10][10] * (csum[10][10] - 1) / 2;
cout << ans << endl;
return 0;
}
| [
"mergon-nitro-pale_fluorelight@hotmail.co.jp"
] | mergon-nitro-pale_fluorelight@hotmail.co.jp |
9280ff17f03b55254deabcae21f72f7764cf0a79 | c6392d2e028a1671c7527b05d2596c13b37d2e83 | /hhvm-3.2-include/hphp/third-party/folly/gen/String-inl.h | 651252f511510967d363c5cb39333c06c255ed38 | [
"PHP-3.01"
] | permissive | sandeepone/hhvm_ext_pcurl | 7a47ced0b54639c8c9b1dfb820a55cd0e03aaccf | d445f6b47c66e646e039a71d8e22860a5831e0a6 | refs/heads/master | 2021-01-15T17:51:32.224760 | 2015-04-21T15:49:37 | 2015-04-21T15:49:37 | 42,769,830 | 2 | 0 | null | 2015-09-19T11:05:17 | 2015-09-19T11:05:17 | null | UTF-8 | C++ | false | false | 8,640 | h | /*
* Copyright 2014 Facebook, Inc.
*
* 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 FOLLY_GEN_STRING_H
#error This file may only be included from folly/gen/String.h
#endif
#include "folly/Conv.h"
#include "folly/String.h"
#include "folly/io/IOBuf.h"
namespace folly {
namespace gen {
namespace detail {
inline bool splitPrefix(StringPiece& in,
StringPiece& prefix,
StringPiece delimiter) {
auto p = in.find(delimiter);
if (p != std::string::npos) {
prefix.assign(in.data(), in.data() + p);
in.advance(p + delimiter.size());
return true;
}
prefix.clear();
return false;
}
/**
* Split by any of the EOL terms: \r, \n, or \r\n.
*/
inline bool splitPrefix(StringPiece& in,
StringPiece& prefix,
MixedNewlines) {
auto newline = "\r\n";
auto p = in.find_first_of(newline);
if (p != std::string::npos) {
prefix.assign(in.data(), in.data() + p);
in.advance(p);
if (!in.removePrefix(newline)) {
in.advance(1);
}
return true;
}
prefix.clear();
return false;
}
inline bool splitPrefix(StringPiece& in, StringPiece& prefix, char delimiter) {
auto p = static_cast<const char*>(memchr(in.data(), delimiter, in.size()));
if (p) {
prefix.assign(in.data(), p);
in.assign(p + 1, in.end());
return true;
}
prefix.clear();
return false;
}
inline const char* ch(const unsigned char* p) {
return reinterpret_cast<const char*>(p);
}
class StringResplitter : public Operator<StringResplitter> {
char delimiter_;
public:
explicit StringResplitter(char delimiter) : delimiter_(delimiter) { }
template <class Source>
class Generator : public GenImpl<StringPiece, Generator<Source>> {
Source source_;
char delimiter_;
public:
Generator(Source source, char delimiter)
: source_(std::move(source)), delimiter_(delimiter) { }
template <class Body>
bool apply(Body&& body) const {
std::unique_ptr<IOBuf> buffer;
auto fn = [&](StringPiece in) -> bool {
StringPiece prefix;
bool found = splitPrefix(in, prefix, this->delimiter_);
if (found && buffer && buffer->length() != 0) {
// Append to end of buffer, return line
if (!prefix.empty()) {
buffer->reserve(0, prefix.size());
memcpy(buffer->writableTail(), prefix.data(), prefix.size());
buffer->append(prefix.size());
}
if (!body(StringPiece(ch(buffer->data()), buffer->length()))) {
return false;
}
buffer->clear();
found = splitPrefix(in, prefix, this->delimiter_);
}
// Buffer is empty, return lines directly from input (no buffer)
while (found) {
if (!body(prefix)) {
return false;
}
found = splitPrefix(in, prefix, this->delimiter_);
}
if (!in.empty()) {
// Incomplete line left, append to buffer
if (!buffer) {
// Arbitrarily assume that we have half a line and get enough
// room for twice that.
constexpr size_t kDefaultLineSize = 256;
buffer = IOBuf::create(std::max(kDefaultLineSize, 2 * in.size()));
}
buffer->reserve(0, in.size());
memcpy(buffer->writableTail(), in.data(), in.size());
buffer->append(in.size());
}
return true;
};
// Iterate
if (!source_.apply(std::move(fn))) {
return false;
}
// Incomplete last line
if (buffer && buffer->length() != 0) {
if (!body(StringPiece(ch(buffer->data()), buffer->length()))) {
return false;
}
}
return true;
}
static constexpr bool infinite = Source::infinite;
};
template<class Source,
class Value,
class Gen = Generator<Source>>
Gen compose(GenImpl<Value, Source>&& source) const {
return Gen(std::move(source.self()), delimiter_);
}
template<class Source,
class Value,
class Gen = Generator<Source>>
Gen compose(const GenImpl<Value, Source>& source) const {
return Gen(source.self(), delimiter_);
}
};
template <class DelimiterType = char>
class SplitStringSource
: public GenImpl<StringPiece, SplitStringSource<DelimiterType>> {
StringPiece source_;
DelimiterType delimiter_;
public:
SplitStringSource(const StringPiece& source,
DelimiterType delimiter)
: source_(source)
, delimiter_(std::move(delimiter)) { }
template <class Body>
bool apply(Body&& body) const {
StringPiece rest(source_);
StringPiece prefix;
while (splitPrefix(rest, prefix, this->delimiter_)) {
if (!body(prefix)) {
return false;
}
}
if (!rest.empty()) {
if (!body(rest)) {
return false;
}
}
return true;
}
};
/**
* Unsplit - For joining tokens from a generator into a string. This is
* the inverse of `split` above.
*
* This type is primarily used through the 'unsplit' function.
*/
template<class Delimiter,
class Output>
class Unsplit : public Operator<Unsplit<Delimiter, Output>> {
Delimiter delimiter_;
public:
explicit Unsplit(const Delimiter& delimiter)
: delimiter_(delimiter) {
}
template<class Source,
class Value>
Output compose(const GenImpl<Value, Source>& source) const {
Output outputBuffer;
UnsplitBuffer<Delimiter, Output> unsplitter(delimiter_, &outputBuffer);
unsplitter.compose(source);
return outputBuffer;
}
};
/**
* UnsplitBuffer - For joining tokens from a generator into a string,
* and inserting them into a custom buffer.
*
* This type is primarily used through the 'unsplit' function.
*/
template<class Delimiter,
class OutputBuffer>
class UnsplitBuffer : public Operator<UnsplitBuffer<Delimiter, OutputBuffer>> {
Delimiter delimiter_;
OutputBuffer* outputBuffer_;
public:
UnsplitBuffer(const Delimiter& delimiter, OutputBuffer* outputBuffer)
: delimiter_(delimiter)
, outputBuffer_(outputBuffer) {
CHECK(outputBuffer);
}
template<class Source,
class Value>
void compose(const GenImpl<Value, Source>& source) const {
// If the output buffer is empty, we skip inserting the delimiter for the
// first element.
bool skipDelim = outputBuffer_->empty();
source | [&](Value v) {
if (skipDelim) {
skipDelim = false;
toAppend(std::forward<Value>(v), outputBuffer_);
} else {
toAppend(delimiter_, std::forward<Value>(v), outputBuffer_);
}
};
}
};
/**
* Hack for static for-like constructs
*/
template<class Target, class=void>
inline Target passthrough(Target target) { return target; }
#pragma GCC diagnostic push
#ifdef __clang__
// Clang isn't happy with eatField() hack below.
#pragma GCC diagnostic ignored "-Wreturn-stack-address"
#endif // __clang__
/**
* ParseToTuple - For splitting a record and immediatlely converting it to a
* target tuple type. Primary used through the 'eachToTuple' helper, like so:
*
* auto config
* = split("1:a 2:b", ' ')
* | eachToTuple<int, string>()
* | as<vector<tuple<int, string>>>();
*
*/
template<class TargetContainer,
class Delimiter,
class... Targets>
class SplitTo {
Delimiter delimiter_;
public:
explicit SplitTo(Delimiter delimiter)
: delimiter_(delimiter) {}
TargetContainer operator()(StringPiece line) const {
int i = 0;
StringPiece fields[sizeof...(Targets)];
// HACK(tjackson): Used for referencing fields[] corresponding to variadic
// template parameters.
auto eatField = [&]() -> StringPiece& { return fields[i++]; };
if (!split(delimiter_,
line,
detail::passthrough<StringPiece&, Targets>(eatField())...)) {
throw std::runtime_error("field count mismatch");
}
i = 0;
return TargetContainer(To<Targets>()(eatField())...);
}
};
#pragma GCC diagnostic pop
} // namespace detail
} // namespace gen
} // namespace folly
| [
"adriang@gmx.net"
] | adriang@gmx.net |
459f0eaee036bee9bc096258ab4c22efbb18aeb9 | 77a091c62781f6aefeebdfd6efd4bab9caa51465 | /Done/Random/E346.cpp | 6e3f4152b415fe37c1bf3f7f9786860d5cbcf60f | [] | no_license | breno-helf/Maratona | 55ab11264f115592e1bcfd6056779a3cf27e44dc | c6970bc554621746cdb9ce53815b8276a4571bb3 | refs/heads/master | 2021-01-23T21:31:05.267974 | 2020-05-05T23:25:23 | 2020-05-05T23:25:23 | 57,412,343 | 1 | 2 | null | 2017-01-25T14:58:46 | 2016-04-29T20:54:08 | C++ | UTF-8 | C++ | false | false | 952 | cpp | #include<bits/stdc++.h>
using namespace std;
#define debug(args...) fprintf(stderr,args)
const int MAXN=112345;
const int INF=0x3f3f3f3f;
vector<int> adj[MAXN];
vector< pair<int,int> > edg;
pair<int,int> cmp[MAXN];
int marc[MAXN],resp,num,n,m;
int dfs(int x){
marc[x]=1;
int tam=adj[x].size();
(cmp[num].first)++;
for(int h=0;h<tam;h++){
int prox=adj[x][h];
(cmp[num].second)++;
if(marc[prox]==0){
dfs(prox);
}
}
}
int lanc(int ini){
cmp[num].first=0;
cmp[num].second=0;
dfs(ini);
cmp[num].second/=2;
if(cmp[num].first==(cmp[num].second+1)){
num++;
return 1;
}
else{
num++;
return 0;
}
}
int main(){
resp=0;
num=0;
scanf("%d%d", &n, &m);
for(int i=0;i<m;i++){
int a,b;
scanf("%d%d", &a, &b);
adj[a].push_back(b);
adj[b].push_back(a);
edg.push_back(make_pair(a,b));
edg.push_back(make_pair(b,a));
}
for(int i=1;i<=n;i++) if(marc[i]==0) resp+=lanc(i);
printf("%d\n", resp);
return 0;
}
| [
"breno.moura@hotmail.com"
] | breno.moura@hotmail.com |
29a8caa95646ef31ba7438e26c76225de2eda90e | 6cd69d24276d418be9fb3ad5fbb850bdcaca9f7e | /oss_src/fiber/fiber_conditional.hpp | 9c056e2c9026d9d48ba58093b0b633c8d51e9c84 | [
"BSD-3-Clause",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | charles2648/SFrame | e8cd14074932635af067aa20a86d1a9cbf7cf698 | 43fdd3ed9fde4ec0f26d548b5f1eebb4cdf1bea5 | refs/heads/master | 2021-01-18T11:23:21.447110 | 2016-03-16T08:51:56 | 2016-03-16T08:51:56 | 54,029,970 | 1 | 0 | null | 2016-03-16T12:29:02 | 2016-03-16T12:29:02 | null | UTF-8 | C++ | false | false | 2,856 | hpp | /**
* Copyright (C) 2015 Dato, Inc.
* All rights reserved.
*
* This software may be modified and distributed under the terms
* of the BSD license. See the LICENSE file for details.
*/
#ifndef GRAPHLAB_FIBER_CONDITIONAL_HPP
#define GRAPHLAB_FIBER_CONDITIONAL_HPP
#include <vector>
#include <queue>
#include <fiber/fiber_control.hpp>
namespace graphlab {
/**
* \ingroup util
* Wrapper around pthread's condition variable, that can work with both
* fibers and threads simultaneously, but at a cost of much greater memory
* requirements.
*
* Limitations.
* - Does not support timed wait
* - threads and fibers are not queued perfectly. fibers are preferentially
* signaled.
*
* Before you use, see \ref parallel_object_intricacies.
*/
class fiber_conditional {
private:
mutable pthread_cond_t m_cond;
mutex lock;
mutable std::queue<size_t> fibers; // used to hold the fibers that are waiting here
// not copyable
void operator=(const fiber_conditional& m) { }
public:
fiber_conditional() {
int error = pthread_cond_init(&m_cond, NULL);
ASSERT_TRUE(!error);
}
/** Copy constructor which does not copy. Do not use!
Required for compatibility with some STL implementations (LLVM).
which use the copy constructor for vector resize,
rather than the standard constructor. */
fiber_conditional(const fiber_conditional &) {
int error = pthread_cond_init(&m_cond, NULL);
ASSERT_TRUE(!error);
}
/// Waits on condition. The mutex must already be acquired. Caller
/// must be careful about spurious wakes.
inline void wait(const mutex& mut) const {
size_t tid = fiber_control::get_tid();
if (tid > 0) {
lock.lock();
fibers.push(tid);
lock.unlock();
fiber_control::deschedule_self(&mut.m_mut);
mut.lock();
} else {
int error = pthread_cond_wait(&m_cond, &mut.m_mut);
ASSERT_TRUE(!error);
}
}
/// Signals one waiting thread to wake up
inline void signal() const {
if (!fibers.empty()) {
lock.lock();
if (!fibers.empty()) {
size_t tid = fibers.front();
fibers.pop();
lock.unlock();
fiber_control::schedule_tid(tid);
return;
}
lock.unlock();
}
int error = pthread_cond_signal(&m_cond);
ASSERT_TRUE(!error);
}
/// Wakes up all waiting threads
inline void broadcast() const {
lock.lock();
while (!fibers.empty()) {
size_t tid = fibers.front();
fibers.pop();
fiber_control::schedule_tid(tid);
}
lock.unlock();
int error = pthread_cond_broadcast(&m_cond);
ASSERT_TRUE(!error);
}
~fiber_conditional() {
ASSERT_EQ(fibers.size(), 0);
int error = pthread_cond_destroy(&m_cond);
ASSERT_TRUE(!error);
}
};
}
#endif
| [
"toby@dato.com"
] | toby@dato.com |
47a545bcdd47ab890a229b7af6c5348538d02951 | ac0ae7f42f80131ec34490eec2498f50d96adf92 | /output/messages/FriendUpdateMessage.cpp | 2c3b3ae0d622f533ead33e0d75e0cfe005f4adf4 | [] | no_license | w0dm4n/Protocol-builder-Ankama-2.4x | 2fad5d35467ee2cb0a5cfe7b2729c9b0170bae00 | 1b521c9e9eed8ebc3f62b72a699cf27c2ba139f8 | refs/heads/master | 2021-01-20T09:07:33.673393 | 2017-05-04T08:19:16 | 2017-05-04T08:19:16 | 90,224,495 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 717 | cpp | #include "FriendUpdateMessage.hpp"
FriendUpdateMessage::FriendUpdateMessage(FriendInformations& friendUpdated)
{
this->friendUpdated = friendUpdated;
}
FriendUpdateMessage::FriendUpdateMessage()
{
}
ushort FriendUpdateMessage::getId()
{
return id;
}
std::string FriendUpdateMessage::getName()
{
return "FriendUpdateMessage";
}
void FriendUpdateMessage::serialize(BinaryWriter& writer)
{
writer.writeShort(this->friendUpdated.getId());
this->friendUpdated.serialize(writer);
}
void FriendUpdateMessage::deserialize(BinaryReader& reader)
{
{
int _loc2_ = reader.readUnsignedShort();
this->friendUpdated.deserialize(reader);
}
} | [
"w0dm4n@hotmail.fr"
] | w0dm4n@hotmail.fr |
d713887c8c9b5ea449d323ab1e091b47ed4dbd44 | b8499de1a793500b47f36e85828f997e3954e570 | /v2_3/build/Android/Debug/app/src/main/include/OpenGL.GLIndexType.h | 1e89b1e012d3ce7fff0eee17f2166689f7559bfc | [] | no_license | shrivaibhav/boysinbits | 37ccb707340a14f31bd57ea92b7b7ddc4859e989 | 04bb707691587b253abaac064317715adb9a9fe5 | refs/heads/master | 2020-03-24T05:22:21.998732 | 2018-07-26T20:06:00 | 2018-07-26T20:06:00 | 142,485,250 | 0 | 0 | null | 2018-07-26T20:03:22 | 2018-07-26T19:30:12 | C++ | UTF-8 | C++ | false | false | 352 | h | // This file was generated based on C:/Users/Vaibhav/AppData/Local/Fusetools/Packages/UnoCore/1.9.0/Source/OpenGL/GLEnums.uno.
// WARNING: Changes might be lost if you edit this file directly.
#pragma once
#include <Uno.Int.h>
namespace g{
namespace OpenGL{
// public extern enum GLIndexType :166
uEnumType* GLIndexType_typeof();
}} // ::g::OpenGL
| [
"shubhamanandoist@gmail.com"
] | shubhamanandoist@gmail.com |
1eb628c13d77e330b8f4be5f230e48cd21cdbe60 | 9cc00bc45c12d4b49c852af42a4cdc2303a5735b | /sse_util.inl | 91d0b638640ba5375ac6ef96b5d454d3920f57ff | [
"MIT"
] | permissive | Hengle/BlueNoiseGenerator | 6f4f70e4a01043e6f8ad82f768ad2e6e5e77e79d | 6dd1a27c355ef9e45e7ee9ba93bf03780ce0fc7d | refs/heads/master | 2021-06-10T04:11:35.213387 | 2017-02-03T13:33:00 | 2017-02-03T13:33:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,016 | inl | #include "debug_opt.h"
#if !defined(OLD_VER)
#ifndef SSE_UTIL_INCLUDE_START
#error Please do not include this file directly, include "sse_util.h" instead.
#endif
#ifdef USE_SSE
inline __m128 Negate(__m128 value)
{
return _mm_xor_ps(value, _mm_set1_ps(-0.0));
}
inline __m128 Mad(__m128 v0, __m128 v1, __m128 v2)
{
return _mm_add_ps(_mm_mul_ps(v0, v1), v2);
}
inline __m128 FastPowSSEVector(__m128 value, float exponent)
{
if (exponent == 0.5f)
{
return _mm_rcp_ps(_mm_rsqrt_ps(value));
}
else if (exponent == 0.25f)
{
return _mm_rsqrt_ps(_mm_rsqrt_ps(value));
}
else if (exponent == 1.f)
{
return value;
}
const SSERegister &sseReg = (const SSERegister &)value;
return _mm_set_ps(powf(sseReg.s[0], exponent), powf(sseReg.s[1], exponent), powf(sseReg.s[2], exponent), powf(sseReg.s[3], exponent));
}
// https://codingforspeed.com/using-faster-exponential-approximation/
inline __m128 FastExpSSEVector(__m128 x)
{
#ifdef USE_FAST_EXP
/*
x = Mad(x, _mm_set_ps1(1.f / 1024.f), _mm_set_ps1(1.0));
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
*/
x = Mad(x, _mm_set_ps1(1.f / 256.f), _mm_set_ps1(1.0));
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
x = _mm_mul_ps(x, x);
return x;
#else
const SSERegister &src = (const SSERegister &)x;
SSERegister result;
result.s[0] = expf(src.s[0]);
result.s[1] = expf(src.s[1]);
result.s[2] = expf(src.s[2]);
result.s[3] = expf(src.s[3]);
return result.v;
#endif
}
inline __m128 Abs(__m128 x)
{
static const __m128 signMask = _mm_set1_ps(-0.f); // -0.f = 1 << 31
return _mm_andnot_ps(signMask, x);
}
#endif // USe_SSE
#endif
| [
"nicovize@club-internet.fr"
] | nicovize@club-internet.fr |
fbb79e33dc0610cc30832a492f9b7fe192bfff58 | 5902fa0857cd4f722a9663bbd61aa0895b9f8dea | /BMIG-5101-SequencesAsBioInformation/Blast/ncbi-blast-2.10.0+-src/c++/include/algo/blast/api/seqsrc_multiseq.hpp | 472b03d5a44150f560572c2dbd55f8f134b9c26e | [] | no_license | thegrapesofwrath/spring-2020 | 1b38d45fa44fcdc78dcecfb3b221107b97ceff9c | f90fcde64d83c04e55f9b421d20f274427cbe1c8 | refs/heads/main | 2023-01-23T13:35:05.394076 | 2020-12-08T21:40:42 | 2020-12-08T21:40:42 | 319,763,280 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 129 | hpp | version https://git-lfs.github.com/spec/v1
oid sha256:24d638c804422568942592636a0af0165819ff2c9e2ba82fbe41ff7c714a7221
size 2226
| [
"shawn-hartley@sbcglobal.net"
] | shawn-hartley@sbcglobal.net |
f55e02257c62cf818fcb9d60c6b04868563355b1 | 4fae3414cd7bc66a9f9ab80664390d397dee0214 | /Arduino/EHealth/Bluetooth.h | a008559bd6b256133f858b10d07159815977cef2 | [] | no_license | eHealth2015/old2014project | 810dd94db53d09ca94b7a9bcec22f7dc163af2c4 | d005fed8ea81ea55f5d5372a288a498b56a7c845 | refs/heads/master | 2016-08-11T09:12:50.686558 | 2015-10-25T11:19:30 | 2015-10-25T11:19:30 | 44,546,501 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 476 | h | #ifndef BLUETOOTH_H
#define BLUETOOTH_H
#include "Memory.h"
#define SNUMBER "00112233445566778899AABBCCDDEEFF"
#define FIRMWARE "0.1a"
#if ARDUINO < 100
#include <WProgram.h>
#else
#include <Arduino.h>
#endif
class Bluetooth{
private:
String trame;
Memory* mem;
public:
Bluetooth();
Bluetooth(Memory* _mem);
void setup();
int read();
int process();
void hello();
void sync();
void data();
void error();
};
#endif
| [
"gatux94@gmail.com"
] | gatux94@gmail.com |
09ae99d15da169f0d066a31811e60df0946fcf04 | 2e91f04e516e9f719784786e0229f39fc843fa45 | /toki-open-2018-group/solution-4.cpp | 0df6efb8d85e63d45eeae2753fbdae713f88b934 | [] | no_license | jonathanirvings/toki-open-2018 | e38362102b5dee2db047a77a97667027687fb969 | b0e05719d3ecdf2ed142cce18e25aaed3f514a4e | refs/heads/master | 2020-03-18T20:03:34.050550 | 2018-06-02T12:32:58 | 2018-06-02T12:32:58 | 135,193,425 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 310 | cpp | #include "group.h"
#include <bits/stdc++.h>
using namespace std;
int getMinimumDelay(int N, vector<int> X, vector<int> Y) {
if (N <= 2) return 0;
int ans = 2000000000;
sort(Y.begin(), Y.end());
for (int i = 0; i < N - 1; i++) {
ans = min(ans, max(Y[i] - Y[0], Y[N - 1] - Y[i + 1]));
}
return ans;
}
| [
"jonathan.irvin@yahoo.com"
] | jonathan.irvin@yahoo.com |
28a074b26ca2518e154044b76dd3f64debb30306 | 98054c0fc0415cd7d7733ed63c69d1d25547b338 | /src/WalletLegacy/WalletLegacy.h | 1ed7316071d68b4515e5e6671a5051c4858fef22 | [
"MIT"
] | permissive | freelacoin/freelabit | 18dc3f23f0671cb73d1df8a22baca43305549eae | f5a2fa5b9258e5e5688d3281e45503f14e0cb914 | refs/heads/freelabit | 2021-12-11T08:33:30.992223 | 2021-08-31T16:42:48 | 2021-08-31T16:42:48 | 102,800,887 | 3 | 6 | MIT | 2018-05-12T04:02:35 | 2017-09-08T01:01:08 | C++ | UTF-8 | C++ | false | false | 7,186 | h | // Copyright (c) 2011-2017 The Cryptonote developers
// Copyright (c) 2014-2017 XDN developers
// Copyright (c) 2016-2017 BXC developers
// Copyright (c) 2017 Royalties developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#pragma once
#include <list>
#include <vector>
#include <unordered_map>
#include <memory>
#include <mutex>
#include "IWalletLegacy.h"
#include "INode.h"
#include "Wallet/WalletErrors.h"
#include "Wallet/WalletAsyncContextCounter.h"
#include "Common/ObserverManager.h"
#include "CryptoNoteCore/TransactionExtra.h"
#include "CryptoNoteCore/CryptoNoteFormatUtils.h"
#include "CryptoNoteCore/Currency.h"
#include "WalletLegacy/WalletUserTransactionsCache.h"
#include "WalletLegacy/WalletUnconfirmedTransactions.h"
#include "WalletLegacy/WalletTransactionSender.h"
#include "WalletLegacy/WalletRequest.h"
#include "Transfers/BlockchainSynchronizer.h"
#include "Transfers/TransfersSynchronizer.h"
namespace CryptoNote {
class SyncStarter;
class WalletLegacy :
public IWalletLegacy,
IBlockchainSynchronizerObserver,
ITransfersObserver {
public:
WalletLegacy(const CryptoNote::Currency& currency, INode& node);
virtual ~WalletLegacy();
virtual void addObserver(IWalletLegacyObserver* observer) override;
virtual void removeObserver(IWalletLegacyObserver* observer) override;
virtual void initAndGenerate(const std::string& password) override;
virtual void initAndLoad(std::istream& source, const std::string& password) override;
virtual void initWithKeys(const AccountKeys& accountKeys, const std::string& password) override;
virtual void shutdown() override;
virtual void reset() override;
virtual void save(std::ostream& destination, bool saveDetailed = true, bool saveCache = true) override;
virtual std::error_code changePassword(const std::string& oldPassword, const std::string& newPassword) override;
virtual std::string getAddress() override;
virtual uint64_t actualBalance() override;
virtual uint64_t pendingBalance() override;
virtual uint64_t actualDepositBalance() override;
virtual uint64_t pendingDepositBalance() override;
virtual size_t getTransactionCount() override;
virtual size_t getTransferCount() override;
virtual size_t getDepositCount() override;
virtual TransactionId findTransactionByTransferId(TransferId transferId) override;
virtual bool getTransaction(TransactionId transactionId, WalletLegacyTransaction& transaction) override;
virtual bool getTransfer(TransferId transferId, WalletLegacyTransfer& transfer) override;
virtual bool getDeposit(DepositId depositId, Deposit& deposit) override;
virtual std::vector<Payments> getTransactionsByPaymentIds(const std::vector<PaymentId>& paymentIds) const override;
virtual TransactionId sendTransaction(const WalletLegacyTransfer& transfer,
uint64_t fee,
const std::string& extra = "",
uint64_t mixIn = 0,
uint64_t unlockTimestamp = 0,
const std::vector<TransactionMessage>& messages = std::vector<TransactionMessage>(),
uint64_t ttl = 0) override;
virtual TransactionId sendTransaction(const std::vector<WalletLegacyTransfer>& transfers,
uint64_t fee,
const std::string& extra = "",
uint64_t mixIn = 0,
uint64_t unlockTimestamp = 0,
const std::vector<TransactionMessage>& messages = std::vector<TransactionMessage>(),
uint64_t ttl = 0) override;
virtual TransactionId deposit(uint32_t term, uint64_t amount, uint64_t fee, uint64_t mixIn = 0) override;
virtual TransactionId withdrawDeposits(const std::vector<DepositId>& depositIds, uint64_t fee) override;
virtual std::error_code cancelTransaction(size_t transactionId) override;
virtual void getAccountKeys(AccountKeys& keys) override;
private:
// IBlockchainSynchronizerObserver
virtual void synchronizationProgressUpdated(uint32_t current, uint32_t total) override;
virtual void synchronizationCompleted(std::error_code result) override;
// ITransfersObserver
virtual void onTransactionUpdated(ITransfersSubscription* object, const Crypto::Hash& transactionHash) override;
virtual void onTransactionDeleted(ITransfersSubscription* object, const Crypto::Hash& transactionHash) override;
virtual void onTransfersUnlocked(ITransfersSubscription* object, const std::vector<TransactionOutputInformation>& unlockedTransfers) override;
virtual void onTransfersLocked(ITransfersSubscription* object, const std::vector<TransactionOutputInformation>& lockedTransfers) override;
void initSync();
void throwIfNotInitialised();
void doSave(std::ostream& destination, bool saveDetailed, bool saveCache);
void doLoad(std::istream& source);
void synchronizationCallback(WalletRequest::Callback callback, std::error_code ec);
void sendTransactionCallback(WalletRequest::Callback callback, std::error_code ec);
void notifyClients(std::deque<std::unique_ptr<WalletLegacyEvent> >& events);
void notifyIfBalanceChanged();
void notifyIfDepositBalanceChanged();
std::unique_ptr<WalletLegacyEvent> getActualDepositBalanceChangedEvent();
std::unique_ptr<WalletLegacyEvent> getPendingDepositBalanceChangedEvent();
std::unique_ptr<WalletLegacyEvent> getActualBalanceChangedEvent();
std::unique_ptr<WalletLegacyEvent> getPendingBalanceChangedEvent();
uint64_t calculateActualDepositBalance();
uint64_t calculatePendingDepositBalance();
uint64_t calculateActualBalance();
uint64_t calculatePendingBalance();
void pushBalanceUpdatedEvents(std::deque<std::unique_ptr<WalletLegacyEvent>>& eventsQueue);
std::vector<TransactionId> deleteOutdatedUnconfirmedTransactions();
std::vector<uint32_t> getTransactionHeights(std::vector<TransactionOutputInformation> transfers);
enum WalletState
{
NOT_INITIALIZED = 0,
INITIALIZED,
LOADING,
SAVING
};
WalletState m_state;
std::mutex m_cacheMutex;
CryptoNote::AccountBase m_account;
std::string m_password;
const CryptoNote::Currency& m_currency;
INode& m_node;
bool m_isStopping;
std::atomic<uint64_t> m_lastNotifiedActualBalance;
std::atomic<uint64_t> m_lastNotifiedPendingBalance;
std::atomic<uint64_t> m_lastNotifiedActualDepositBalance;
std::atomic<uint64_t> m_lastNotifiedPendingDepositBalance;
BlockchainSynchronizer m_blockchainSync;
TransfersSyncronizer m_transfersSync;
ITransfersContainer* m_transferDetails;
WalletUserTransactionsCache m_transactionsCache;
std::unique_ptr<WalletTransactionSender> m_sender;
WalletAsyncContextCounter m_asyncContextCounter;
Tools::ObserverManager<CryptoNote::IWalletLegacyObserver> m_observerManager;
std::unique_ptr<SyncStarter> m_onInitSyncStarter;
};
} //namespace CryptoNote
| [
"ericvesprini@yahoo.com"
] | ericvesprini@yahoo.com |
325eb1b473a82bd0ff33a605de0a0794cf4cc7d6 | e9c02bb0df7ad3a928cf7c97b8294451eaa8dbc8 | /graph-source-code/527-E/10336560.cpp | ee3e31649454f47bc4692bf66a01ed59e970ee93 | [
"MIT"
] | permissive | AmrARaouf/algorithm-detection | b157a534545fa8920bbe94e7307d4b937a74aa60 | 59f3028d2298804870b32729415d71eec6116557 | refs/heads/master | 2021-01-13T14:37:04.074339 | 2015-12-06T21:14:31 | 2015-12-06T21:14:31 | 45,905,817 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,378 | cpp | //Language: GNU C++
#include <iostream>
#include <vector>
#include <fstream>
#include <set>
using namespace std;
const int N = 1e5 + 5;
multiset<int> g[N];
int cv[N];
vector<int> euler;
void dfs(int v) {
while(!g[v].empty()) {
int to = *g[v].begin();
g[v].erase(g[v].begin());
if (to != v)
g[to].erase(g[to].find(v));
dfs(to);
}
euler.push_back(v);
}
int main() {
#ifdef CONTEMPLATOR
ifstream cin("input.txt");
ofstream cout("output.txt");
#endif // CONTEMPLATOR
ios_base::sync_with_stdio(false);
int n, m;
cin >> n >> m;
for (int i = 0; i < m; i++) {
int a, b;
cin >> a >> b;
g[a].insert(b);
if (a != b)
g[b].insert(a);
cv[a]++, cv[b]++;
}
vector<int> bad;
for (int i = 0; i < N; i++)
if (cv[i] & 1)
bad.push_back(i);
for (size_t i = 0; i < bad.size(); i += 2) {
m++;
g[bad[i]].insert(bad[i+1]);
g[bad[i+1]].insert(bad[i]);
}
if (m & 1) {
m++;
g[1].insert(1);
}
dfs(1);
cout << m << endl;
for (int i = 0; i < m; i++) {
int a = euler[i];
int b = euler[i+1];
if (i & 1) swap(a, b);
cout << a << " " << b << "\n";
}
return 0;
}
| [
"amr.abdelraouf93@gmail.com"
] | amr.abdelraouf93@gmail.com |
aef7717855119d20c7072964937c44a608d2fd79 | ad594d3d1cc6fe4c34b596d9564a7b1bf54a2f7a | /139.cpp | 9e36fcf8a427fee6af7cee9807de51de67eec570 | [] | no_license | colinlee1999/leetcode | 16199151de09073754e2d209af170fd3b489bb21 | 5ada773459ca45a942113a96581550a1b1af9987 | refs/heads/master | 2020-05-21T23:13:27.766217 | 2017-08-23T06:07:28 | 2017-08-23T06:07:28 | 61,930,482 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 608 | cpp | #include "iostream"
#include "vector"
#include "set"
#include "map"
#define INT_MIN (1<<31)
#define INT_MAX (~INT_MIN)
using namespace std;
class Solution {
public:
bool wordBreak(string s, unordered_set<string>& wordDict) {
unordered_set<int> true_pos;
true_pos.insert(0);
int longest = 0;
for (int i = 0; i < s.length(); i++)
{
for (auto it : true_pos)
if (wordDict.count(s.substr(it, i - it + 1)))
{
longest = i + 1;
break;
}
if (longest == i+1)
true_pos.insert(i + 1);
}
return (longest == s.length());
}
};
int main()
{
Solution s;
cin.get();
}
| [
"arteest@foxmail.com"
] | arteest@foxmail.com |
d4e472c9ecce2049e00a54f4d95dde8de679e13b | 0e88892ac677c180d6aa9bb5665729a609d3a170 | /src/core/math/math_types.h | 3090c7b6e76267925b24852d18f992325569601e | [
"MIT"
] | permissive | UIKit0/crown | 630720672389903140392db772b70e1dd9f3c998 | 11e8631a0a80830695ba3594a952a2d0ac278d54 | refs/heads/master | 2020-12-03T03:34:41.998651 | 2015-12-12T13:54:29 | 2015-12-12T13:54:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,285 | h | /*
* Copyright (c) 2012-2015 Daniele Bartolini and individual contributors.
* License: https://github.com/taylor001/crown/blob/master/LICENSE
*/
#pragma once
#include "types.h"
namespace crown
{
/// @defgroup Math Math
/// @ingroup Math
struct Vector2
{
float x, y;
};
/// @ingroup Math
struct Vector3
{
float x, y, z;
};
/// @ingroup Math
struct Vector4
{
float x, y, z, w;
};
/// Holds RGBA color as four floats.
typedef Vector4 Color4;
/// @ingroup Math
struct Quaternion
{
float x, y, z, w;
};
/// @ingroup Math
struct Matrix3x3
{
Vector3 x, y, z;
};
/// @ingroup Math
struct Matrix4x4
{
Vector4 x, y, z, t;
};
/// @ingroup Math
struct AABB
{
Vector3 min;
Vector3 max;
};
/// @ingroup Math
struct OBB
{
Matrix4x4 tm;
AABB aabb;
};
/// 3D Plane.
/// The form is ax + by + cz + d = 0
/// where: d = -vector3::dot(n, p)
///
/// @ingroup Math
struct Plane
{
Vector3 n;
float d;
};
/// @ingroup Math
struct Frustum
{
Plane left;
Plane right;
Plane bottom;
Plane top;
Plane near;
Plane far;
};
/// @ingroup Math
struct Sphere
{
Vector3 c;
float r;
};
const Vector2 VECTOR2_ZERO = { 0.0f, 0.0f };
const Vector3 VECTOR3_ZERO = { 0.0f, 0.0f, 0.0f };
const Vector3 VECTOR3_XAXIS = { 1.0f, 0.0f, 0.0f };
const Vector3 VECTOR3_YAXIS = { 0.0f, 1.0f, 0.0f };
const Vector3 VECTOR3_ZAXIS = { 0.0f, 0.0f, 1.0f };
const Vector3 VECTOR3_FORWARD = { 0.0f, 0.0f, 1.0f };
const Vector3 VECTOR3_BACKWARD = { 0.0f, 0.0f, -1.0f };
const Vector3 VECTOR3_LEFT = { -1.0f, 0.0f, 0.0f };
const Vector3 VECTOR3_RIGHT = { 1.0f, 0.0f, 0.0f };
const Vector3 VECTOR3_UP = { 0.0f, 1.0f, 0.0f };
const Vector3 VECTOR3_DOWN = { 0.0f, -1.0f, 0.0f };
const Vector4 VECTOR4_ZERO = { 0.0f, 0.0f, 0.0f, 0.0f };
const Vector4 VECTOR4_XAXIS = { 1.0f, 0.0f, 0.0f, 0.0f };
const Vector4 VECTOR4_YAXIS = { 0.0f, 1.0f, 0.0f, 0.0f };
const Vector4 VECTOR4_ZAXIS = { 0.0f, 0.0f, 1.0f, 0.0f };
const Vector4 VECTOR4_WAXIS = { 0.0f, 0.0f, 0.0f, 1.0f };
const Quaternion QUATERNION_IDENTITY = { 0.0f, 0.0f, 0.0f, 1.0f };
const Matrix3x3 MATRIX3X3_IDENTITY = { VECTOR3_XAXIS, VECTOR3_YAXIS, VECTOR3_ZAXIS };
const Matrix4x4 MATRIX4X4_IDENTITY = { VECTOR4_XAXIS, VECTOR4_YAXIS, VECTOR4_ZAXIS, VECTOR4_WAXIS };
} // namespace crown
| [
"danyatk@gmail.com"
] | danyatk@gmail.com |
b5c9c12d65816d1d627af291943928c061a85372 | 0d553b926bd876f255d7b2ec29d179f98022e04a | /main.cpp | 8127926ddd17df72d9b72f2c41bed20bd774d030 | [] | no_license | Karol03/SnakeANN | 1ed399b873ca0946d84aacaf5443b699cf33f1a3 | 9cad22c4f20a8a2f448a419214c1baef7da3c71b | refs/heads/master | 2020-05-20T09:00:35.545821 | 2019-05-19T10:58:05 | 2019-05-19T10:58:05 | 185,488,988 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 348 | cpp | #include <QCoreApplication>
#include "Engine/game.hpp"
#include "utilities/generator.hpp"
#include "utilities/logger.hpp"
using namespace std;
int main(int argc, char *argv[])
{
logger::Logging log(logger::Logging::Info);
QCoreApplication a(argc, argv);
Generator::initialize();
Game game;
game.run();
return a.exec();
}
| [
"karol_dudzic_03@wp.pl"
] | karol_dudzic_03@wp.pl |
174a4dce8776e85798fbabb8c8121371cd7418a2 | cabe040f3d980106401ca8f02051705fa954d4b4 | /Student.h | 9b6f953bff64dd275757509e96c65a6a7e5d9edc | [] | no_license | aedelgado19/CS162-LinkedLists2 | d0b9cb926c766181cc907758b9d84b5252030c5c | 8d32d9c9926a3169a94d97c3a71e0890d1ee97cf | refs/heads/master | 2023-01-06T13:53:57.026072 | 2020-11-11T04:36:11 | 2020-11-11T04:36:11 | 310,903,845 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 412 | h | //Author: Allison Delgado
#include <iostream>
class Student{
public:
Student* getStudent();
void setFirstName(char* inputName);
char* getFirstName();
void setLastName(char* inputName);
char* getLastName();
void setID(int inputID);
int getID();
void setGPA(float inputGPA);
float getGPA();
Student();
~Student();
private:
char fName[50];
char lName[50];
int id;
float gpa;
};
| [
"aedelgado19@gmail.com"
] | aedelgado19@gmail.com |
bb0990eaf13d48d4d96b2b8b7e9ac59c3941ed9a | 2ccbd5ca4588d5edee12d5ac5d1044927c797b49 | /ccc15s3.cpp | b48d765bbdcb76dcd49fe8febf5a254bb958231d | [] | no_license | 2ee2ee2ee/Competitive_Programming | 9c1ab1da209b000ab27bf908f8b38d80e0ac9c31 | cf7558f62fb2fa1dc5ad21727ecdbba63a3224c0 | refs/heads/master | 2023-03-11T20:31:49.234470 | 2021-02-20T22:13:29 | 2021-02-20T22:13:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 419 | cpp | #include <bits/stdc++.h>
using namespace std;
set<int> os;
set<int>::iterator it;
int main() {
cin.sync_with_stdio(0);
cin.tie(0);
int G,P;
cin >> G >> P;
for (int i = 1; i <= G; i++) os.insert(i);
for (int i = 1,x; i <= P; i++) {
cin >> x;
it = os.lower_bound(x);
if (it == os.begin() && *it != x) {
cout << i-1 << "\n";
return 0;
}
if (*it != x) it--;
os.erase(it);
}
cout << P << "\n";
} | [
"38817928+sa35577@users.noreply.github.com"
] | 38817928+sa35577@users.noreply.github.com |
6263f1f733f034a7241802efdf8ad4e18947e26e | d8cb5ca60948919a441da933a01b5c8e84bb3a44 | /wxwidgets/wxWidgets-2.9.1/src/generic/notifmsgg.cpp | fc377f6db833e37d0fcee15315968d4142cc710e | [] | no_license | sonyomega/wxWidgets | 6d028af7097b87944aa41ab1331303ae7acf3ce1 | da8de1d8b0259d4fa4c958b1ff6a33c25728c503 | refs/heads/master | 2020-09-12T22:15:44.006866 | 2011-06-22T21:47:42 | 2011-06-22T21:47:42 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,452 | cpp | ///////////////////////////////////////////////////////////////////////////////
// Name: src/generic/notifmsgg.cpp
// Purpose: generic implementation of wxGenericNotificationMessage
// Author: Vadim Zeitlin
// Created: 2007-11-24
// RCS-ID: $Id$
// Copyright: (c) 2007 Vadim Zeitlin <vadim@wxwindows.org>
// Licence: wxWindows licence
///////////////////////////////////////////////////////////////////////////////
// ============================================================================
// declarations
// ============================================================================
// ----------------------------------------------------------------------------
// headers
// ----------------------------------------------------------------------------
// for compilers that support precompilation, includes "wx.h".
#include "wxprec.h"
#ifdef __BORLANDC__
#pragma hdrstop
#endif
#ifndef wxUSE_LIBHILDON
#define wxUSE_LIBHILDON 0
#endif
#ifndef wxUSE_LIBHILDON2
#define wxUSE_LIBHILDON2 0
#endif
#if wxUSE_NOTIFICATION_MESSAGE && (!wxUSE_LIBHILDON || !wxUSE_LIBHILDON2)
#ifndef WX_PRECOMP
#include "wx/dialog.h"
#include "wx/timer.h"
#include "wx/sizer.h"
#include "wx/statbmp.h"
#endif //WX_PRECOMP
#include "wx/artprov.h"
// even if the platform has the native implementation, we still normally want
// to use the generic one (unless it's totally unsuitable for the target UI as
// is the case of Hildon) because it may provide more features, so include
// wx/generic/notifmsg.h to get wxGenericNotificationMessage declaration even
// if wx/notifmsg.h only declares wxNotificationMessage itself (if it already
// uses the generic version, the second inclusion will do no harm)
#include "wx/notifmsg.h"
#include "wx/generic/notifmsg.h"
// ----------------------------------------------------------------------------
// wxNotificationMessageDialog
// ----------------------------------------------------------------------------
class wxNotificationMessageDialog : public wxDialog
{
public:
wxNotificationMessageDialog(wxWindow *parent,
const wxString& text,
int timeout,
int flags);
void Set(wxWindow *parent,
const wxString& text,
int timeout,
int flags);
bool IsAutomatic() const { return m_timer.IsRunning(); }
void SetDeleteOnHide() { m_deleteOnHide = true; }
private:
void OnClose(wxCloseEvent& event);
void OnTimer(wxTimerEvent& event);
// if true, delete the dialog when it should disappear, otherwise just hide
// it (initially false)
bool m_deleteOnHide;
// timer which will hide this dialog when it expires, if it's not running
// it means we were created without timeout
wxTimer m_timer;
DECLARE_EVENT_TABLE()
wxDECLARE_NO_COPY_CLASS(wxNotificationMessageDialog);
};
// ============================================================================
// wxNotificationMessageDialog implementation
// ============================================================================
BEGIN_EVENT_TABLE(wxNotificationMessageDialog, wxDialog)
EVT_CLOSE(wxNotificationMessageDialog::OnClose)
EVT_TIMER(wxID_ANY, wxNotificationMessageDialog::OnTimer)
END_EVENT_TABLE()
wxNotificationMessageDialog::wxNotificationMessageDialog(wxWindow *parent,
const wxString& text,
int timeout,
int flags)
: wxDialog(parent, wxID_ANY, _("Notice"),
wxDefaultPosition, wxDefaultSize,
0 /* no caption, no border styles */),
m_timer(this)
{
m_deleteOnHide = false;
Set(parent, text, timeout, flags);
}
void
wxNotificationMessageDialog::Set(wxWindow * WXUNUSED(parent),
const wxString& text,
int timeout,
int flags)
{
wxSizer * const sizerTop = new wxBoxSizer(wxHORIZONTAL);
if ( flags & wxICON_MASK )
{
sizerTop->Add(new wxStaticBitmap
(
this,
wxID_ANY,
wxArtProvider::GetMessageBoxIcon(flags)
),
wxSizerFlags().Centre().Border());
}
sizerTop->Add(CreateTextSizer(text), wxSizerFlags(1).Border());
SetSizerAndFit(sizerTop);
if ( timeout != wxGenericNotificationMessage::Timeout_Never )
{
// wxTimer uses ms, timeout is in seconds
m_timer.Start(timeout*1000, true /* one shot only */);
}
else if ( m_timer.IsRunning() )
{
m_timer.Stop();
}
}
void wxNotificationMessageDialog::OnClose(wxCloseEvent& event)
{
if ( m_deleteOnHide )
{
// we don't need to keep this dialog alive any more
Destroy();
}
else // don't really close, just hide, as we can be shown again later
{
event.Veto();
Hide();
}
}
void wxNotificationMessageDialog::OnTimer(wxTimerEvent& WXUNUSED(event))
{
if ( m_deleteOnHide )
Destroy();
else
Hide();
}
// ============================================================================
// wxGenericNotificationMessage implementation
// ============================================================================
int wxGenericNotificationMessage::ms_timeout = 10;
/* static */ void wxGenericNotificationMessage::SetDefaultTimeout(int timeout)
{
wxASSERT_MSG( timeout > 0,
"negative or zero default timeout doesn't make sense" );
ms_timeout = timeout;
}
void wxGenericNotificationMessage::Init()
{
m_dialog = NULL;
}
wxGenericNotificationMessage::~wxGenericNotificationMessage()
{
if ( m_dialog->IsAutomatic() )
{
// we want to allow the user to create an automatically hidden
// notification just by creating a local wxGenericNotificationMessage object
// and so we shouldn't hide the notification when this object goes out
// of scope
m_dialog->SetDeleteOnHide();
}
else // manual dialog, hide it immediately
{
// OTOH for permanently shown dialogs only the code can hide them and
// if the object is deleted, we must do it now as it won't be
// accessible programmatically any more
delete m_dialog;
}
}
bool wxGenericNotificationMessage::Show(int timeout)
{
if ( timeout == Timeout_Auto )
{
timeout = GetDefaultTimeout();
}
if ( !m_dialog )
{
m_dialog = new wxNotificationMessageDialog
(
GetParent(),
GetFullMessage(),
timeout,
GetFlags()
);
}
else // update the existing dialog
{
m_dialog->Set(GetParent(), GetFullMessage(), timeout, GetFlags());
}
m_dialog->Show();
return true;
}
bool wxGenericNotificationMessage::Close()
{
if ( !m_dialog )
return false;
m_dialog->Hide();
return true;
}
#endif // wxUSE_NOTIFICATION_MESSAGE && (!wxUSE_LIBHILDON || !wxUSE_LIBHILDON2)
| [
"erwin.coumans@gmail.com"
] | erwin.coumans@gmail.com |
b393cd1a19226ed45a671c5bdd7c5fd5043eb219 | d2e68e00be2ef67e29cb4d3a9c8478bef7cfd99c | /src/ast/sweep_down_node.h | 6a8ac762da9928a9852d691af7305ce5a3e785d0 | [] | no_license | ist181045/com1617-xpl | ca3af5869e51b5eda172874ee34cd383953b7665 | b4dd6594e82d9e6f8198ae38577b86bb22087ef4 | refs/heads/master | 2021-03-27T13:53:26.926042 | 2018-09-23T20:35:18 | 2018-09-23T20:35:18 | 80,261,968 | 1 | 4 | null | null | null | null | UTF-8 | C++ | false | false | 1,389 | h | #ifndef __XPL_SWEEPDOWNNODE_H__
#define __XPL_SWEEPDOWNNODE_H__
#include <cdk/ast/basic_node.h>
#include <cdk/ast/expression_node.h>
#include <cdk/ast/integer_node.h>
#include <cdk/ast/lvalue_node.h>
namespace xpl {
class sweep_down_node: public cdk::basic_node {
cdk::lvalue_node *_lvalue;
cdk::expression_node *_initial;
cdk::expression_node *_lower;
cdk::expression_node *_step;
cdk::basic_node *_block;
public:
inline sweep_down_node(int lineno, cdk::lvalue_node *lvalue,
cdk::expression_node *initial, cdk::expression_node *lower,
cdk::basic_node *block, cdk::expression_node *step = nullptr)
: cdk::basic_node(lineno), _lvalue(lvalue), _initial(initial),
_lower(lower), _step(step), _block(block) {
if (step == nullptr) _step = new cdk::integer_node(lineno, 1);
}
~sweep_down_node() {
if (_step) delete _step;
}
public:
inline cdk::lvalue_node *lvalue() {
return _lvalue;
}
inline cdk::expression_node *initial() {
return _initial;
}
inline cdk::expression_node *lower() {
return _lower;
}
inline cdk::expression_node *step() {
return _step;
}
inline cdk::basic_node *block() {
return _block;
}
void accept(basic_ast_visitor *sp, int level) {
sp->do_sweep_down_node(this, level);
}
};
} // xpl
#endif
| [
"rui.ventura@tecnico.ulisboa.pt"
] | rui.ventura@tecnico.ulisboa.pt |
0c659d8abcb201f21a339f0c8160ce738692da6a | b81e786d614f6593b948d5e39eea64d1a82f3f97 | /solutions/261.graph-valid-tree.276785020.ac.cpp | 84f94261548a3e15d3859165ef42570a12b66185 | [
"MIT"
] | permissive | Jiltseb/Leetcode-Solutions | 67350b2b12c4e49ac7f6d46a14a3170b66acac20 | 2edff60d76c2898d912197044f6284efeeb34119 | refs/heads/main | 2022-12-30T22:14:11.666308 | 2020-10-23T15:25:35 | 2020-10-23T15:25:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 751 | cpp | struct DSU {
int n;
int setCount;
vector<int> parent;
vector<int> size;
DSU(int n) : n(n), size(n, 1), parent(n), setCount(n) {
for (int i = 0; i < n; i++)
parent[i] = i;
}
int getSet(int i) {
if (parent[i] == i)
return i;
return parent[i] = getSet(parent[i]);
}
bool join(int i, int j) {
i = getSet(i);
j = getSet(j);
if (i == j)
return false;
setCount--;
if (size[i] < size[j])
swap(i, j);
parent[j] = i;
size[i] += size[j];
return true;
}
};
class Solution {
public:
bool validTree(int n, vector<vector<int>> &edges) {
DSU dsu(n);
for (auto e : edges)
if (!dsu.join(e[0], e[1]))
return false;
return dsu.setCount == 1;
}
};
| [
"satviksr@gmail.com"
] | satviksr@gmail.com |
9f234b5198d6a23ac3a1c0877d168d164bd596f5 | 178b73c122021e4d53303505f675cadb3ad3803c | /GridRead.cpp | 98cd6815039205946541ed12f9580c6ec043f7d1 | [] | no_license | cejutue/MeteMapping | 0da6a9f06d56cd5ae96fe7437ffc6014d25461b7 | 29a30d0c4ec3c7504ceb0f49a73b3d4efd90851e | refs/heads/master | 2022-07-30T10:38:17.292802 | 2022-07-09T02:54:11 | 2022-07-09T02:54:11 | 211,217,788 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 559 | cpp | #include "stdafx.h"
#include "GridRead.h"
GridRead::GridRead()
{
}
GridRead::~GridRead()
{
delete m_Databuff;
}
bool GridRead::Read(const char * InPath)
{
FILE *fin_bin = fopen(InPath, "rb");
int rc = 0;
struct stat s;
stat(InPath, &s);
m_Databuff = new float[s.st_size / sizeof(float)];
m_buffSize = s.st_size / sizeof(float);
memset(m_Databuff, sizeof(float), m_buffSize);
if ((rc = fread(m_Databuff, sizeof(float), m_buffSize, fin_bin)) == 0)
{
fclose(fin_bin);
return false;
}
fclose(fin_bin);
return true;
}
| [
"373580574@qq.com"
] | 373580574@qq.com |
a639e729e7bc0e709e388bb5745f4be9f8041ab2 | 5041bdc8ce649616b6dcf32aeade9ae27075ae2b | /remoting/host/daemon_process.cc | d0ccd0cd05656acba7bba44a4415121b7b841cbe | [
"BSD-3-Clause"
] | permissive | aSeijiNagai/Readium-Chromium | a15a1ea421c797fab6e0876785f9ce4afb784e60 | 404328b0541dd3da835b288785aed080f73d85dd | refs/heads/master | 2021-01-16T22:00:32.748245 | 2012-09-24T07:57:13 | 2012-09-24T07:57:13 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,708 | cc | // Copyright (c) 2012 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 "remoting/host/daemon_process.h"
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/single_thread_task_runner.h"
#include "base/threading/thread.h"
namespace {
const char kIpcThreadName[] = "Daemon process IPC";
} // namespace
namespace remoting {
DaemonProcess::~DaemonProcess() {
}
bool DaemonProcess::OnMessageReceived(const IPC::Message& message) {
return true;
}
DaemonProcess::DaemonProcess(
scoped_refptr<base::SingleThreadTaskRunner> main_task_runner,
const base::Closure& stopped_callback)
: Stoppable(main_task_runner, stopped_callback),
main_task_runner_(main_task_runner) {
// Initialize on the same thread that will be used for shutting down.
main_task_runner_->PostTask(
FROM_HERE,
base::Bind(&DaemonProcess::Init, base::Unretained(this)));
}
void DaemonProcess::Init() {
DCHECK(main_task_runner_->BelongsToCurrentThread());
// Launch the IPC thread.
ipc_thread_.reset(new base::Thread(kIpcThreadName));
base::Thread::Options io_thread_options(MessageLoop::TYPE_IO, 0);
if (!ipc_thread_->StartWithOptions(io_thread_options)) {
LOG(ERROR) << "Failed to start the Daemon process IPC thread.";
Stop();
return;
}
if (!LaunchNetworkProcess()) {
LOG(ERROR) << "Failed to launch the networking process.";
Stop();
return;
}
}
void DaemonProcess::DoStop() {
DCHECK(main_task_runner_->BelongsToCurrentThread());
if (ipc_thread_.get()) {
ipc_thread_->Stop();
}
CompleteStopping();
}
} // namespace remoting
| [
"kerz@chromium.org@4ff67af0-8c30-449e-8e8b-ad334ec8d88c"
] | kerz@chromium.org@4ff67af0-8c30-449e-8e8b-ad334ec8d88c |
3698e0e7064c30b5a9aba42b1864dfb545ba5383 | e7c68e4b8053329afd867fb37dd48242f12fd8ba | /VerdiMain/src/VerdiPrerequisites.cpp | 69ac987f908118bd38f30dc97fcd596125b355a2 | [] | no_license | xwize/Verdi | a233274b3c0aceb3f2076f04451c67f8ea470c27 | 2b86321e02b76f992fc232939e5b41eb91c77aac | refs/heads/master | 2023-04-20T16:59:03.887959 | 2021-05-10T11:33:23 | 2021-05-10T11:33:23 | 365,752,607 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 938 | cpp |
#include "VerdiPrerequisites.h"
// We also need GL, GLU and GLee.
#include <GLee.h>
namespace Verdi {
void _glAssert(const char* szMessage, const char* szFile, int iLine)
{
static int iPrevLine = -1;
static std::string strPrevFile = "";
GLenum error = glGetError();
if(error != GL_NO_ERROR)
{
std::string strErrorString = "";
switch(error)
{
case GL_INVALID_ENUM :
strErrorString = "GL_INVALID_ENUM"; break;
case GL_INVALID_VALUE :
strErrorString = "GL_INVALID_VALUE"; break;
case GL_INVALID_OPERATION :
strErrorString = "GL_INVALID_OPERATION"; break;
default :
strErrorString = "UNKNOWN ERROR"; break;
};
std::cout << strErrorString << " @ " << szFile
<< ":" << iLine << " <- "
<< strPrevFile << ":" << iPrevLine << " | " << szMessage;
}
assert(error == GL_NO_ERROR);
iPrevLine = iLine;
strPrevFile = szFile;
}
} | [
"this.verb@gmail.com"
] | this.verb@gmail.com |
c6a1afd035bd7d300fe47595abc0403a0f85cc46 | 40278ddab2745877dc19500564c3617ff6f00f9f | /ImagingMedical/3D/RegSegmentation.cpp | d813284fe463a61e06959c08bea0c26a4ed590a4 | [] | no_license | AlexSou/BusinessStats | 17267f9f8dabf1a065b4775601e47e2ad4e718ac | 6efa61d3565920f12d5142233bc193b03fedbbdf | refs/heads/master | 2016-09-06T19:59:55.244946 | 2012-11-13T06:10:14 | 2012-11-13T06:10:14 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,724 | cpp | /*
* File: RegSegmentation.cpp
* Author: A Soulier
*
* Created on November 2009
*/
#include "RegSegmentation.h"
RegSegmentation::RegSegmentation() {
imageSet_ = false;
coordSet_ = false;
upperSet_ = false;
lowerSet_ = false;
imgReader_ = ImgReaderT::New();
imgWriter_ = ImgWriterT::New();
imgCastFilterIn_ = CastFilterInType::New();
imgCastFilterOut_ = CastFilterOutType::New();
imgCTIF_ = CTIFT::New();
}
void RegSegmentation::readImage(const char * file) {
//printf("%s", file);
imgReader_->SetFileName(file);
imgReader_->Update();
//typedef itk::MinimumMaximumImageCalculator<ImageProcT> imgCalc;
//imgCalc::Pointer calc = imgCalc::New();
imgCastFilterIn_->SetInput(imgReader_->GetOutput());
imgCastFilterIn_->Update();
imgCTIF_->SetInput(imgCastFilterIn_->GetOutput());
imgCTIF_->Update();
//calc->SetImage(imgCTIF_->GetOutput());
//calc->ComputeMaximum();
//const float max = calc->GetMaximum();
//PixelOutT outRepPixel = static_cast<PixelOutT>(max * 1.1);
//imgCTIF_->SetReplaceValue(outRepPixel);
imageSet_ = true;
}
void RegSegmentation::setCoords(int x, int y, int z ) {
IndexTypeSeed seed;
seed[0] = static_cast<IndexTypeSeed::IndexValueType>(x);
seed[1] = static_cast<IndexTypeSeed::IndexValueType>(y);
seed[2] = static_cast<IndexTypeSeed::IndexValueType>(z);
imgCTIF_->SetSeed(seed);
coordSet_ = true;
}
void RegSegmentation::setLower(PixelInT lowerPix) {
imgCTIF_->SetLower(static_cast<PixelInT> (lowerPix) );
lowerSet_ = true;
}
void RegSegmentation::setUpper(PixelInT upperPix) {
imgCTIF_->SetUpper(static_cast<PixelInT> (upperPix) );
upperSet_ = true;
}
void RegSegmentation::delCoords() {
imgCTIF_->ClearSeeds();
coordSet_ = false;
}
void RegSegmentation::writeImage(const char * file) {
if(imageSet_ && coordSet_ && upperSet_ && lowerSet_) {
//imgCTIF_->SetReplaceValue(255);
imgCTIF_->Update();
imgCastFilterOut_->SetInput(imgCTIF_->GetOutput());
imgCastFilterOut_->Update();
imgWriter_->SetInput(imgCastFilterOut_->GetOutput());
imgWriter_->SetFileName(file);
try
{
imgWriter_->Update();
}
catch( itk::ExceptionObject & excep )
{
std::cerr << "Exception when writing segmented image." << std::endl;
std::cerr << excep << std::endl;
exit(EXIT_FAILURE);
}
}
}
RegSegmentation::RegSegmentation(const RegSegmentation& orig) {
}
RegSegmentation::~RegSegmentation() {
}
| [
"alesouli@gmail.com"
] | alesouli@gmail.com |
9a114dd0c8ef1288d7ddd7e14dd2d4f38afa1851 | 04b1803adb6653ecb7cb827c4f4aa616afacf629 | /ui/events/event_sink.h | e31c1be2815c4c2c72f441814d5a1c6490794c73 | [
"BSD-3-Clause"
] | permissive | Samsung/Castanets | 240d9338e097b75b3f669604315b06f7cf129d64 | 4896f732fc747dfdcfcbac3d442f2d2d42df264a | refs/heads/castanets_76_dev | 2023-08-31T09:01:04.744346 | 2021-07-30T04:56:25 | 2021-08-11T05:45:21 | 125,484,161 | 58 | 49 | BSD-3-Clause | 2022-10-16T19:31:26 | 2018-03-16T08:07:37 | null | UTF-8 | C++ | false | false | 611 | h | // Copyright 2017 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 UI_EVENTS_EVENT_SINK_H_
#define UI_EVENTS_EVENT_SINK_H_
#include "ui/events/event_dispatcher.h"
namespace ui {
class Event;
// EventSink receives events from an EventSource.
class EVENTS_EXPORT EventSink {
public:
virtual ~EventSink() {}
// Receives events from EventSource.
virtual EventDispatchDetails OnEventFromSource(Event* event)
WARN_UNUSED_RESULT = 0;
};
} // namespace ui
#endif // UI_EVENTS_EVENT_SINK_H_
| [
"sunny.nam@samsung.com"
] | sunny.nam@samsung.com |
8d342f702d14aeb74df2c04d9042fe048b3ada21 | bd2f117637be64d13d7b94093c537d346ca3257f | /Examples/GUI/GUI_Layered/Sources/gui_3d.cpp | f35010ca04a5dd3af88b0f58fd914199f255db3f | [
"Zlib"
] | permissive | animehunter/clanlib-2.3 | e6d6a09ff58016809d687c101b64ed4da1467562 | 7013c39f4cd1f25b0dad3bedfdb7a5cf593b1bb7 | refs/heads/master | 2016-09-10T12:56:23.015390 | 2011-12-15T20:58:59 | 2011-12-15T20:58:59 | 3,001,221 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 18,268 | cpp | /*
** ClanLib SDK
** Copyright (c) 1997-2009 The ClanLib Team
**
** This software is provided 'as-is', without any express or implied
** warranty. In no event will the authors be held liable for any damages
** arising from the use of this software.
**
** Permission is granted to anyone to use this software for any purpose,
** including commercial applications, and to alter it and redistribute it
** freely, subject to the following restrictions:
**
** 1. The origin of this software must not be misrepresented; you must not
** claim that you wrote the original software. If you use this software
** in a product, an acknowledgment in the product documentation would be
** appreciated but is not required.
** 2. Altered source versions must be plainly marked as such, and must not be
** misrepresented as being the original software.
** 3. This notice may not be removed or altered from any source distribution.
**
** Note: Some of the libraries ClanLib may link to may have additional
** requirements or restrictions.
**
** File Author(s):
**
** Mark Page
*/
#include "precomp.h"
#include "gui_layered.h"
#include "GUI.h"
#include "app.h"
class LightSource
{
public:
LightSource()
{
}
CL_Vec4f m_Ambient;
CL_Vec4f m_Diffuse;
CL_Vec4f m_Specular;
CL_Vec4f m_Vector;
};
const char GUI_Texture_Shader_Vertex[] =
"#version 120\n"
"\n"
"attribute vec3 InPosition;"
"attribute vec3 InNormal;"
"attribute vec2 InTexCoord;"
"uniform mat4 cl_ModelViewMatrix;"
"uniform mat4 cl_ModelViewProjectionMatrix;"
"uniform mat3 cl_NormalMatrix;"
"\n"
"varying vec3 WorldSpaceNormal; \n"
"varying vec3 WorldSpacePosition; \n"
"varying vec4 ObjPos;\n"
"varying vec2 TexCoord;\n"
""
"void main()"
"{"
" vec4 in_position = vec4(InPosition.xyz, 1.0);\n"
" gl_Position = cl_ModelViewProjectionMatrix * in_position;\n"
" WorldSpaceNormal = normalize( cl_NormalMatrix * InNormal);\n"
" WorldSpacePosition = InPosition;\n"
" ObjPos = cl_ModelViewMatrix * in_position;\n"
" TexCoord = InTexCoord;"
"}"
;
const char GUI_Texture_Shader_Fragment[] =
"#version 120\n"
"\n"
"varying vec3 WorldSpaceNormal; \n"
"varying vec3 WorldSpacePosition; \n"
"varying vec4 ObjPos;\n"
"varying vec2 TexCoord;\n"
"\n"
"uniform sampler2D Texture0;\n"
"\n"
"uniform float MaterialShininess;\n"
"uniform vec4 MaterialEmission;\n"
"uniform vec4 MaterialSpecular;\n"
"uniform float MaterialTransparency;\n"
"\n"
"uniform vec4 LightVector;\n"
"uniform vec4 LightHalfVector;\n"
"uniform vec4 LightSpecular;\n"
"uniform vec4 LightDiffuse;\n"
"uniform vec4 LightAmbient;\n"
"\n"
"void main()\n"
"{\n"
" vec4 texture_color = texture2D(Texture0, TexCoord.xy);\n"
" if (texture_color.w < 0.01) discard;\n"
"\n"
" vec3 eye = -normalize(ObjPos.xyz); \n"
" vec4 diff = vec4(0); \n"
" vec4 spec = vec4(0); \n"
"\n"
" vec3 world_space_normal = normalize(WorldSpaceNormal);\n"
" float nDotL = max(0.0, dot(world_space_normal, LightVector.xyz)); \n"
" float pf; \n"
" if (nDotL == 0.0)\n"
" {\n"
" pf = 0.0; \n"
" }else\n"
" {\n"
" float nDotHV = max(0.0, dot(world_space_normal, LightHalfVector.xyz));\n"
" pf = pow(nDotHV, MaterialShininess);\n"
" }\n"
" spec += LightSpecular * pf; \n"
" diff += LightDiffuse * nDotL;\n"
" vec4 final_texture_color = texture_color;\n"
" gl_FragColor = LightAmbient * final_texture_color + (diff + MaterialEmission) * final_texture_color +spec * MaterialSpecular;\n"
" gl_FragColor.a = texture_color.w - MaterialTransparency;\n"
"}\n"
;
bool GUI_Layered::run3d()
{
// Control the sine wave wobble
unsigned int current_time = CL_System::get_time();
if (panel3d->is_animated())
wobble_offset += ((float) (current_time - last_time)) / 2000.0f;
last_time = current_time;
current_zoffset = panel3d->get_zoffset();
CL_GraphicContext gc = window_ptr->get_gc();
gc.set_map_mode(cl_user_projection);
set_projection_matrix();
modelview_matrix = CL_Mat4f::identity();
modelview_matrix.matrix[2 + (4*2)] = -1.0f;
gc.set_modelview(modelview_matrix);
resultant_matrix = CL_Mat4f::multiply(modelview_matrix, projection_matrix);
LightSource lightsource;
lightsource.m_Specular = CL_Vec4f(panel3d->get_light_specular(), panel3d->get_light_specular(), panel3d->get_light_specular(), 1.0f);
lightsource.m_Diffuse = CL_Vec4f(panel3d->get_light_diffuse(), panel3d->get_light_diffuse(), panel3d->get_light_diffuse(), 1.0f);
lightsource.m_Vector = CL_Vec4f( panel3d->get_light_position_x(), panel3d->get_light_position_y(), panel3d->get_light_position_z(), 0.0f);
lightsource.m_Ambient = CL_Vec4f(0.2f, 0.2f, 0.2f, 1.0f);
lightsource.m_Vector.normalize3();
std::vector<CL_GUIWindowManagerTextureWindow> windows = wm.get_windows();
std::vector<CL_GUIWindowManagerTextureWindow>::size_type index, size;
size = windows.size();
gc.set_program_object(gui_shader);
gui_shader.set_uniform4f("LightVector", lightsource.m_Vector);
CL_Vec4f light_halfvector(0.0f, 0.0f, 1.0f, 0.0f);
light_halfvector += lightsource.m_Vector;
light_halfvector.normalize3();
gui_shader.set_uniform4f("LightHalfVector", light_halfvector);
gui_shader.set_uniform4f("LightSpecular", lightsource.m_Specular);
gui_shader.set_uniform4f("LightDiffuse", lightsource.m_Diffuse);
gui_shader.set_uniform4f("LightAmbient", lightsource.m_Ambient);
gui_shader.set_uniform1f("MaterialShininess", pow(2.0f, (10.0f * panel3d->get_material_shininess()) + 2.0f));
gui_shader.set_uniform4f("MaterialEmission", CL_Vec4f(panel3d->get_material_emission(), panel3d->get_material_emission(), panel3d->get_material_emission(), 1.0f));
gui_shader.set_uniform4f("MaterialSpecular", CL_Vec4f(panel3d->get_material_specular(), panel3d->get_material_specular(), panel3d->get_material_specular(), 1.0f));
gui_shader.set_uniform1f("MaterialTransparency", panel3d->get_material_transparency());
for (index = 0; index < size; index++)
{
CL_GUIWindowManagerTextureWindow window = windows[index];
CL_Subtexture subtexture = window.get_texture();
CL_Texture texture = subtexture.get_texture();
texture.set_min_filter(cl_filter_linear);
texture.set_mag_filter(cl_filter_linear);
CL_Rect window_geometry = window.get_geometry();
CL_Rect subtexture_geometry = subtexture.get_geometry();
CL_Rectf rect((float) window_geometry.left, (float) window_geometry.top, CL_Sizef(subtexture_geometry.get_size()));
CL_Rectf texture_unit1_coords(subtexture_geometry);
float gc_width = (float) gc.get_width();
float gc_height = (float) gc.get_height();
// Transform 2d geometry to 3d
rect.left = ((rect.left * 2.0f) / gc_width) - 1.0f;
rect.right = ((rect.right * 2.0f) / gc_width) - 1.0f;
rect.top = ((rect.top * 2.0f) / gc_height) - 1.0f;
rect.bottom = ((rect.bottom * 2.0f) / gc_height) - 1.0f;
float dest_left = rect.left;
float dest_right = rect.right;
float dest_top = -rect.top;
float dest_bottom = -rect.bottom;
float texture_width = (float) texture.get_width();
float texture_height = (float) texture.get_height();
float texel_centre = 0.375f;
float src_left = (texture_unit1_coords.left + texel_centre) / texture_width;
float src_right = (texture_unit1_coords.right + texel_centre) / texture_width;
float src_top = (texture_unit1_coords.top + texel_centre) / texture_height;
float src_bottom = (texture_unit1_coords.bottom + texel_centre) / texture_height;
const int num_segments_horizontal = 32;
const int num_segments_vertical = 1;
const int num_points = 6 * num_segments_horizontal * num_segments_vertical;
CL_Vec3f positions[num_points];
CL_Vec3f normals[num_points];
CL_Vec2f tex1_coords[num_points];
CL_Vec3f *pos_ptr = positions;
CL_Vec2f *tex_ptr = tex1_coords;
CL_Vec3f *normals_ptr = normals;
CL_Vec3f point_a;
CL_Vec3f point_b;
CL_Vec3f point_c;
CL_Vec3f last_triangle_normal_left;
CL_Vec3f last_triangle_normal_right;
CL_Vec3f this_triangle_normal_left;
CL_Vec3f this_triangle_normal_right;
CL_Vec3f next_triangle_normal_left;
CL_Vec3f next_triangle_normal_right;
CL_Vec3f normal;
for (int segment_count_vertical = 0; segment_count_vertical < num_segments_vertical; segment_count_vertical++)
{
float seg_top = dest_top + (segment_count_vertical * (dest_bottom - dest_top) / num_segments_vertical);
float seg_bottom = dest_top + ((segment_count_vertical+1) * (dest_bottom - dest_top) / num_segments_vertical);
float tex_seg_top = src_top + (segment_count_vertical * (src_bottom- src_top) / num_segments_vertical);
float tex_seg_bottom = src_top + ((segment_count_vertical+1) * (src_bottom- src_top) / num_segments_vertical);
float seg_left;
float seg_right;
seg_left = dest_left + (-1 * (dest_right- dest_left) / num_segments_horizontal);
seg_right = dest_left + ((-1+1) * (dest_right- dest_left) / num_segments_horizontal);
point_a = CL_Vec3f(seg_left, seg_top, get_zpos_at_position(seg_left, seg_top));
point_b = CL_Vec3f(seg_right, seg_top, get_zpos_at_position(seg_right, seg_top));
point_c = CL_Vec3f(seg_left, seg_bottom, get_zpos_at_position(seg_left, seg_bottom));
this_triangle_normal_left = CL_Vec3f::cross(point_b - point_a, point_c - point_a);
point_a = CL_Vec3f(seg_left, seg_bottom, get_zpos_at_position(seg_left, seg_bottom));
point_b = CL_Vec3f(seg_right, seg_top, get_zpos_at_position(seg_right, seg_top));
point_c = CL_Vec3f(seg_right, seg_bottom, get_zpos_at_position(seg_right, seg_bottom));
this_triangle_normal_right = CL_Vec3f::cross(point_b - point_a, point_c - point_a);
seg_left = dest_left + (0 * (dest_right- dest_left) / num_segments_horizontal);
seg_right = dest_left + ((0+1) * (dest_right- dest_left) / num_segments_horizontal);
point_a = CL_Vec3f(seg_left, seg_top, get_zpos_at_position(seg_left, seg_top));
point_b = CL_Vec3f(seg_right, seg_top, get_zpos_at_position(seg_right, seg_top));
point_c = CL_Vec3f(seg_left, seg_bottom, get_zpos_at_position(seg_left, seg_bottom));
next_triangle_normal_left = CL_Vec3f::cross(point_b - point_a, point_c - point_a);
point_a = CL_Vec3f(seg_left, seg_bottom, get_zpos_at_position(seg_left, seg_bottom));
point_b = CL_Vec3f(seg_right, seg_top, get_zpos_at_position(seg_right, seg_top));
point_c = CL_Vec3f(seg_right, seg_bottom, get_zpos_at_position(seg_right, seg_bottom));
next_triangle_normal_right = CL_Vec3f::cross(point_b - point_a, point_c - point_a);
for (int segment_count_horizontal = 0; segment_count_horizontal < num_segments_horizontal; segment_count_horizontal++)
{
last_triangle_normal_left = this_triangle_normal_left;
last_triangle_normal_right = this_triangle_normal_right;
this_triangle_normal_left = next_triangle_normal_left;
this_triangle_normal_right = next_triangle_normal_right;
seg_left = dest_left + (segment_count_horizontal * (dest_right- dest_left) / num_segments_horizontal);
seg_right = dest_left + ((segment_count_horizontal+1) * (dest_right- dest_left) / num_segments_horizontal);
*(pos_ptr++) = CL_Vec3f(seg_left, seg_top, get_zpos_at_position(seg_left, seg_top));
*(pos_ptr++) = CL_Vec3f(seg_right, seg_top, get_zpos_at_position(seg_right, seg_top));
*(pos_ptr++) = CL_Vec3f(seg_left, seg_bottom, get_zpos_at_position(seg_left, seg_bottom));
*(pos_ptr++) = CL_Vec3f(seg_left, seg_bottom, get_zpos_at_position(seg_left, seg_bottom));
*(pos_ptr++) = CL_Vec3f(seg_right, seg_top, get_zpos_at_position(seg_right, seg_top));
*(pos_ptr++) = CL_Vec3f(seg_right, seg_bottom, get_zpos_at_position(seg_right, seg_bottom));
seg_left = dest_left + ((segment_count_horizontal+1) * (dest_right- dest_left) / num_segments_horizontal);
seg_right = dest_left + ((segment_count_horizontal+2) * (dest_right- dest_left) / num_segments_horizontal);
point_a = CL_Vec3f(seg_left, seg_top, get_zpos_at_position(seg_left, seg_top));
point_b = CL_Vec3f(seg_right, seg_top, get_zpos_at_position(seg_right, seg_top));
point_c = CL_Vec3f(seg_left, seg_bottom, get_zpos_at_position(seg_left, seg_bottom));
next_triangle_normal_left = CL_Vec3f::cross(point_b - point_a, point_c - point_a);
point_a = CL_Vec3f(seg_left, seg_bottom, get_zpos_at_position(seg_left, seg_bottom));
point_b = CL_Vec3f(seg_right, seg_top, get_zpos_at_position(seg_right, seg_top));
point_c = CL_Vec3f(seg_right, seg_bottom, get_zpos_at_position(seg_right, seg_bottom));
next_triangle_normal_right = CL_Vec3f::cross(point_b - point_a, point_c - point_a);
normal = last_triangle_normal_left + last_triangle_normal_right + this_triangle_normal_left;
*(normals_ptr++) = normal.normalize();
normal = this_triangle_normal_left + this_triangle_normal_right + next_triangle_normal_left;
*(normals_ptr++) = normal.normalize();
normal = last_triangle_normal_right + this_triangle_normal_left + this_triangle_normal_right;
*(normals_ptr++) = normal.normalize();
normal = last_triangle_normal_right + this_triangle_normal_left + this_triangle_normal_right;
*(normals_ptr++) = normal.normalize();
normal = this_triangle_normal_left + this_triangle_normal_right + next_triangle_normal_left;
*(normals_ptr++) = normal.normalize();
normal = this_triangle_normal_right + next_triangle_normal_left + next_triangle_normal_right;
*(normals_ptr++) = normal.normalize();
float tex_seg_left = src_left + (segment_count_horizontal * (src_right- src_left) / num_segments_horizontal);
float tex_seg_right = src_left + ((segment_count_horizontal+1) * (src_right- src_left) / num_segments_horizontal);
*(tex_ptr++) = CL_Vec2f(tex_seg_left, tex_seg_top);
*(tex_ptr++) = CL_Vec2f(tex_seg_right, tex_seg_top);
*(tex_ptr++) = CL_Vec2f(tex_seg_left, tex_seg_bottom);
*(tex_ptr++) = CL_Vec2f(tex_seg_left, tex_seg_bottom);
*(tex_ptr++) = CL_Vec2f(tex_seg_right, tex_seg_top);
*(tex_ptr++) = CL_Vec2f(tex_seg_right, tex_seg_bottom);
}
}
CL_PrimitivesArray prim_array(gc);
prim_array.set_attributes(0, positions);
prim_array.set_attributes(1, normals);
prim_array.set_attributes(2, tex1_coords);
gc.set_texture(0, texture);
gc.draw_primitives(cl_triangles, num_points, prim_array);
}
gc.reset_program_object();
gc.reset_texture(0);
gc.set_map_mode(CL_MapMode(cl_map_2d_upper_left));
return true;
}
float GUI_Layered::get_zpos_at_position(float xpos, float ypos)
{
float value = xpos;
value = sin(wobble_offset + 1.5f * CL_PI * (value+CL_PI/4.0f));
value = current_zoffset - (value / 2.0f);
return value;
}
void GUI_Layered::set_projection_matrix()
{
CL_GraphicContext gc = window_ptr->get_gc();
float fov = 2.0f * atan2(1.0f, lens_zoom);
float aspect = 1.0f;
float width = (float) gc.get_width();
float height = (float) gc.get_height();
if (height)
aspect = ( width * lens_aspect) / height;
fov = (fov * 180.0f) / CL_PI;
projection_matrix = CL_Mat4f::perspective( fov, aspect, lens_near, lens_far);
gc.set_projection(projection_matrix);
}
void GUI_Layered::wm_input_intercept(CL_InputEvent &input_event, CL_InputState &input_state)
{
CL_GraphicContext gc = window_ptr->get_gc();
float gc_width = (float) gc.get_width();
float gc_height = (float) gc.get_height();
// Transform points to range -1.0f to 1.0f
float mouse_x = ((2.0f * input_event.mouse_pos.x) / gc_width) - 1.0f;
float mouse_y = ((2.0f * input_event.mouse_pos.y) / gc_height) - 1.0f;
mouse_y = -mouse_y;
CL_Mat4d resultant_matrix_double = CL_Mat4d(resultant_matrix);
CL_Mat4d inverse_matrix = resultant_matrix_double.inverse();
CL_Vec3f point;
float mouse_z;
float mouse_low_z = 0.5f;
float mouse_high_z = 1.5f;
for (int max_iterations = 0; max_iterations < 100; ++max_iterations)
{
// Find the Z position of the panel at this 2d point
// Keep bisecting, until we have found the correct Z
mouse_z = ( mouse_high_z + mouse_low_z ) / 2.0f;
point = transform_point(CL_Vec3d( mouse_x, mouse_y, mouse_z), inverse_matrix);
float point_z = get_zpos_at_position(point.x, point.y);
float diff = point_z - point.z;
if (diff < 0.0f)
diff = -diff;
if (diff <= 0.00001)
break;
if (point_z > point.z)
{
mouse_low_z = mouse_z;
}
else
{
mouse_high_z = mouse_z;
}
}
saved_x1 = mouse_x;
saved_x2 = point.x;
saved_y1 = mouse_y;
saved_y2 = point.y;
saved_z1 = mouse_z;
saved_z2 = point.z;
input_event.mouse_pos.x = (int) ((((saved_x2) + 1.0f) * gc_width ) / 2.0f);
input_event.mouse_pos.y = (int) ((((-saved_y2) + 1.0f) * gc_height ) / 2.0f);
}
CL_Vec3f GUI_Layered::transform_point(const CL_Vec3d &src_point, const CL_Mat4d &matrix)
{
CL_Vec3d dest;
dest.x = src_point.x * matrix.matrix[0 + 0*4] +
src_point.y * matrix.matrix[0 + 1*4] +
src_point.z * matrix.matrix[0 + 2*4] +
matrix.matrix[0 + 3*4];
dest.y = src_point.x * matrix.matrix[1 + 0*4] +
src_point.y * matrix.matrix[1 + 1*4] +
src_point.z * matrix.matrix[1 + 2*4] +
matrix.matrix[1 + 3*4];
dest.z = src_point.x * matrix.matrix[2 + 0*4] +
src_point.y * matrix.matrix[2 + 1*4] +
src_point.z * matrix.matrix[2 + 2*4] +
matrix.matrix[2 + 3*4];
double w = src_point.x * matrix.matrix[3 + 0*4] +
src_point.y * matrix.matrix[3 + 1*4] +
src_point.z * matrix.matrix[3 + 2*4] +
matrix.matrix[3 + 3*4];
if (w != 0.0)
{
dest.x /= w;
dest.y /= w;
dest.z /= w;
}
return dest;
}
void GUI_Layered::setup_shader()
{
CL_GraphicContext gc = window_ptr->get_gc();
CL_ShaderObject vertex_shader(gc, cl_shadertype_vertex, GUI_Texture_Shader_Vertex);
if(!vertex_shader.compile())
{
throw CL_Exception(cl_format("Unable to compile vertex shader object: %1", vertex_shader.get_info_log()));
}
CL_ShaderObject fragment_shader(gc, cl_shadertype_fragment, GUI_Texture_Shader_Fragment);
if(!fragment_shader.compile())
{
throw CL_Exception(cl_format("Unable to compile fragment shader object: %1", fragment_shader.get_info_log()));
}
gui_shader = CL_ProgramObject(gc);
gui_shader.attach(vertex_shader);
gui_shader.attach(fragment_shader);
gui_shader.bind_attribute_location(0, "InPosition");
gui_shader.bind_attribute_location(1, "InNormal");
gui_shader.bind_attribute_location(2, "InTexCoord");
if (!gui_shader.link())
{
throw CL_Exception(cl_format("Unable to link program object: %1", gui_shader.get_info_log()));
}
}
| [
"rombust@cc39f7f4-b520-0410-a30f-b56705a9c917"
] | rombust@cc39f7f4-b520-0410-a30f-b56705a9c917 |
8660a47caabc0da0a8a86e3b4745e65bb2a84ef7 | cd2d31b6b627423dc890f510da6fcb860a81cfe0 | /_studio/mfx_lib/decode/vp9/include/mfx_vp9_dec_decode_hw.h | 635d298c1c2ef1671a31ce6caf386ee94e078681 | [
"LicenseRef-scancode-unknown-license-reference",
"MIT"
] | permissive | eistarov/oneVPL-intel-gpu | 1ce39b47ad6352b02c725e322676803951cb0dc9 | e041fa223aaf079faecf8ba248eb8247149bc21a | refs/heads/main | 2023-07-01T23:23:29.303857 | 2021-07-02T06:26:45 | 2021-07-02T06:32:26 | 383,012,333 | 0 | 0 | NOASSERTION | 2021-07-05T04:26:44 | 2021-07-05T04:26:43 | null | UTF-8 | C++ | false | false | 5,715 | h | // Copyright (c) 2014-2020 Intel Corporation
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software 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:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// 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
// AUTHORS 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.
#ifndef _MFX_VP9_DECODE_HW_H_
#define _MFX_VP9_DECODE_HW_H_
#include "mfx_common.h"
#if defined(MFX_ENABLE_VP9_VIDEO_DECODE)
#include "mfx_vp9_dec_decode.h"
#include "mfx_vp9_dec_decode_utils.h"
#include "mfx_umc_alloc_wrapper.h"
#include "mfx_task.h"
#include "mfx_critical_error_handler.h"
#include "umc_mutex.h"
#include "umc_vp9_dec_defs.h"
#include "umc_vp9_frame.h"
#include <list>
#include <set>
#include <deque>
namespace UMC_VP9_DECODER { class Packer; }
class FrameStorage;
class VideoDECODEVP9_HW : public VideoDECODE, public MfxCriticalErrorHandler
{
public:
VideoDECODEVP9_HW(VideoCORE *pCore, mfxStatus *sts);
virtual ~VideoDECODEVP9_HW();
static mfxStatus Query(VideoCORE *pCore, mfxVideoParam *pIn, mfxVideoParam *pOut);
static mfxStatus QueryIOSurf(VideoCORE *pCore, mfxVideoParam *pPar, mfxFrameAllocRequest *pRequest);
static mfxStatus QueryImplsDescription(VideoCORE&, mfxDecoderDescription::decoder&, mfx::PODArraysHolder&);
virtual mfxStatus Init(mfxVideoParam *par) override;
virtual mfxStatus Reset(mfxVideoParam *pPar) override;
virtual mfxStatus Close() override;
virtual mfxTaskThreadingPolicy GetThreadingPolicy() override;
virtual mfxStatus GetVideoParam(mfxVideoParam *pPar) override;
virtual mfxStatus GetDecodeStat(mfxDecodeStat *pStat) override;
static mfxStatus DecodeHeader(VideoCORE * core, mfxBitstream *bs, mfxVideoParam *params);
virtual mfxStatus DecodeFrameCheck(mfxBitstream *bs, mfxFrameSurface1 *pSurfaceWork, mfxFrameSurface1 **ppSurfaceOut, MFX_ENTRY_POINT *pEntryPoint) override;
virtual mfxStatus GetUserData(mfxU8 *pUserData, mfxU32 *pSize, mfxU64 *pTimeStamp);
virtual mfxStatus GetPayload(mfxU64 *pTimeStamp, mfxPayload *pPayload) override;
virtual mfxStatus SetSkipMode(mfxSkipMode mode) override;
virtual mfxFrameSurface1* GetSurface() override;
protected:
void CalculateTimeSteps(mfxFrameSurface1 *);
static mfxStatus QueryIOSurfInternal(eMFXPlatform, mfxVideoParam *, mfxFrameAllocRequest *);
mfxStatus UpdateRefFrames();
mfxStatus CleanRefList();
mfxStatus DecodeSuperFrame(mfxBitstream *in, UMC_VP9_DECODER::VP9DecoderFrame & info);
mfxStatus DecodeFrameHeader(mfxBitstream *in, UMC_VP9_DECODER::VP9DecoderFrame & info);
mfxStatus PackHeaders(mfxBitstream *bs, UMC_VP9_DECODER::VP9DecoderFrame const & info);
mfxFrameSurface1 * GetOriginalSurface(mfxFrameSurface1 *);
mfxStatus GetOutputSurface(mfxFrameSurface1 **, mfxFrameSurface1 *, UMC::FrameMemID);
private:
bool m_isInit;
bool m_is_opaque_memory;
VideoCORE* m_core;
eMFXPlatform m_platform;
mfxVideoParamWrapper m_vInitPar;
mfxVideoParamWrapper m_vPar;
mfxU32 m_num_output_frames;
mfxF64 m_in_framerate;
mfxU16 m_frameOrder;
mfxU32 m_statusReportFeedbackNumber;
UMC::Mutex m_mGuard;
std::deque<UMC::Mutex> m_mCopyGuard; //For handling repeated frames
bool m_adaptiveMode;
mfxU32 m_index;
std::unique_ptr<SurfaceSource> m_surface_source;
std::unique_ptr<UMC_VP9_DECODER::Packer> m_Packer;
std::unique_ptr<FrameStorage> m_framesStorage;
mfxFrameAllocRequest m_request;
mfxFrameAllocResponse m_response;
mfxFrameAllocResponse m_response_alien;
mfxDecodeStat m_stat;
friend mfxStatus MFX_CDECL VP9DECODERoutine(void *p_state, void *pp_param, mfxU32 thread_number, mfxU32);
friend mfxStatus VP9CompleteProc(void *p_state, void *pp_param, mfxStatus);
mfxStatus ReportDecodeStatus(mfxFrameSurface1* surface_work);
void ResetFrameInfo();
mfxStatus PrepareInternalSurface(UMC::FrameMemID &mid);
struct VP9DECODERoutineData
{
VideoDECODEVP9_HW* decoder;
mfxFrameSurface1* surface_work;
UMC::FrameMemID currFrameId;
UMC::FrameMemID copyFromFrame;
mfxU32 index;
mfxU32 showFrame;
};
UMC::VideoAccelerator * m_va;
typedef std::list<mfxFrameSurface1 *> StatuReportList;
StatuReportList m_completedList;
UMC_VP9_DECODER::VP9DecoderFrame m_frameInfo;
typedef struct {
mfxU32 width;
mfxU32 height;
} SizeOfFrame;
SizeOfFrame m_firstSizes;
SizeOfFrame m_sizesOfRefFrame[UMC_VP9_DECODER::NUM_REF_FRAMES];
mfxBitstream m_bs;
mfxI32 m_baseQIndex;
};
#endif // MFX_ENABLE_VP9_VIDEO_DECODE
#endif // _MFX_VP9_DECODE_HW_H_
| [
"oleg.nabiullin@intel.com"
] | oleg.nabiullin@intel.com |
021bd471ecc63e03e96576db2f0f14e27d9543fe | 12d9d7fe88baf2cdefaedc42e8dde6c77e6d7d48 | /Parser/src/FIleUtils.cpp | f46fa604af4f08c4513e103b1c9c17df41fdd5b6 | [] | no_license | phish3y/CParser | 8986dc020066830e777122216f22adccea663bea | 490a5d4d88993ecd646d68da55fd11ba9793043a | refs/heads/master | 2022-02-22T06:27:36.431631 | 2019-10-03T20:14:35 | 2019-10-03T20:14:35 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 815 | cpp | #include "FileUtils.hpp"
#include <stdio.h>
#include <sys/stat.h>
size_t getFileSize(int fd) {
struct stat s;
if(fstat(fd, &s) < 0) {
return -1;
} else {
return s.st_size;
}
}
int mapFile(int fd, size_t size, char** mappedFile) {
*mappedFile = (char*) mmap(NULL, size, PROT_READ, MAP_PRIVATE, fd, 0);
if(mappedFile == MAP_FAILED) {
return -1;
} else {
return 0;
}
}
bool isFileXml(char* filename, int filenameSize) {
int xmlSuffixSize = 4;
char xmlsuffix[] = ".xml";
bool isXml = true;
filename += filenameSize - xmlSuffixSize;
for(int i = 0; i < xmlSuffixSize; ++i) {
if(xmlsuffix[i] != *filename) {
isXml = false;
break;
}
++filename;
}
return isXml;
}
| [
"logsdonevan1@gmail.com"
] | logsdonevan1@gmail.com |
00dc0c870abf2e3011a94277b3ecdd5fa9ff328c | f848b5f96330586ecf1af131e3e02e2bafefd7cb | /RestaurantManagmentSystem/src/FileHelper.h | 7c5f6a587ec4a2039fac862860174a8be885ef8b | [] | no_license | eabasguliyev/RestaurantManagmentSystem | 1bee544925cc08bcbda2fc64fd592e1d3be797c8 | cc1fd82a07198f1b294405b5736fee63eee6ee6e | refs/heads/master | 2023-02-19T15:05:39.833972 | 2021-01-10T07:06:21 | 2021-01-10T07:06:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 233 | h | #pragma once
#include "Restaurant.h"
class FileHelper
{
public:
static void writeToFile(Restaurant& res);
static bool readFromFile(Restaurant& res);
static void writeLog(const std::string& file_name, const std::string& error);
}; | [
"40658140+eabasquliyev@users.noreply.github.com"
] | 40658140+eabasquliyev@users.noreply.github.com |
e2842fe29c77d591944b75a813d1b99c540a3a85 | 1747c8202e8e915fba72c05656df819ffb342682 | /Servo/Behaviours/T-6/B-123/O-108.hpp | 49a89002a0b3dfd53914e3e96e881f2bafcad3a1 | [] | no_license | prisme-studio/SERVO | 7fd7de4ec0892237198c276718bdb5eeb34ffda4 | b231991542931cf685f0060743ef641fa81578dc | refs/heads/master | 2021-01-09T04:35:00.939465 | 2020-03-16T17:18:43 | 2020-03-16T17:18:43 | 242,246,974 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 895 | hpp | //
// O-108.hpp
// Talkers
//
// Created by Valentin Dufois on 2020-02-24.
//
#ifndef O_108_hpp
#define O_108_hpp
#include "../../Output.hpp"
class O108: public Output {
public:
O108(): Output(108, // Output ID
false, // Is tree end ?
124, // Next Behaviour ID
DELAY_DEFAULT, // Is delayed
DELAY_VALUE_DEFAULT, // Delay value (seconds)
DELAY_VARIANCE_DEFAULT, // Delay variance (seconds)
{ // Output values
},
{ // Captions
"Do you mean that they are all the same or they just happen to have identical behaviours?",
}) {}
virtual bool isConditionValid(State &behaviourState) override {
/*
Condition:
*/
return true;
}
};
#endif /* O_108_hpp */
| [
"valentin@dufois.fr"
] | valentin@dufois.fr |
d2933ac6fd2511222f5356e765646af8aff3b0af | fc3cb4f2d5afe9b7093a3c6f9f1cd95211ccf7b8 | /L08S03.ObjectFactory/GameLibrary.h | 7a0242d8bfc9620a2191ec98a456e37e202afe01 | [] | no_license | CPSC-2377-UALR/CPSC.2377.Code.Examples | a8967a9aac7feac1a73b0f625f590959f3323c25 | 80318fe1e395c8e4eb8cfe032b4607260c2988f7 | refs/heads/master | 2022-02-19T04:25:46.417542 | 2019-09-11T17:50:10 | 2019-09-11T17:50:10 | 127,178,682 | 2 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 202 | h | #ifndef GAMELIBRARY_H
#define GAMELIBRARY_H
#include<string>
#include<map>
#include"ObjectFactory.h"
using namespace std;
class GameLibrary{
public:
map<string,ObjectFactory*> inventory;
};
#endif | [
"smorme@ualr.edu"
] | smorme@ualr.edu |
c7e4e3e0c4ce5dcc9a0278c2dcd199b01027bafa | 4b64ae7a608d6ea578bcf1ae61cbb306e5e6779f | /Towers.cpp | 863dd8ed280b2023c4ebdb721ab5a88e72540a89 | [] | no_license | hyydrra/Field-Runner-Game | 800052ce365bec9511ac97f88efc1f9e8837cd32 | cc833aec1093279e00c262a6ae5f42d6dc95c1f0 | refs/heads/master | 2022-11-20T19:55:22.299304 | 2020-07-11T20:40:52 | 2020-07-11T20:40:52 | 278,925,261 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,730 | cpp | #include "Towers.h"
#include "Enemy.h"
#include "Variables.h"
using namespace std;
Variables variables_t = Variables();
Towers::Towers(int position_x_, int position_y_) {
position_x = position_x_;
position_y = position_y_;
maxlevel = 2;
}
void Towers::draw(Window *window) {
int enemy_x, enemy_y;
if (locked){
enemy_x = locked_target->get_location().x;
enemy_y = locked_target->get_location().y;
}
else{
enemy_x = 0;
enemy_y = 0;
}
window->draw_img(
render_tower_path(position_x, position_y, enemy_x, enemy_y),
Rectangle(position_x - 0.5*image_width, position_y -0.5*image_height, image_width, image_height),
NULL_RECT,
0,
tower_flip(position_x, position_y, enemy_x, enemy_y));
}
float Towers::degree_between_two_point(int x1, int y1, int x2, int y2) {
float teta = (atan2(y2-y1, x2-x1)*180/M_PI);
if (teta>=0)
return teta;
else
return 360.0 + teta;
}
bool Towers::tower_flip(int x_tower, int y_tower, int x_enemy, int y_enemy) {
float teta = degree_between_two_point(x_tower, y_tower, x_enemy, y_enemy);
if (teta > 90 && teta < 270) {return true;}
else {return false;}
}
string Towers::fire_nofire_image(){
if(locked){
if ((last_shot_counter > ((1-fire_to_no_fire_ratio) * reload_time/variables_t.update_delay)) ||
(last_shot_counter < (fire_to_no_fire_ratio * reload_time/variables_t.update_delay))){
return "fire";
}
// if(last_shot_counter%3 == 0){
// return "fire";
// }
}
return "nofire";
}
Point Towers::get_location(){ return Point(position_x, position_y);}
float Towers::distance_between_two_point(Point p1, Point p2){
return sqrt(pow(p1.x - p2.x, 2) + pow(p1.y - p2.y, 2));
}
void Towers::set_target(Enemy* target, float new_nearest_target_dist) {
if (locked) {
if ((distance_between_two_point(Point(position_x, position_y), locked_target->get_location()) > range) || locked_target->get_remaining_health() <=0 ) {
locked = false;
}
}
if (!locked) {
if (new_nearest_target_dist < range) {
locked_target = target;
locked = true;
}
}
}
bool Towers::shot_target(int update_delay){
last_shot_counter++;
if (last_shot_counter-1 > int(reload_time/update_delay)){
if(locked){
last_shot_counter = 0;
return true;
}
}
return false;
}
Enemy* Towers::get_target() { return locked_target; }
string Towers::get_name() { return name; }
int Towers::get_upgrade_cost() { return upgrade_cost;}
int Towers::get_build_cost() { return build_cost;} | [
"amirho3eingh98@gmail.com"
] | amirho3eingh98@gmail.com |
9f93d992c0ac4624323ac6444a4c642750710b68 | f371a1e57b354cc1b985dbfc17f057c186d9f7a0 | /programmers/source/1-10.cpp | e19fe67b9b92f568ad955cdf0460869446fb111d | [
"MIT"
] | permissive | tdm1223/Algorithm | 7ea3d79eaa7244a1cfe8a420e25d89b783465e8f | c773ab0338e5a606ad0fc7d8989b0ee7cc1bf3fa | refs/heads/master | 2022-11-14T01:34:08.955376 | 2022-10-30T11:00:54 | 2022-10-30T11:00:54 | 143,304,153 | 8 | 9 | null | 2019-08-06T02:41:24 | 2018-08-02T14:16:00 | C++ | UTF-8 | C++ | false | false | 544 | cpp | // ์ ์ผ ์์ ์ ์ ๊ฑฐํ๊ธฐ
// 2019.06.28
#include<string>
#include<vector>
using namespace std;
vector<int> solution(vector<int> arr)
{
vector<int> answer;
int min = arr[0];
// ์ ์ผ ์์ ์๋ฅผ ์ฐพ์
for (int i = 1; i<arr.size(); i++)
{
if (arr[i] < min)
{
min = arr[i];
}
}
// ์ ์ผ ์์ ์๋ฅผ ์ ์ธํ๊ณ ๋ฒกํฐ์ ๋ฃ์
for (int i = 0; i<arr.size(); i++)
{
if (arr[i] == min)
{
continue;
}
answer.push_back(arr[i]);
}
if (answer.size() == 0)
{
answer.push_back(-1);
}
return answer;
}
| [
"tdm1223@naver.com"
] | tdm1223@naver.com |
e3a66175626d287feeae8b87742c33df92e5b3ea | b88eeed20d442c3e164c727a97db7bdf1935b70f | /contrib/mul/vpdfl/vpdfl_gaussian_kernel_pdf.cxx | f068f31cb178854143f59234c2b095d3c2da13ff | [
"LicenseRef-scancode-warranty-disclaimer"
] | no_license | huanghailiang/vxl-1.17.0 | be3b4909ef31efc2aa0eb4ee884e5190704ca060 | c3076ac1013f10a532fe6d6b3c5f5b78eb26466e | refs/heads/master | 2021-07-23T04:05:36.954717 | 2017-11-01T07:23:22 | 2017-11-01T07:23:22 | 109,099,265 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,299 | cxx | // This is mul/vpdfl/vpdfl_gaussian_kernel_pdf.cxx
#ifdef VCL_NEEDS_PRAGMA_INTERFACE
#pragma implementation
#endif
//:
// \file
// \brief Multi-variate spherical gaussian_kernel_pdf kernel PDF.
// \author Tim Cootes
#include "vpdfl_gaussian_kernel_pdf.h"
#include <vcl_cstdlib.h>
#include <vcl_cassert.h>
#include <vcl_string.h>
#include <vcl_cmath.h>
#include <vnl/vnl_math.h>
#include <vpdfl/vpdfl_gaussian_kernel_pdf_sampler.h>
#include <vpdfl/vpdfl_sampler_base.h>
//=======================================================================
vpdfl_gaussian_kernel_pdf::vpdfl_gaussian_kernel_pdf()
{
}
//=======================================================================
vpdfl_gaussian_kernel_pdf::~vpdfl_gaussian_kernel_pdf()
{
}
//=======================================================================
//: Probability density at x
double vpdfl_gaussian_kernel_pdf::operator()(const vnl_vector<double>& x0) const
{
int n = x_.size();
assert(n>0);
int dim = x_[0].size();
double p;
const vnl_vector<double>* x = &x_[0];
const double* w = width_.data_block();
double k = 1.0/(n*vcl_pow(2*vnl_math::pi,0.5*dim));
double sum = 0;
for (int i=0;i<n;++i)
{
double M = vnl_vector_ssd(x[i],x0)/(w[i]*w[i]);
if (M<20)
sum += vcl_exp(-0.5*M)/vcl_pow(w[i],dim);
}
p = k*sum;
return p;
}
// Probability densities:
double vpdfl_gaussian_kernel_pdf::log_p(const vnl_vector<double>& x) const
{
return vcl_log(vpdfl_gaussian_kernel_pdf::operator()(x));
}
//=======================================================================
vpdfl_sampler_base* vpdfl_gaussian_kernel_pdf::new_sampler() const
{
vpdfl_gaussian_kernel_pdf_sampler *i = new vpdfl_gaussian_kernel_pdf_sampler;
i->set_model(*this);
return i;
}
//=======================================================================
void vpdfl_gaussian_kernel_pdf::gradient(vnl_vector<double>& /*g*/,
vnl_vector<double>const& /*x*/,
double& /*p*/) const
{
vcl_cerr<<"vpdfl_gaussian_kernel_pdf::gradient() Not yet implemented.\n";
vcl_abort();
}
//=======================================================================
void vpdfl_gaussian_kernel_pdf::nearest_plausible(vnl_vector<double>& /*x*/, double /*log_p_min*/) const
{
vcl_cerr<<"vpdfl_gaussian_kernel_pdf::nearest_plausible() Not yet implemented.\n";
vcl_abort();
}
//=======================================================================
// Method: is_a
//=======================================================================
vcl_string vpdfl_gaussian_kernel_pdf::is_a() const
{
static vcl_string class_name_ = "vpdfl_gaussian_kernel_pdf";
return class_name_;
}
//=======================================================================
// Method: is_class
//=======================================================================
bool vpdfl_gaussian_kernel_pdf::is_class(vcl_string const& s) const
{
return vpdfl_kernel_pdf::is_class(s) || s==vpdfl_gaussian_kernel_pdf::is_a();
}
//=======================================================================
// Method: version_no
//=======================================================================
short vpdfl_gaussian_kernel_pdf::version_no() const
{
return 1;
}
//=======================================================================
// Method: clone
//=======================================================================
vpdfl_pdf_base* vpdfl_gaussian_kernel_pdf::clone() const
{
return new vpdfl_gaussian_kernel_pdf(*this);
}
//=======================================================================
// Method: print
//=======================================================================
void vpdfl_gaussian_kernel_pdf::print_summary(vcl_ostream& os) const
{
vpdfl_kernel_pdf::print_summary(os);
}
//=======================================================================
// Method: save
//=======================================================================
void vpdfl_gaussian_kernel_pdf::b_write(vsl_b_ostream& bfs) const
{
vsl_b_write(bfs,is_a());
vsl_b_write(bfs,version_no());
vpdfl_kernel_pdf::b_write(bfs);
}
//=======================================================================
// Method: load
//=======================================================================
void vpdfl_gaussian_kernel_pdf::b_read(vsl_b_istream& bfs)
{
if (!bfs) return;
vcl_string name;
vsl_b_read(bfs,name);
if (name != is_a())
{
vcl_cerr << "I/O ERROR: vsl_b_read(vsl_b_istream&, vpdfl_gaussian_kernel_pdf &)\n"
<< " Attempted to load object of type "
<< name <<" into object of type " << is_a() << '\n';
bfs.is().clear(vcl_ios::badbit); // Set an unrecoverable IO error on stream
return;
}
short version;
vsl_b_read(bfs,version);
switch (version)
{
case (1):
vpdfl_kernel_pdf::b_read(bfs);
break;
default:
vcl_cerr << "I/O ERROR: vsl_b_read(vsl_b_istream&, vpdfl_gaussian_kernel_pdf &)\n"
<< " Unknown version number "<< version << '\n';
bfs.is().clear(vcl_ios::badbit); // Set an unrecoverable IO error on stream
return;
}
}
//==================< end of vpdfl_gaussian_kernel_pdf.cxx >====================
| [
"huanghailiang711@163.com"
] | huanghailiang711@163.com |
bd9bab29421f1bcab451ac516cb02f83f72aa2d2 | ad715f9713dc5c6c570a5ac51a18b11932edf548 | /tensorflow/lite/experimental/telemetry/telemetry_settings.h | 52ba9b8b10e5d664e2e76a2596b59dd802adc6bb | [
"LicenseRef-scancode-generic-cla",
"Apache-2.0",
"BSD-2-Clause"
] | permissive | rockzhuang/tensorflow | f1f31bc8edfa402b748c500efb97473c001bac95 | cb40c060b36c6a75edfefbc4e5fc7ee720273e13 | refs/heads/master | 2022-11-08T20:41:36.735747 | 2022-10-21T01:45:52 | 2022-10-21T01:45:52 | 161,580,587 | 27 | 11 | Apache-2.0 | 2019-01-23T11:00:44 | 2018-12-13T03:47:28 | C++ | UTF-8 | C++ | false | false | 1,721 | h | /* Copyright 2022 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.
==============================================================================*/
#ifndef TENSORFLOW_LITE_EXPERIMENTAL_TELEMETRY_TELEMETRY_SETTINGS_H_
#define TENSORFLOW_LITE_EXPERIMENTAL_TELEMETRY_TELEMETRY_SETTINGS_H_
#include <map>
#include <string>
#include "tensorflow/lite/experimental/telemetry/telemetry_status.h"
namespace tflite {
// TFLite model and interpreter settings that will be reported by telemetry.
struct TelemetrySettings {
// Source of the settings. Determines how `data` is interpreted.
TelemetrySource source;
// Settings data. Interpretation based on `source`.
// If `source` is TFLITE_INTERPRETER, the type of `data` will
// be `TelemetryInterpreterSettings`.
// Otherwise, the data is provided by the individual delegate.
const void* data = nullptr;
};
// TfLite model information and settings of the interpreter.
struct TelemetryInterpreterSettings {
TelemetryInterpreterSettings() = default;
// Metadata from the TfLite model.
std::map<std::string, std::string> model_metadata;
};
} // namespace tflite
#endif // TENSORFLOW_LITE_EXPERIMENTAL_TELEMETRY_TELEMETRY_SETTINGS_H_
| [
"gardener@tensorflow.org"
] | gardener@tensorflow.org |
5b3cf07dd2a624addbea1abbf7a39dfb72a84991 | a583ce8dbc8a0998866b3df6c19498167e3e514f | /recover-binary-search-tree.cc | 80eb576d5ca79c87ed3fa609f27a562de0b02969 | [] | no_license | sealiay/leetcode | 12826662313a99cf9cf36792bced3d0c1503c277 | d57d2bfe5e474d43f0aad29a90993690d2b5d2e3 | refs/heads/master | 2016-09-10T18:28:08.010252 | 2014-03-29T06:29:15 | 2014-03-29T06:29:15 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,247 | cc | /**
* Definition for binary tree
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode(int x) : val(x), left(NULL), right(NULL) {}
* };
*/
class Solution {
public:
TreeNode *er[2];
bool g = false;
void recoverTree(TreeNode *root) {
TreeNode *c = root;
TreeNode *p = nullptr;
while ( c ) {
if ( !c->left ) {
test(p, c);
p = c;
c = c->right;
} else {
TreeNode *q = c->left;
while ( q->right && q->right != c ) q = q->right;
if ( q->right == c ) {
test(q, c);
q->right = nullptr;
p = c;
c = c->right;
} else {
q->right = c;
c = c->left;
}
}
}
swap(er[0]->val, er[1]->val);
return;
}
void test(TreeNode *l, TreeNode *n) {
if ( l && l->val > n->val ) {
if ( !g ) {
er[0] = l;
er[1] = n;
g = true;
} else {
er[1] = n;
}
}
}
};
| [
"eric.3zc@gmail.com"
] | eric.3zc@gmail.com |
a50951346482e06185f2a138bb21ee9db731b026 | 611bd60e4d8f648c6fc2552076f124c739cb05c9 | /Robotic_arm_Ghanshyam's work/Moveit_files/doc/pick_place/src/pick_place_check.cpp | 2bb3fac49fdc5021d2c76b20748f551fbfdecbd4 | [] | no_license | GSHYAM-MRM/MRM-Research-Ghanashyam_Codes | 79d6c3d89394822abf1838c0c31a65f809f4d2dd | e8c48bc7aa8e214cdb9e6950feb03142a0e2fc73 | refs/heads/main | 2022-12-19T00:17:03.680013 | 2020-10-03T22:06:10 | 2020-10-03T22:06:10 | 300,925,418 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 12,108 | cpp | /*********************************************************************
* Software License Agreement (BSD License)
*
* Copyright (c) 2012, Willow Garage, Inc.
* All rights reserved.
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions
* are met:
*
* * Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
* * Redistributions in binary form must reproduce the above
* copyright notice, this list of conditions and the following
* disclaimer in the documentation and/or other materials provided
* with the distribution.
* * Neither the name of Willow Garage nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*********************************************************************/
/* Author: Ioan Sucan, Ridhwan Luthra*/
// ROS
#include <ros/ros.h>
// MoveIt
#include <moveit/planning_scene_interface/planning_scene_interface.h>
#include <moveit/move_group_interface/move_group_interface.h>
// TF2
#include <tf2_geometry_msgs/tf2_geometry_msgs.h>
void openGripper(trajectory_msgs::JointTrajectory& posture)
{
// BEGIN_SUB_TUTORIAL open_gripper
/* Add both finger joints of panda robot. */
posture.joint_names.resize(2);
posture.joint_names[0] = "p1";
posture.joint_names[1] = "p2";
/* Set them as open, wide enough for the object to fit. */
posture.points.resize(1);
posture.points[0].positions.resize(2);
posture.points[0].positions[0] = 0.04;
posture.points[0].positions[1] = 0.04;
posture.points[0].time_from_start = ros::Duration(0.5);
// END_SUB_TUTORIAL
}
void closedGripper(trajectory_msgs::JointTrajectory& posture)
{
// BEGIN_SUB_TUTORIAL closed_gripper
/* Add both finger joints of panda robot. */
posture.joint_names.resize(2);
posture.joint_names[0] = "p1";
posture.joint_names[1] = "p2";
/* Set them as closed. */
posture.points.resize(1);
posture.points[0].positions.resize(2);
posture.points[0].positions[0] = 0.00;
posture.points[0].positions[1] = 0.00;
posture.points[0].time_from_start = ros::Duration(0.5);
// END_SUB_TUTORIAL
}
void pick(moveit::planning_interface::MoveGroupInterface& move_group)
{
// BEGIN_SUB_TUTORIAL pick1
// Create a vector of grasps to be attempted, currently only creating single grasp.
// This is essentially useful when using a grasp generator to generate and test multiple grasps.
std::vector<moveit_msgs::Grasp> grasps;
grasps.resize(1);
// Setting grasp pose
// ++++++++++++++++++++++
// This is the pose of panda_link8. |br|
// Make sure that when you set the grasp_pose, you are setting it to be the pose of the last link in
// your manipulator which in this case would be `"panda_link8"` You will have to compensate for the
// transform from `"panda_link8"` to the palm of the end effector.
grasps[0].grasp_pose.header.frame_id = "base_link";
tf2::Quaternion orientation;
orientation.setRPY(-0.013247, 0.009803, -1.565320);
grasps[0].grasp_pose.pose.orientation = tf2::toMsg(orientation);
grasps[0].grasp_pose.pose.position.x = 0.516484;
grasps[0].grasp_pose.pose.position.y = 0.064646;
grasps[0].grasp_pose.pose.position.z = 0.2;
// Setting pre-grasp approach
// ++++++++++++++++++++++++++
/* Defined with respect to frame_id */
grasps[0].pre_grasp_approach.direction.header.frame_id = "base_link";
/* Direction is set as positive x axis */
grasps[0].pre_grasp_approach.direction.vector.x = 1.0;
grasps[0].pre_grasp_approach.min_distance = 0.235;
grasps[0].pre_grasp_approach.desired_distance = 0.238;
// Setting post-grasp retreat
// ++++++++++++++++++++++++++
/* Defined with respect to frame_id */
grasps[0].post_grasp_retreat.direction.header.frame_id = "base_link";
/* Direction is set as positive z axis */
grasps[0].post_grasp_retreat.direction.vector.z = 1.0;
grasps[0].post_grasp_retreat.min_distance = 0.1;
grasps[0].post_grasp_retreat.desired_distance = 0.25;
// Setting posture of eef before grasp
// +++++++++++++++++++++++++++++++++++
openGripper(grasps[0].pre_grasp_posture);
// END_SUB_TUTORIAL
// BEGIN_SUB_TUTORIAL pick2
// Setting posture of eef during grasp
// +++++++++++++++++++++++++++++++++++
closedGripper(grasps[0].grasp_posture);
// END_SUB_TUTORIAL
// BEGIN_SUB_TUTORIAL pick3
// Set support surface as table1.
move_group.setSupportSurfaceName("table1");
// Call pick to pick up the object using the grasps given
move_group.pick("object", grasps);
// END_SUB_TUTORIAL
}
void place(moveit::planning_interface::MoveGroupInterface& group)
{
// BEGIN_SUB_TUTORIAL place
// TODO(@ridhwanluthra) - Calling place function may lead to "All supplied place locations failed. Retrying last
// location in verbose mode." This is a known issue. |br|
// |br|
// Ideally, you would create a vector of place locations to be attempted although in this example, we only create
// a single place location.
std::vector<moveit_msgs::PlaceLocation> place_location;
place_location.resize(1);
// Setting place location pose
// +++++++++++++++++++++++++++
place_location[0].place_pose.header.frame_id = "base_link";
tf2::Quaternion orientation;
orientation.setRPY(0, 0, -M_PI / 2);
place_location[0].place_pose.pose.orientation = tf2::toMsg(orientation);
/* For place location, we set the value to the exact location of the center of the object. */
place_location[0].place_pose.pose.position.x = 0.5;
place_location[0].place_pose.pose.position.y = -0.35;
place_location[0].place_pose.pose.position.z = 0.2;
// Setting pre-place approach
// ++++++++++++++++++++++++++
/* Defined with respect to frame_id */;
place_location[0].pre_place_approach.direction.header.frame_id = "base_link";
/* Direction is set as negative z axis */
place_location[0].pre_place_approach.direction.vector.z = -1.0;
place_location[0].pre_place_approach.min_distance = 0.394646;
place_location[0].pre_place_approach.desired_distance = 0.414646;
// Setting post-grasp retreat
// ++++++++++++++++++++++++++
/* Defined with respect to frame_id */
place_location[0].post_place_retreat.direction.header.frame_id = "base_link";
/* Direction is set as negative y axis */
place_location[0].post_place_retreat.direction.vector.y = 1.0;
place_location[0].post_place_retreat.min_distance = 0.1;
place_location[0].post_place_retreat.desired_distance = 0.25;
// Setting posture of eef after placing object
// +++++++++++++++++++++++++++++++++++++++++++
/* Similar to the pick case */
openGripper(place_location[0].post_place_posture);
// Set support surface as table2.
group.setSupportSurfaceName("table2");
// Call place to place the object using the place locations given.
group.place("object", place_location);
// END_SUB_TUTORIAL
}
void addCollisionObjects(moveit::planning_interface::PlanningSceneInterface& planning_scene_interface)
{
// BEGIN_SUB_TUTORIAL table1
//
// Creating Environment
// ^^^^^^^^^^^^^^^^^^^^
// Create vector to hold 3 collision objects.
std::vector<moveit_msgs::CollisionObject> collision_objects;
collision_objects.resize(3);
// Add the first table where the cube will originally be kept.
collision_objects[0].id = "table1";
collision_objects[0].header.frame_id = "base_link";
/* Define the primitive and its dimensions. */
collision_objects[0].primitives.resize(1);
collision_objects[0].primitives[0].type = collision_objects[0].primitives[0].BOX;
collision_objects[0].primitives[0].dimensions.resize(3);
collision_objects[0].primitives[0].dimensions[0] = 0.2;
collision_objects[0].primitives[0].dimensions[1] = 0.4;
collision_objects[0].primitives[0].dimensions[2] = 0.1;
/* Define the pose of the table. */
collision_objects[0].primitive_poses.resize(1);
collision_objects[0].primitive_poses[0].position.x = 0.8;
collision_objects[0].primitive_poses[0].position.y = 0.1;
collision_objects[0].primitive_poses[0].position.z = 0.0625;
// END_SUB_TUTORIAL
collision_objects[0].operation = collision_objects[0].ADD;
// BEGIN_SUB_TUTORIAL table2
// Add the second table where we will be placing the cube.
collision_objects[1].id = "table2";
collision_objects[1].header.frame_id = "base_link";
/* Define the primitive and its dimensions. */
collision_objects[1].primitives.resize(1);
collision_objects[1].primitives[0].type = collision_objects[1].primitives[0].BOX;
collision_objects[1].primitives[0].dimensions.resize(3);
collision_objects[1].primitives[0].dimensions[0] = 0.4;
collision_objects[1].primitives[0].dimensions[1] = 0.2;
collision_objects[1].primitives[0].dimensions[2] = 0.1;
/* Define the pose of the table. */
collision_objects[1].primitive_poses.resize(1);
collision_objects[1].primitive_poses[0].position.x = 0.5;
collision_objects[1].primitive_poses[0].position.y = -0.35;
collision_objects[1].primitive_poses[0].position.z = 0.05;
// END_SUB_TUTORIAL
collision_objects[1].operation = collision_objects[1].ADD;
// BEGIN_SUB_TUTORIAL object
// Define the object that we will be manipulating
collision_objects[2].header.frame_id = "base_link";
collision_objects[2].id = "object";
/* Define the primitive and its dimensions. */
collision_objects[2].primitives.resize(1);
collision_objects[2].primitives[0].type = collision_objects[1].primitives[0].BOX;
collision_objects[2].primitives[0].dimensions.resize(3);
collision_objects[2].primitives[0].dimensions[0] = 0.02;
collision_objects[2].primitives[0].dimensions[1] = 0.02;
collision_objects[2].primitives[0].dimensions[2] = 0.2;
/* Define the pose of the object. */
collision_objects[2].primitive_poses.resize(1);
collision_objects[2].primitive_poses[0].position.x = 0.8;
collision_objects[2].primitive_poses[0].position.y = 0.064646;
collision_objects[2].primitive_poses[0].position.z = 0.2;
// END_SUB_TUTORIAL
collision_objects[2].operation = collision_objects[2].ADD;
planning_scene_interface.applyCollisionObjects(collision_objects);
}
int main(int argc, char** argv)
{
ros::init(argc, argv, "dextra_arm_pick_place");
ros::NodeHandle nh;
ros::AsyncSpinner spinner(1);
spinner.start();
ros::WallDuration(1.0).sleep();
moveit::planning_interface::PlanningSceneInterface planning_scene_interface;
moveit::planning_interface::MoveGroupInterface group("arm");
group.setPlanningTime(45.0);
addCollisionObjects(planning_scene_interface);
// Wait a bit for ROS things to initialize
ros::WallDuration(1.0).sleep();
pick(group);
ros::WallDuration(1.0).sleep();
place(group);
ros::waitForShutdown();
return 0;
}
// BEGIN_TUTORIAL
// CALL_SUB_TUTORIAL table1
// CALL_SUB_TUTORIAL table2
// CALL_SUB_TUTORIAL object
//
// Pick Pipeline
// ^^^^^^^^^^^^^
// CALL_SUB_TUTORIAL pick1
// openGripper function
// """"""""""""""""""""
// CALL_SUB_TUTORIAL open_gripper
// CALL_SUB_TUTORIAL pick2
// closedGripper function
// """"""""""""""""""""""
// CALL_SUB_TUTORIAL closed_gripper
// CALL_SUB_TUTORIAL pick3
//
// Place Pipeline
// ^^^^^^^^^^^^^^
// CALL_SUB_TUTORIAL place
// END_TUTORIAL
| [
"gscourses1489@gmail.com"
] | gscourses1489@gmail.com |
44e4da81e57f086a5eab33fd9e540db5282e25ab | 66fa38b0a78c7199e4a08fb7d89e1f0ea407d8aa | /__source__/DataStructures/Primitives/Pure/Vector3/Vector3.impl.h | 0d364cd6ed73041fc26ee839f9fe1412871df95d | [
"MIT"
] | permissive | TheDonsky/DumbRay | b5a4fb5795937318340f503fa6df66bfa658c3d8 | 5625d51d9ba48fb05a5ff0a600a29188344b013d | refs/heads/master | 2022-11-27T07:23:41.147536 | 2022-11-16T19:16:33 | 2022-11-16T19:16:33 | 61,559,713 | 5 | 0 | null | 2018-05-25T07:36:23 | 2016-06-20T15:44:20 | C++ | UTF-8 | C++ | false | false | 30,315 | h | #include"Vector3.h"
/** ########################################################################## **/
/** //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\// **/
/** ########################################################################## **/
// Macros:
/** ------------------------------------ **/
#define SqrMagnitudeOfThis (x*x + y*y + z*z)
#define MagnitudeOfThis sqrt(x*x + y*y + z*z)
#define SqrMagnitude(v) (v.x*v.x + v.y*v.y + v.z*v.z)
#define Magnitude(v) sqrt(v.x*v.x + v.y*v.y + v.z*v.z)
/** ------------------------------------ **/
#define DotProductWith(v) (x*v.x + y*v.y + z*v.z)
#define DotProduct(v1, v2) (v1.x*v2.x + v1.y*v2.y + v1.z*v2.z)
/** ------------------------------------ **/
#define CrossWith_X_Param(v) (y*v.z - v.y*z)
#define CrossWith_Y_Param(v) (v.x*z - x*v.z)
#define CrossWith_Z_Param(v) (x*v.y - v.x*y)
#define CrossProductWith(v) Vector3(CrossWith_X_Param(v), CrossWith_Y_Param(v), CrossWith_Z_Param(v))
#define CrossProduct_X_Param(v1, v2) (v1.y*v2.z - v2.y*v1.z)
#define CrossProduct_Y_Param(v1, v2) (v2.x*v1.z - v1.x*v2.z)
#define CrossProduct_Z_Param(v1, v2) (v1.x*v2.y - v2.x*v1.y)
#define CrossProduct(v1, v2) Vector3(CrossProduct_X_Param(v1, v2), CrossProduct_Y_Param(v1, v2), CrossProduct_Z_Param(v1, v2))
/** ------------------------------------ **/
#define AngleCosWith(v) DotProductWith(v) / sqrt(SqrMagnitudeOfThis*SqrMagnitude(v))
#define AngleCos(v1, v2) DotProduct(v1, v2) / sqrt(SqrMagnitude(v1)*SqrMagnitude(v2))
/** ------------------------------------ **/
#define NormalOn(v) (v*(DotProductWith(v) / SqrMagnitude(v)))
/** ------------------------------------ **/
#define DefCross register float crossX, crossY, crossZ;
#define AssignCrossWith(axis) crossX = CrossWith_X_Param(axis); crossY = CrossWith_Y_Param(axis); crossZ = CrossWith_Z_Param(axis)
#define AssignCrossOf(v1,v2) crossX = CrossProduct_X_Param(v1, v2); crossY = CrossProduct_Y_Param(v1, v2); crossZ = CrossProduct_Z_Param(v1, v2)
#define DefCrossWith(v) DefCross; AssignCrossWith(v)
#define DefCrossBetween(v1, v2) DefCross; AssignCrossOf(v1,v2)
/** ------------------------------------ **/
#define AssignAndReturnThis(a, b, c) x=a; y=b; z=c; return(*this)
/** ########################################################################## **/
/** //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\// **/
/** ########################################################################## **/
/** Construction: **/
// Does nothing
__dumb__ Vector3::Vector3(){}
// Simple constructor
__dumb__ Vector3::Vector3(float X, float Y, float Z){
x = X;
y = Y;
z = Z;
}
// Copy constructor
__dumb__ Vector3::Vector3(const Vector3 &v){
x = v.x;
y = v.y;
z = v.z;
}
// Reconstructor
__dumb__ Vector3& Vector3::operator()(float X, float Y, float Z){
AssignAndReturnThis(X, Y, Z);
}
/** ########################################################################## **/
/** //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\// **/
/** ########################################################################## **/
/** Operators: **/
/** ========================================================== **/
/*| + |*/
// Enables writing "+v"
__dumb__ Vector3 Vector3::operator+()const{
return(*this);
}
// Sum of two vectors
__dumb__ Vector3 Vector3::operator+(const Vector3 &v)const{
return(Vector3(x + v.x, y + v.y, z + v.z));
}
// Increment
__dumb__ Vector3& Vector3::operator+=(const Vector3 &v){
x += v.x;
y += v.y;
z += v.z;
return(*this);
}
/** ========================================================== **/
/*| - |*/
// Inversed vector
__dumb__ Vector3 Vector3::operator-()const{
return(Vector3(-x, -y, -z));
}
// Subtraction of two vectors
__dumb__ Vector3 Vector3::operator-(const Vector3 &v)const{
return(Vector3(x - v.x, y - v.y, z - v.z));
}
// Decrement
__dumb__ Vector3& Vector3::operator-=(const Vector3 &v){
x -= v.x;
y -= v.y;
z -= v.z;
return(*this);
}
/** ========================================================== **/
/*| * & ^ |*/
/** ------------------------------------ **/
// Multiplied by floating point
__dumb__ Vector3 Vector3::operator*(const float f)const{
return(Vector3(x*f, y*f, z*f));
}
// Inversed syntax for floating point multiplication
__dumb__ Vector3 operator*(const float f, const Vector3 &v){
return(Vector3(v.x*f, v.y*f, v.z*f));
}
// Multilication by a floating point
__dumb__ Vector3& Vector3::operator*=(const float f){
x *= f;
y *= f;
z *= f;
return(*this);
}
/** ------------------------------------ **/
// Dot product
__dumb__ float Vector3::operator*(const Vector3 &v)const{
return(DotProductWith(v));
}
/** ------------------------------------ **/
// Cross product
__dumb__ Vector3 Vector3::operator&(const Vector3 &v)const{
return(CrossProductWith(v));
}
// Sets vector to it's cross product with the another one
__dumb__ Vector3& Vector3::operator&=(const Vector3 &v){
AssignAndReturnThis(CrossWith_X_Param(v), CrossWith_Y_Param(v), CrossWith_Z_Param(v));
}
/** ------------------------------------ **/
// Upscaled (x*v.x, y*v.y, z*v.z)
__dumb__ Vector3 Vector3::operator^(const Vector3 &v)const{
return(Vector3(x*v.x, y*v.y, z*v.z));
}
// Upscale
__dumb__ Vector3& Vector3::operator^=(const Vector3 &v){
x *= v.x;
y *= v.y;
z *= v.z;
return(*this);
}
/** ========================================================== **/
/*| / |*/
/** ------------------------------------ **/
// Divided by floating point
__dumb__ Vector3 Vector3::operator/(const float f)const{
register float fi = 1 / f;
return(Vector3(x*fi, y*fi, z*fi));
}
// Inversed syntax for floating point division(dumb and unnessessary, but anyway...)
__dumb__ Vector3 operator/(const float f, const Vector3 &v){
return(Vector3(f / v.x, f / v.y, f / v.z));
}
// Division by floating point
__dumb__ Vector3& Vector3::operator/=(const float f){
register float fi = 1 / f;
x *= fi;
y *= fi;
z *= fi;
return(*this);
}
/** ------------------------------------ **/
// Downscaled (x/v.x, y/v.y, z/v.y)
__dumb__ Vector3 Vector3::operator/(const Vector3 &v)const{
return(Vector3(x / v.x, y / v.y, z / v.z));
}
// Downscale
__dumb__ Vector3& Vector3::operator/=(const Vector3 &v){
x /= v.x;
y /= v.y;
z /= v.z;
return(*this);
}
/** ========================================================== **/
/*| == |*/
// Compare (equals)
__dumb__ bool Vector3::operator==(const Vector3 &v)const{
return((x == v.x) && (y == v.y) && (z == v.z));
}
// Compare (not equals)
__dumb__ bool Vector3::operator!=(const Vector3 &v)const{
return((x != v.x) || (y != v.y) || (z != v.z));
}
// Compare (distance between is low enough)
__dumb__ bool Vector3::isNearTo(const Vector3 &v, const float maxDistance)const{
register float dx = x - v.x;
register float dy = y - v.y;
register float dz = z - v.z;
return((dx*dx + dy*dy + dz*dz) <= (maxDistance*maxDistance));
}
/** ########################################################################## **/
/** //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\// **/
/** ########################################################################## **/
/** Functions: **/
/** ========================================================== **/
/*| Magnitude |*/
/** ------------------------------------ **/
// Square of the vector's length
__dumb__ float Vector3::sqrMagnitude()const{
return(SqrMagnitudeOfThis);
}
// Vector's length
__dumb__ float Vector3::magnitude()const{
return(MagnitudeOfThis);
}
/** ------------------------------------ **/
// Distance to the other vertex
__dumb__ float Vector3::distanceTo(const Vector3 &v)const{
register float dx = x - v.x;
register float dy = y - v.y;
register float dz = z - v.z;
return(sqrt(dx*dx + dy*dy + dz*dz));
}
// Distance between vertices
__dumb__ float Vector3::distance(const Vector3 &v1, const Vector3 &v2){
register float dx = v1.x - v2.x;
register float dy = v1.y - v2.y;
register float dz = v1.z - v2.z;
return(sqrt(dx*dx + dy*dy + dz*dz));
}
/** ------------------------------------ **/
// Unit vector with the same direction
__dumb__ Vector3 Vector3::normalized()const{
register float inversedMagnitude = 1 / MagnitudeOfThis;
return(Vector3(x*inversedMagnitude, y*inversedMagnitude, z*inversedMagnitude));
}
// Makes this vector unit, without changing direction
__dumb__ Vector3& Vector3::normalize(){
register float inversedMagnitude = 1 / MagnitudeOfThis;
x *= inversedMagnitude;
y *= inversedMagnitude;
z *= inversedMagnitude;
return((*this));
}
/** ========================================================== **/
/*| Angle |*/
/** ------------------------------------ **/
// Cosine of angle between vectors
__dumb__ float Vector3::angleCos(const Vector3 &v1, const Vector3 &v2){
return(AngleCos(v1, v2));
}
// Cosine of angle between unit vectors
__dumb__ float Vector3::angleCosUnitVectors(const Vector3 &v1, const Vector3 &v2){
return(DotProduct(v1, v2));
}
// Cosine of angle between this and the another vector
__dumb__ float Vector3::angleCos(const Vector3 &v)const{
return(AngleCosWith(v));
}
// Cosine of angle between this and the another unit vector
__dumb__ float Vector3::angleCosUnitVectors(const Vector3 &v)const{
return(DotProductWith(v));
}
/** ------------------------------------ **/
// Sine of angle between vectors
__dumb__ float Vector3::angleSin(const Vector3 &v1, const Vector3 &v2){
DefCrossBetween(v1, v2);
return(sqrt((crossX*crossX + crossY*crossY + crossZ*crossZ) / (SqrMagnitude(v1)*SqrMagnitude(v2))));
}
// Sine of angle between unit vectors
__dumb__ float Vector3::angleSinUnitVectors(const Vector3 &v1, const Vector3 &v2){
DefCrossBetween(v1, v2);
return(sqrt(crossX*crossX + crossY*crossY + crossZ*crossZ));
}
// Sine of angle between this and the another vector
__dumb__ float Vector3::angleSin(const Vector3 &v)const{
DefCrossWith(v);
return(sqrt((crossX*crossX + crossY*crossY + crossZ*crossZ) / (SqrMagnitudeOfThis*SqrMagnitude(v))));
}
// Sine of angle between this and the another unit vector
__dumb__ float Vector3::angleSinUnitVectors(const Vector3 &v)const{
DefCrossWith(v);
return(sqrt(crossX*crossX + crossY*crossY + crossZ*crossZ));
}
/** ------------------------------------ **/
// Angle between two vectors in radians
__dumb__ float Vector3::radianAngle(const Vector3 &v1, const Vector3 &v2){
return(acos(AngleCos(v1, v2)));
}
// Angle between two unit vectors in radians
__dumb__ float Vector3::radianAngleUnitVectors(const Vector3 &v1, const Vector3 &v2){
return(acos(DotProduct(v1, v2)));
}
// Angle between this and the another vector in radians
__dumb__ float Vector3::radianAngle(const Vector3 &v)const{
return(acos(AngleCosWith(v)));
}
// Angle between this and the another unit vector in radians
__dumb__ float Vector3::radianAngleUnitVectors(const Vector3 &v)const{
return(acos(DotProductWith(v)));
}
/** ------------------------------------ **/
// Angle between two vectors in degrees
__dumb__ float Vector3::angle(const Vector3 &v1, const Vector3 &v2){
return(acos(AngleCos(v1, v2))*RADIAN);
}
// Angle between two unit vectors in degrees
__dumb__ float Vector3::angleUnitVectors(const Vector3 &v1, const Vector3 &v2){
return(acos(DotProduct(v1, v2))*RADIAN);
}
// Angle between this and the another vector in degrees
__dumb__ float Vector3::angle(const Vector3 &v)const{
return(acos(AngleCosWith(v))*RADIAN);
}
// Angle between this and the another unit vector in degrees
__dumb__ float Vector3::angleUnitVectors(const Vector3 &v)const{
return(acos(DotProductWith(v))*RADIAN);
}
/** ========================================================== **/
/*| Normal |*/
/** ------------------------------------ **/
// Normal(projection) on another vector
__dumb__ Vector3 Vector3::normalOn(const Vector3 &v)const{
return(NormalOn(v));
}
// Normal(projection) on an unit vector
__dumb__ Vector3 Vector3::normalOnUnitVector(const Vector3 &v)const{
return(v*DotProductWith(v));
}
// Projects on another vector
__dumb__ Vector3& Vector3::normalizeOn(const Vector3 &v){
return((*this) = NormalOn(v));
}
// Projects on an unit vector
__dumb__ Vector3& Vector3::normalizeOnUnitVector(const Vector3 &v){
return((*this) = v*DotProductWith(v));
}
/** ------------------------------------ **/
// Magnitude of the normal on the another vector
__dumb__ float Vector3::normalLengthOn(const Vector3 &v)const{
return(DotProductWith(v) / Magnitude(v));
}
// Magnitude of the normal on the unit vector
__dumb__ float Vector3::normalLengthOnUnitVector(const Vector3 &v)const{
return(DotProductWith(v));
}
/** ------------------------------------ **/
// Noraml of the plain, defined by two vectors
__dumb__ Vector3 Vector3::plainNormal(const Vector3 &v1, const Vector3 &v2){
DefCrossBetween(v1, v2);
register float inevrsedMagnitude = 1 / sqrt(crossX*crossX + crossY*crossY + crossZ*crossZ);
return(Vector3(crossX*inevrsedMagnitude, crossY*inevrsedMagnitude, crossZ*inevrsedMagnitude));
}
// Noraml of the plain, defined by two unit vectors
__dumb__ Vector3 Vector3::plainNormalForUnitVectors(const Vector3 &v1, const Vector3 &v2){
return(CrossProduct(v1, v2));
}
// Noraml of the plain, defined by three vertices in space
__dumb__ Vector3 Vector3::plainNormal(const Vector3 &v1, const Vector3 &v2, const Vector3 &v3){
register float v1x = v2.x - v1.x;
register float v1y = v2.y - v1.y;
register float v1z = v2.z - v1.z;
register float v2x = v3.x - v1.x;
register float v2y = v3.y - v1.y;
register float v2z = v3.z - v1.z;
register float crossX = (v2y*v1z - v1y*v2z);
register float crossY = (v1x*v2z - v2x*v1z);
register float crossZ = (v2x*v1y - v1x*v2y);
register float inevrsedMagnitude = 1 / sqrt(crossX*crossX + crossY*crossY + crossZ*crossZ);
return(Vector3(crossX*inevrsedMagnitude, crossY*inevrsedMagnitude, crossZ*inevrsedMagnitude));
}
/** ------------------------------------ **/
// Reflection
__dumb__ Vector3 Vector3::reflection(const Vector3 &normal)const {
register float mul = (2.0f * DotProductWith(normal) / SqrMagnitude(normal));
return Vector3(x - (normal.x * mul), y - (normal.y * mul), z - (normal.z * mul));
}
__dumb__ Vector3& Vector3::reflect(const Vector3 &normal) {
register float mul = (2.0f * DotProductWith(normal) / SqrMagnitude(normal));
x -= (normal.x * mul);
y -= (normal.y * mul);
z -= (normal.z * mul);
return(*this);
}
__dumb__ Vector3 Vector3::reflectionOnUnitVector(const Vector3 &normal)const {
register float mul = (2.0f * DotProductWith(normal));
return Vector3(x - (normal.x * mul), y - (normal.y * mul), z - (normal.z * mul));
}
__dumb__ Vector3& Vector3::reflectOnUnitVector(const Vector3 &normal) {
register float mul = (2.0f * DotProductWith(normal));
x -= (normal.x * mul);
y -= (normal.y * mul);
z -= (normal.z * mul);
return (*this);
}
/** ========================================================== **/
/*| Rotation |*/
/** ------------------------------------ **/
#define DefNorm register float normalMultiplier = DotProductWith(axis) / SqrMagnitude(axis); register float normX = axis.x*normalMultiplier; register float normY = axis.y*normalMultiplier; register float normZ = axis.z*normalMultiplier
#define DefDelta register float dx = x - normX; register float dy = y - normY; register float dz = z - normZ
#define DefMultipliers register float cosA = cos(angle); register float sinMultiplier = sin(angle)*sqrt((dx*dx + dy*dy + dz*dz) / (crossX*crossX + crossY*crossY + crossZ*crossZ))
#define DefRotationData DefNorm; DefDelta; DefCross; AssignCrossWith(axis); DefMultipliers
#define RotationResultParams normX + dx*cosA + crossX*sinMultiplier, normY + dy*cosA + crossY*sinMultiplier, normZ + dz*cosA + crossZ*sinMultiplier
/** ------------------------------------ **/
#define DefSinCos register float sinA = sin(angle); register float cosA = cos(angle);
#define DefSinCosAndCross DefSinCos; DefCross; AssignCrossWith(axis)
#define RotationAxisAgainstAxisParams x*cosA + crossX*sinA, y*cosA + crossY*sinA, z*cosA + crossZ*sinA
/** ------------------------------------ **/
#define RotatedAxisParams(v) v.x*cosA - crossX*sinA, v.y*cosA - crossY*sinA, v.z*cosA - crossZ*sinA
#define TwoAxisRotationRoutine DefSinCos; DefCross; AssignCrossWith(v1); v1(RotatedAxisParams(v1)); AssignCrossWith(v2); v2(RotatedAxisParams(v2))
/** ------------------------------------ **/
// This vector, rotated against given vector by given radian angle
__dumb__ Vector3 Vector3::rotated_Radian(const Vector3 &axis, float angle)const{
DefRotationData;
return(Vector3(RotationResultParams));
}
// This vector, rotated against given axis by given radian angle, if both vectors are unit and perpendicular to each other
__dumb__ Vector3 Vector3::rotated_AxisAgainstAxisRadian(const Vector3 &axis, float angle)const{
DefSinCosAndCross;
return(Vector3(RotationAxisAgainstAxisParams));
}
// Rotates vector against given vector by given radian angle
__dumb__ Vector3& Vector3::rotate_Radian(const Vector3 &axis, float angle){
DefRotationData;
return((*this)(RotationResultParams));
}
// Rotates vector against given vector by given radian angle, if both vectors are unit and perpendicular to each other
__dumb__ Vector3& Vector3::rotate_AxisAgainstAxisRadian(const Vector3 &axis, float angle){
DefSinCosAndCross;
return((*this)(RotationAxisAgainstAxisParams));
}
/** ------------------------------------ **/
// This vector, rotated against given vector by given angle in degrees
__dumb__ Vector3 Vector3::rotated(const Vector3 &axis, float angle)const{
angle /= RADIAN;
DefRotationData;
return(Vector3(RotationResultParams));
}
// This vector, rotated against given axis by given angle in degrees, if both vectors are unit and perpendicular to each other
__dumb__ Vector3 Vector3::rotated_AxisAgainstAxis(const Vector3 &axis, float angle)const{
angle /= RADIAN;
DefSinCosAndCross;
return(Vector3(RotationAxisAgainstAxisParams));
}
// Rotates vector against given vector by given angle in degrees
__dumb__ Vector3& Vector3::rotate(const Vector3 &axis, float angle){
angle /= RADIAN;
DefRotationData;
return((*this)(RotationResultParams));
}
// Rotates vector against given vector by given angle in degrees, if both vectors are unit and perpendicular to each other
__dumb__ Vector3& Vector3::rotate_AxisAgainstAxis(const Vector3 &axis, float angle){
angle /= RADIAN;
DefSinCosAndCross;
return((*this)(RotationAxisAgainstAxisParams));
}
/** ------------------------------------ **/
// Rotates two vectors by given radian angle against itself, if all three vectors are unit and perpendicular to each other
__dumb__ void Vector3::rotateTwoAxisAgainstThisRadian(Vector3 &v1, Vector3 &v2, float angle)const{
TwoAxisRotationRoutine;
}
// Rotates two vectors by given angle in degrees against itself, if all three vectors are unit and perpendicular to each other
__dumb__ void Vector3::rotateTwoAxisAgainstThis(Vector3 &v1, Vector3 &v2, float angle)const{
angle /= RADIAN;
TwoAxisRotationRoutine;
}
/** ------------------------------------ **/
#undef DefNorm
#undef DefDelta
#undef DefMultipliers
#undef DefRotationData
#undef RotationResultParams
/** ------------------------------------ **/
#undef DefSinCos
#undef DefSinCosAndCross
#undef RotationAxisAgainstAxisParams
/** ------------------------------------ **/
#undef RotatedAxisParams
#undef TwoAxisRotationRoutine
/** ########################################################################## **/
/** //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\// **/
/** ########################################################################## **/
/** Constants: **/
/** ========================================================== **/
/*| Variables |*/
/** ------------------------------------ **/
#define VECTOR3_ZERO { 0, 0, 0 }
const Vector3 VECTOR3_ZERO_H = VECTOR3_ZERO;
__device__ __constant__ const float3 VECTOR3_ZERO_D = VECTOR3_ZERO;
#define VECTOR3_ONE { 1, 1, 1 }
const Vector3 VECTOR3_ONE_H = VECTOR3_ONE;
__device__ __constant__ const float3 VECTOR3_ONE_D = VECTOR3_ONE;
#define VECTOR3_UP { 0, 1, 0 }
const Vector3 VECTOR3_UP_H = VECTOR3_UP;
__device__ __constant__ const float3 VECTOR3_UP_D = VECTOR3_UP;
#define VECTOR3_DOWN { 0, -1, 0 }
const Vector3 VECTOR3_DOWN_H = VECTOR3_DOWN;
__device__ __constant__ const float3 VECTOR3_DOWN_D = VECTOR3_DOWN;
#define VECTOR3_FRONT { 0, 0, 1 }
const Vector3 VECTOR3_FRONT_H = VECTOR3_FRONT;
__device__ __constant__ const float3 VECTOR3_FRONT_D = VECTOR3_FRONT;
#define VECTOR3_BACK { 0, 0, -1 }
const Vector3 VECTOR3_BACK_H = VECTOR3_BACK;
__device__ __constant__ const float3 VECTOR3_BACK_D = VECTOR3_BACK;
#define VECTOR3_RIGHT { 1, 0, 0 }
const Vector3 VECTOR3_RIGHT_H = VECTOR3_RIGHT;
__device__ __constant__ const float3 VECTOR3_RIGHT_D = VECTOR3_RIGHT;
#define VECTOR3_LEFT { -1, 0, 0 }
const Vector3 VECTOR3_LEFT_H = VECTOR3_LEFT;
__device__ __constant__ const float3 VECTOR3_LEFT_D = VECTOR3_LEFT;
/** ------------------------------------ **/
#define VECTOR3_X_AXIS { 1, 0, 0 }
const Vector3 VECTOR3_X_AXIS_H = VECTOR3_X_AXIS;
__device__ __constant__ const float3 VECTOR3_X_AXIS_D = VECTOR3_X_AXIS;
#define VECTOR3_Y_AXIS { 0, 1, 0 }
const Vector3 VECTOR3_Y_AXIS_H = VECTOR3_Y_AXIS;
__device__ __constant__ const float3 VECTOR3_Y_AXIS_D = VECTOR3_Y_AXIS;
#define VECTOR3_Z_AXIS { 0, 0, 1 }
const Vector3 VECTOR3_Z_AXIS_H = VECTOR3_Z_AXIS;
__device__ __constant__ const float3 VECTOR3_Z_AXIS_D = VECTOR3_Z_AXIS;
#undef VECTOR3_EQIVALENT_FLOAT_ARRAY_SIZE
/** ========================================================== **/
/*| GPU initialisation |*/
// Initializes constants on GPU
inline bool Vector3::initConstants(){
if (cudaMemcpyToSymbol(&VECTOR3_ZERO_D, &VECTOR3_ZERO_H, sizeof(Vector3), 0, cudaMemcpyHostToDevice) != cudaSuccess) return(false);
if (cudaMemcpyToSymbol(&VECTOR3_ONE_D, &VECTOR3_ONE_H, sizeof(Vector3), 0, cudaMemcpyHostToDevice) != cudaSuccess) return(false);
if (cudaMemcpyToSymbol(&VECTOR3_UP_D, &VECTOR3_UP_H, sizeof(Vector3), 0, cudaMemcpyHostToDevice) != cudaSuccess) return(false);
if (cudaMemcpyToSymbol(&VECTOR3_DOWN_D, &VECTOR3_DOWN_H, sizeof(Vector3), 0, cudaMemcpyHostToDevice) != cudaSuccess) return(false);
if (cudaMemcpyToSymbol(&VECTOR3_FRONT_D, &VECTOR3_FRONT_H, sizeof(Vector3), 0, cudaMemcpyHostToDevice) != cudaSuccess) return(false);
if (cudaMemcpyToSymbol(&VECTOR3_BACK_D, &VECTOR3_BACK_H, sizeof(Vector3), 0, cudaMemcpyHostToDevice) != cudaSuccess) return(false);
if (cudaMemcpyToSymbol(&VECTOR3_RIGHT_D, &VECTOR3_RIGHT_H, sizeof(Vector3), 0, cudaMemcpyHostToDevice) != cudaSuccess) return(false);
if (cudaMemcpyToSymbol(&VECTOR3_LEFT_D, &VECTOR3_LEFT_H, sizeof(Vector3), 0, cudaMemcpyHostToDevice) != cudaSuccess) return(false);
if (cudaMemcpyToSymbol(&VECTOR3_X_AXIS_D, &VECTOR3_X_AXIS_H, sizeof(Vector3), 0, cudaMemcpyHostToDevice) != cudaSuccess) return(false);
if (cudaMemcpyToSymbol(&VECTOR3_Y_AXIS_D, &VECTOR3_Y_AXIS_H, sizeof(Vector3), 0, cudaMemcpyHostToDevice) != cudaSuccess) return(false);
if (cudaMemcpyToSymbol(&VECTOR3_Z_AXIS_D, &VECTOR3_Z_AXIS_H, sizeof(Vector3), 0, cudaMemcpyHostToDevice) != cudaSuccess) return(false);
return(true);
}
/** ========================================================== **/
/*| Access |*/
/** ------------------------------------ **/
// Vector3(0, 0, 0); Has visible constants VECTOR3_ZERO_H and *VECTOR3_ZERO_D for the host and the device, respectively, as well as macro VECTOR3_ZERO.
__dumb__ const Vector3& Vector3::zero(){
#ifdef __CUDA_ARCH__
return (*((Vector3*)(&VECTOR3_ZERO_D)));
#else
return VECTOR3_ZERO_H;
#endif
}
// Vector3(1, 1, 1); Has visible constants VECTOR3_ONE_H and *VECTOR3_ONE_D for the host and the device, respectively, as well as macro VECTOR3_ONE.
__dumb__ const Vector3& Vector3::one(){
#ifdef __CUDA_ARCH__
return (*((Vector3*)(&VECTOR3_ONE_D)));
#else
return VECTOR3_ONE_H;
#endif
}
// Vector3(0, 1, 0); Has visible constants VECTOR3_UP_H and *VECTOR3_UP_D for the host and the device, respectively, as well as macro VECTOR3_UP.
__dumb__ const Vector3& Vector3::up(){
#ifdef __CUDA_ARCH__
return (*((Vector3*)(&VECTOR3_UP_D)));
#else
return VECTOR3_UP_H;
#endif
}
// Vector3(0, -1, 0); Has visible constants VECTOR3_DOWN_H and *VECTOR3_DOWN_D for the host and the device, respectively, as well as macro VECTOR3_DOWN.
__dumb__ const Vector3& Vector3::down(){
#ifdef __CUDA_ARCH__
return (*((Vector3*)(&VECTOR3_DOWN_D)));
#else
return VECTOR3_DOWN_H;
#endif
}
// Vector3(0, 0, 1); Has visible constants VECTOR3_FRONT_H and *VECTOR3_FRONT_D for the host and the device, respectively, as well as macro VECTOR3_FRONT.
__dumb__ const Vector3& Vector3::front(){
#ifdef __CUDA_ARCH__
return (*((Vector3*)(&VECTOR3_FRONT_D)));
#else
return VECTOR3_FRONT_H;
#endif
}
// Vector3(0, 0, -1); Has visible constants VECTOR3_BACK_H and *VECTOR3_BACK_D for the host and the device, respectively, as well as macro VECTOR3_BACK.
__dumb__ const Vector3& Vector3::back(){
#ifdef __CUDA_ARCH__
return (*((Vector3*)(&VECTOR3_BACK_D)));
#else
return VECTOR3_BACK_H;
#endif
}
// Vector3(1, 0, 0); Has visible constants VECTOR3_RIGHT_H and *VECTOR3_RIGHT_D for the host and the device, respectively, as well as macro VECTOR3_RIGHT.
__dumb__ const Vector3& Vector3::right(){
#ifdef __CUDA_ARCH__
return (*((Vector3*)(&VECTOR3_RIGHT_D)));
#else
return VECTOR3_RIGHT_H;
#endif
}
// Vector3(-1, 0, 0); Has visible constants VECTOR3_LEFT_H and *VECTOR3_LEFT_D for the host and the device, respectively, as well as macro VECTOR3_LEFT.
__dumb__ const Vector3& Vector3::left(){
#ifdef __CUDA_ARCH__
return (*((Vector3*)(&VECTOR3_LEFT_D)));
#else
return VECTOR3_LEFT_H;
#endif
}
/** ------------------------------------ **/
// Vector3(1, 0, 0); Has visible constants VECTOR3_X_AXIS_H and *VECTOR3_X_AXIS_D for the host and the device, respectively, as well as macro VECTOR3_X_AXIS.
__dumb__ const Vector3& Vector3::Xaxis(){
#ifdef __CUDA_ARCH__
return (*((Vector3*)(&VECTOR3_X_AXIS_D)));
#else
return VECTOR3_X_AXIS_H;
#endif
}
// Vector3(0, 1, 0); Has visible constants VECTOR3_Y_AXIS_H and *VECTOR3_Y_AXIS_D for the host and the device, respectively, as well as macro VECTOR3_Y_AXIS.
__dumb__ const Vector3& Vector3::Yaxis(){
#ifdef __CUDA_ARCH__
return (*((Vector3*)(&VECTOR3_Y_AXIS_D)));
#else
return VECTOR3_Y_AXIS_H;
#endif
}
// Vector3(0, 0, 1); Has visible constants VECTOR3_Z_AXIS_H and *VECTOR3_Z_AXIS_D for the host and the device, respectively, as well as macro VECTOR3_Z_AXIS.
__dumb__ const Vector3& Vector3::Zaxis(){
#ifdef __CUDA_ARCH__
return (*((Vector3*)(&VECTOR3_Z_AXIS_D)));
#else
return VECTOR3_Z_AXIS_H;
#endif
}
// Vector3(1, 0, 0); Has visible constants VECTOR3_X_AXIS_H and *VECTOR3_X_AXIS_D for the host and the device, respectively, as well as macro VECTOR3_X_AXIS.
__dumb__ const Vector3& Vector3::i(){
#ifdef __CUDA_ARCH__
return (*((Vector3*)(&VECTOR3_X_AXIS_D)));
#else
return VECTOR3_X_AXIS_H;
#endif
}
// Vector3(0, 1, 0); Has visible constants VECTOR3_Y_AXIS_H and *VECTOR3_Y_AXIS_D for the host and the device, respectively, as well as macro VECTOR3_Y_AXIS.
__dumb__ const Vector3& Vector3::j(){
#ifdef __CUDA_ARCH__
return (*((Vector3*)(&VECTOR3_Y_AXIS_D)));
#else
return VECTOR3_Y_AXIS_H;
#endif
}
// Vector3(0, 0, 1); Has visible constants VECTOR3_Z_AXIS_H and *VECTOR3_Z_AXIS_D for the host and the device, respectively, as well as macro VECTOR3_Z_AXIS.
__dumb__ const Vector3& Vector3::k(){
#ifdef __CUDA_ARCH__
return (*((Vector3*)(&VECTOR3_Z_AXIS_D)));
#else
return VECTOR3_Z_AXIS_H;
#endif
}
/** ########################################################################## **/
/** //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\// **/
/** ########################################################################## **/
/** Stream operators: **/
// Stream operator for input.
inline std::istream& operator>>(std::istream &stream, Vector3 &v){
return(stream >> v.x >> v.y >> v.z);
}
// Stream operator for output.
inline std::ostream& operator<<(std::ostream &stream, const Vector3 &v){
return(stream << "(" << v.x << ", " << v.y << ", " << v.z << ")");
}
/** ########################################################################## **/
/** //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\// **/
/** ########################################################################## **/
/** From/to Dson: **/
inline bool Vector3::fromDson(const Dson::Object &object, std::ostream *errorStream) {
if (object.type() != Dson::Object::DSON_ARRAY) {
if (errorStream != NULL) (*errorStream) << "Vector3 can not be constructed from any Dson::Object other than Dson::Array" << std::endl;
return false;
}
const Dson::Array &arr = (*((Dson::Array*)(&object)));
x = y = z = 0;
int numId = 0;
for (int i = 0; i < arr.size(); i++)
if (arr[i].type() == Dson::Object::DSON_NUMBER) {
float number = ((Dson::Number*)(&arr[i]))->floatValue();
if (numId == 0) x = number;
else if (numId == 1) y = number;
else if (numId == 2) z = number;
numId++;
}
return true;
}
inline Dson::Array Vector3::toDson()const {
Dson::Array arr;
Dson::Number number;
number.value() = ((double)x);
arr.push(number);
number.value() = ((double)y);
arr.push(number);
number.value() = ((double)y);
arr.push(number);
return arr;
}
/** ########################################################################## **/
/** //\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\//\\// **/
/** ########################################################################## **/
/** Macro undefs: **/
/** ------------------------------------ **/
#undef SqrMagnitudeOfThis
#undef MagnitudeOfThis
#undef SqrMagnitude
#undef Magnitude
/** ------------------------------------ **/
#undef DotProductWith
#undef DotProduct
/** ------------------------------------ **/
#undef CrossWith_X_Param
#undef CrossWith_Y_Param
#undef CrossWith_Z_Param
#undef CrossProductWith
#undef CrossProduct_X_Param
#undef CrossProduct_Y_Param
#undef CrossProduct_Z_Param
#undef CrossProduct
/** ------------------------------------ **/
#undef AngleCosWith
#undef AngleCos
/** ------------------------------------ **/
#undef NormalOn
/** ------------------------------------ **/
#undef DefCross
#undef AssignCrossWith
#undef AssignCrossOf
#undef DefCrossWith
#undef DefCrossBetween
/** ------------------------------------ **/
#undef AssignAndReturnThis
| [
"nikadon.net@gmail.com"
] | nikadon.net@gmail.com |
41a31dae8a887645ca92b8952a91f54d9be76b2b | 09ed831aeec406e86a992f13ae7de7ea7d20b4c9 | /HydroxUtilities/include/Utilities/Timer/TimerGPUOGL.h | e0aa183a497a026324ee18586f4c302c516ea4bd | [] | no_license | HyDr0x/Hydrox_Engine | 77a7e0beef0b9f757fb739a09c7d786c76334cb6 | 563c17523dc0a2ce4490387a2c9188d423a408e2 | refs/heads/master | 2021-05-31T02:13:42.040613 | 2014-05-06T10:25:29 | 2014-05-06T10:25:29 | 14,363,292 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 576 | h | #ifndef OGLTIMER_H_
#define OGLTIMER_H_
#include <iostream>
#include <string>
#include <GL\glew.h>
#include "Utilities/DLLExport.h"
#ifdef _WIN32
#define MICROSIGN unsigned char (230)
#else
#define MICROSIGN unsigned short (0xC2B5)
#endif
namespace he
{
namespace util
{
class GRAPHICAPI OGLTimer
{
public:
OGLTimer(std::string &timerName);
~OGLTimer();
GLuint getTimeDifference();
private:
std::string m_timerName;
GLuint m_query;
GLuint m_openGLTime;
bool m_showTimerWhenDying;
};
}
}
#endif
| [
"christoph.laemmerhirt@st.ovgu.de"
] | christoph.laemmerhirt@st.ovgu.de |
ec96db1cdfd71028abf4a2f5b91ad8d3e85a5d0a | 96a72e0b2c2dae850d67019bc26b73864e680baa | /Study/DirectX/HW7/directx1/modelclass.h | 9428d6f37c3fd0329913ba9cc7638c25e270ca72 | [] | no_license | SeaCanFly/CODE | 7c06a81ef04d14f064e2ac9737428da88f0957c7 | edf9423eb074861daf5063310a894d7870fa7b84 | refs/heads/master | 2021-04-12T12:15:58.237501 | 2019-07-15T05:02:09 | 2019-07-15T05:02:09 | 126,703,006 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,414 | h | #pragma once
#ifndef _MODELCLASS_H_
#define _MODELCLASS_H_
//////////////
// INCLUDES //
//////////////
#include <fstream>
#include <d3d11.h>
#include <d3dx10math.h>
using namespace std;
///////////////////////
// MY CLASS INCLUDES //
///////////////////////
#include "textureclass.h"
////////////////////////////////////////////////////////////////////////////////
// Class name: ModelClass
////////////////////////////////////////////////////////////////////////////////
class ModelClass
{
private:
struct VertexType
{
D3DXVECTOR3 position;
D3DXVECTOR2 texture;
D3DXVECTOR3 normal;
};
struct ModelType
{
float x, y, z;
float tu, tv;
float nx, ny, nz;
};
public:
ModelClass();
ModelClass(const ModelClass&);
~ModelClass();
bool Initialize(ID3D11Device*, char*, WCHAR*);
void Shutdown();
void Render(ID3D11DeviceContext*);
int GetIndexCount();
ID3D11ShaderResourceView* GetTexture();
void SetPosition(float, float, float);
void GetPosition(float&, float&, float&);
private:
bool InitializeBuffers(ID3D11Device*);
void ShutdownBuffers();
void RenderBuffers(ID3D11DeviceContext*);
bool LoadTexture(ID3D11Device*, WCHAR*);
void ReleaseTexture();
bool LoadModel(char*);
void ReleaseModel();
private:
ID3D11Buffer *m_vertexBuffer, *m_indexBuffer;
int m_vertexCount, m_indexCount;
TextureClass* m_Texture;
ModelType* m_model;
float m_positionX, m_positionY, m_positionZ;
};
#endif | [
"SeaCanFly@gmail.com"
] | SeaCanFly@gmail.com |
e3374b4afa46ce3a4d6289845fe42c03d3f62b7c | bd1fea86d862456a2ec9f56d57f8948456d55ee6 | /000/113/955/CWE762_Mismatched_Memory_Management_Routines__delete_array_struct_realloc_73a.cpp | 7d2aaa712a5ae73093eb77c2fa595eed6e2f9bdb | [] | no_license | CU-0xff/juliet-cpp | d62b8485104d8a9160f29213368324c946f38274 | d8586a217bc94cbcfeeec5d39b12d02e9c6045a2 | refs/heads/master | 2021-03-07T15:44:19.446957 | 2020-03-10T12:45:40 | 2020-03-10T12:45:40 | 246,275,244 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,282 | cpp | /* TEMPLATE GENERATED TESTCASE FILE
Filename: CWE762_Mismatched_Memory_Management_Routines__delete_array_struct_realloc_73a.cpp
Label Definition File: CWE762_Mismatched_Memory_Management_Routines__delete_array.label.xml
Template File: sources-sinks-73a.tmpl.cpp
*/
/*
* @description
* CWE: 762 Mismatched Memory Management Routines
* BadSource: realloc Allocate data using realloc()
* GoodSource: Allocate data using new []
* Sinks:
* GoodSink: Deallocate data using free()
* BadSink : Deallocate data using delete []
* Flow Variant: 73 Data flow: data passed in a list from one function to another in different source files
*
* */
#include "std_testcase.h"
#include <list>
using namespace std;
namespace CWE762_Mismatched_Memory_Management_Routines__delete_array_struct_realloc_73
{
#ifndef OMITBAD
/* bad function declaration */
void badSink(list<twoIntsStruct *> dataList);
void bad()
{
twoIntsStruct * data;
list<twoIntsStruct *> dataList;
/* Initialize data*/
data = NULL;
data = NULL;
/* POTENTIAL FLAW: Allocate memory with a function that requires free() to free the memory */
data = (twoIntsStruct *)realloc(data, 100*sizeof(twoIntsStruct));
/* Put data in a list */
dataList.push_back(data);
dataList.push_back(data);
dataList.push_back(data);
badSink(dataList);
}
#endif /* OMITBAD */
#ifndef OMITGOOD
/* goodG2B uses the GoodSource with the BadSink */
void goodG2BSink(list<twoIntsStruct *> dataList);
static void goodG2B()
{
twoIntsStruct * data;
list<twoIntsStruct *> dataList;
/* Initialize data*/
data = NULL;
/* FIX: Allocate memory using new [] */
data = new twoIntsStruct[100];
/* Put data in a list */
dataList.push_back(data);
dataList.push_back(data);
dataList.push_back(data);
goodG2BSink(dataList);
}
/* goodB2G uses the BadSource with the GoodSink */
void goodB2GSink(list<twoIntsStruct *> dataList);
static void goodB2G()
{
twoIntsStruct * data;
list<twoIntsStruct *> dataList;
/* Initialize data*/
data = NULL;
data = NULL;
/* POTENTIAL FLAW: Allocate memory with a function that requires free() to free the memory */
data = (twoIntsStruct *)realloc(data, 100*sizeof(twoIntsStruct));
dataList.push_back(data);
dataList.push_back(data);
dataList.push_back(data);
goodB2GSink(dataList);
}
void good()
{
goodG2B();
goodB2G();
}
#endif /* OMITGOOD */
} /* close namespace */
/* Below is the main(). It is only used when building this testcase on
its own for testing or for building a binary to use in testing binary
analysis tools. It is not used when compiling all the testcases as one
application, which is how source code analysis tools are tested. */
#ifdef INCLUDEMAIN
using namespace CWE762_Mismatched_Memory_Management_Routines__delete_array_struct_realloc_73; /* so that we can use good and bad easily */
int main(int argc, char * argv[])
{
/* seed randomness */
srand( (unsigned)time(NULL) );
#ifndef OMITGOOD
printLine("Calling good()...");
good();
printLine("Finished good()");
#endif /* OMITGOOD */
#ifndef OMITBAD
printLine("Calling bad()...");
bad();
printLine("Finished bad()");
#endif /* OMITBAD */
return 0;
}
#endif
| [
"frank@fischer.com.mt"
] | frank@fischer.com.mt |
bc9110c2c05ae7c8655cce80a2fbb42c960b513e | 284047fb958e867033fac5eb9893d0fce503d1cf | /chapter14/page502/main.cpp | ea31f986c2f523368c5fa5b477343b55750672f5 | [] | no_license | liuxinyu123/cpp-primer | d8bbc4c209e077187221d6bdb12c1f88a0002cfb | 5f27e737de13df705fb7f5a57a4a5ac07cb24200 | refs/heads/master | 2021-01-13T16:42:45.948833 | 2017-02-22T15:01:32 | 2017-02-22T15:01:32 | 77,421,962 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 786 | cpp | #include <iostream>
#include "strblob.h"
#include "strblobptr.h"
using std::cout;
using std::endl;
int main (int argc, char *argv[])
{
StrBlob sb1 ({"hello", "world", "what", "are", "you", "doing"});
cout << sb1.Size () << endl;
cout << sb1 << endl;
StrBlobPtr sbp1(sb1);
cout << sbp1.Deref () << endl;
sbp1.Incr ();
cout << sbp1.Deref () << endl;
cout << (++sbp1).Deref () << endl;
cout << sbp1++.Deref () << endl;
cout << sbp1.Deref () << endl;
cout << sbp1.operator++ (0).Deref () << endl;
cout << sbp1.operator++ ().Deref () << endl;
//cout << sbp1.operator++ ().Deref () << endl;
StrBlob sb2 = {"how", "are", "you"};
StrBlobPtr sbp2 (sb2);
cout << *sbp2 << endl;
*sbp2 = "ok";
cout << sbp2 -> size () << endl;
cout << (*sbp2).size () << endl;
return 0;
}
| [
"happy_lucky52@163.com"
] | happy_lucky52@163.com |
bb162bf1548e6ac4b5f9fdf52df77e9e6c6f8d0b | fd19b1e99f869e2fc2dd530cf8fa404c8f1995f3 | /CPP/May/uafh.cpp | b3bf64e95fe3bbeff9a2b0465452e04b79e7c29b | [] | no_license | sumanthreddy07/Competitive_Programming | 3c16eeb7c9133bfc4c7af4c51f53b0205dd32a57 | 0291d75d4fa017b2a3e206e8aa1d4001e864d550 | refs/heads/master | 2023-06-28T07:03:06.665869 | 2021-07-10T17:41:34 | 2021-07-10T17:41:34 | 242,544,556 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 919 | cpp | #include <bits/stdc++.h>
#include <vector>
#include <string>
#include <algorithm>
#define LL long long
#define L long
#define run(i,a,b) for(long i=a;i<=b;i++)
#define revrun(i,a,b) for(long i=b;i>=a;i--)
#define PAIR pair<long,long>
using namespace std;
int main()
{
L t,i,j,flag=0,sum=0;
cin>>t;
while(t--)
{
LL n,k,num2;
cin>>n>>k;
if( (n-k+1)%2==1 && (n-k)>=0)
{
cout<<"YES"<<endl;
run(i,1,k-1)
{
cout<<1<<" ";
n--;
}
cout<<n<<endl;
}
else if( (n-2*k+2)%2==0 && (n-2*k)>=0)
{
cout<<"YES"<<endl;
run(i,1,k-1)
{
cout<<2<<" ";
n-=2;
}
cout<<n<<endl;
}
else
{
cout<<"NO"<<endl;
}
}
return 0;
} | [
"kota.sumanthreddy@gmail.com"
] | kota.sumanthreddy@gmail.com |
f1032affb9cd18cdb3ed42c429bd736e3aa81ac4 | dc802fc27398276106626e12ab1e5ae957bde460 | /thirdparty/openexr/source/IlmImf/ImfAttribute.cpp | 85dd269162a25a666c4263dff9ba1db373ae57cd | [
"BSD-3-Clause",
"Unlicense"
] | permissive | simoncblyth/Optix7Sandbox | 495e58e017cb94c28a506ce8f9e948526b1eba4d | 06c703ea9bd00d65a32ea3dcd26d9fc208655543 | refs/heads/master | 2020-09-11T13:01:49.553607 | 2019-10-20T09:18:34 | 2019-10-20T09:18:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,239 | cpp | ///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2002, Industrial Light & Magic, a division of Lucas
// Digital Ltd. LLC
//
// 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 Industrial Light & Magic 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.
//
///////////////////////////////////////////////////////////////////////////
//-----------------------------------------------------------------------------
//
// class Attribute
//
//-----------------------------------------------------------------------------
#include <ImfAttribute.h>
#include "IlmThreadMutex.h"
#include "Iex.h"
#include <string.h>
#include <map>
#include "ImfNamespace.h"
OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_ENTER
using ILMTHREAD_NAMESPACE::Mutex;
using ILMTHREAD_NAMESPACE::Lock;
Attribute::Attribute () {}
Attribute::~Attribute () {}
namespace {
struct NameCompare//: std::binary_function <const char *, const char *, bool>
{
bool
operator () (const char *x, const char *y) const
{
return strcmp (x, y) < 0;
}
};
typedef Attribute* (*Constructor)();
typedef std::map <const char *, Constructor, NameCompare> TypeMap;
class LockedTypeMap: public TypeMap
{
public:
Mutex mutex;
};
LockedTypeMap &
typeMap ()
{
// c++11 requires thread-safe static variable initialization
#if __cplusplus >= 201103L
static LockedTypeMap tMap;
return tMap;
#else
static Mutex criticalSection;
Lock lock (criticalSection);
static LockedTypeMap* typeMap = 0;
if (typeMap == 0)
typeMap = new LockedTypeMap ();
return *typeMap;
#endif
}
} // namespace
bool
Attribute::knownType (const char typeName[])
{
LockedTypeMap& tMap = typeMap();
Lock lock (tMap.mutex);
return tMap.find (typeName) != tMap.end();
}
void
Attribute::registerAttributeType (const char typeName[],
Attribute *(*newAttribute)())
{
LockedTypeMap& tMap = typeMap();
Lock lock (tMap.mutex);
if (tMap.find (typeName) != tMap.end())
THROW (IEX_NAMESPACE::ArgExc, "Cannot register image file attribute "
"type \"" << typeName << "\". "
"The type has already been registered.");
tMap.insert (TypeMap::value_type (typeName, newAttribute));
}
void
Attribute::unRegisterAttributeType (const char typeName[])
{
LockedTypeMap& tMap = typeMap();
Lock lock (tMap.mutex);
tMap.erase (typeName);
}
Attribute *
Attribute::newAttribute (const char typeName[])
{
LockedTypeMap& tMap = typeMap();
Lock lock (tMap.mutex);
TypeMap::const_iterator i = tMap.find (typeName);
if (i == tMap.end())
THROW (IEX_NAMESPACE::ArgExc, "Cannot create image file attribute of "
"unknown type \"" << typeName << "\".");
return (i->second)();
}
OPENEXR_IMF_INTERNAL_NAMESPACE_SOURCE_EXIT
| [
"microsoft@hurleyworks.com"
] | microsoft@hurleyworks.com |
9c1b3fd8ee20ba62b8b5bf7ee4a471cc7667a0d6 | 46562ad5824f919d47fb9b31f9ba781c15504028 | /src/models/resources/tile-extractor.hpp | 46eb369fb457b47952cd154425b8251f31394686 | [
"MIT"
] | permissive | undisbeliever/untech-editor | f61c233340e6f1a5882034a8917901c5ca5416e7 | 0927e385c7d8085f3e2caafa48038c563499d9b2 | refs/heads/master | 2023-07-08T03:41:51.347757 | 2023-07-01T08:49:21 | 2023-07-01T08:49:21 | 75,025,364 | 8 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,631 | hpp | /*
* This file is part of the UnTech Editor Suite.
* Copyright (c) 2016 - 2021, Marcus Rowe <undisbeliever@gmail.com>.
* Distributed under The MIT License: https://opensource.org/licenses/MIT
*/
#include "invalid-image-error.h"
#include "models/common/image.h"
#include "models/common/iterators.h"
#include "models/snes/bit-depth.h"
#include "models/snes/convert-snescolor.h"
#include "models/snes/tile.h"
#include <vector>
namespace UnTech::Resources {
struct TileAndPalette {
Snes::Tile8px tile;
unsigned palette{};
};
inline bool extractTile8px(Snes::Tile8px& tile,
const Image& image, const unsigned x, const unsigned y,
const std::vector<Snes::SnesColor>::const_iterator pBegin,
const std::vector<Snes::SnesColor>::const_iterator pEnd)
{
const static unsigned TS = tile.TILE_SIZE;
assert(x + TS <= image.size().width && x + TS <= image.size().height);
for (const auto ty : range(TS)) {
auto imgBits = image.scanline(y + ty).subspan(x, TS);
for (const auto tx : range(TS)) {
const Snes::SnesColor c = Snes::toSnesColor(imgBits[tx]);
auto pIt = std::find(pBegin, pEnd, c);
if (pIt == pEnd) {
// color not found in palette
return false;
}
tile.setPixel(tx, ty, std::distance(pBegin, pIt));
}
}
return true;
}
inline bool extractTileAndPalette(TileAndPalette& ft, const Image& image, const unsigned x, const unsigned y,
const std::vector<Snes::SnesColor>& palette, const unsigned colorsPerPalette,
const unsigned firstPalette, const unsigned nPalettes)
{
const unsigned firstColor = firstPalette * colorsPerPalette;
const unsigned lastColor = std::min<size_t>(firstColor + nPalettes * colorsPerPalette, palette.size());
for (size_t pIndex = firstColor, pId = firstPalette; pIndex < lastColor; pIndex += colorsPerPalette, pId++) {
auto pStart = palette.begin() + pIndex;
auto pEnd = pIndex + colorsPerPalette < lastColor ? pStart + colorsPerPalette
: palette.begin() + lastColor;
bool s = extractTile8px(ft.tile, image, x, y, pStart, pEnd);
if (s) {
ft.palette = pId;
return true;
}
}
return false;
}
inline std::vector<TileAndPalette> tilesFromImage(const Image& image, const Snes::BitDepth bitDepth,
const std::vector<Snes::SnesColor>& palette,
const unsigned firstPalette, const unsigned nPalettes,
std::vector<InvalidImageTile>& err)
{
const static unsigned TS = decltype(TileAndPalette::tile)::TILE_SIZE;
const unsigned colorsPerPalette = Snes::colorsForBitDepth(bitDepth);
const usize iSize = image.size();
unsigned tw = iSize.width / TS;
unsigned th = iSize.height / TS;
std::vector<TileAndPalette> tiles(tw * th);
auto tileIt = tiles.begin();
for (unsigned y = 0; y < iSize.height; y += TS) {
for (unsigned x = 0; x < iSize.width; x += TS) {
bool s = extractTileAndPalette(*tileIt, image, x, y, palette, colorsPerPalette, firstPalette, nPalettes);
if (!s) {
err.push_back({ TS, x, y, InvalidTileReason::NO_PALETTE_FOUND });
}
tileIt++;
}
}
assert(tileIt == tiles.end());
return tiles;
}
}
| [
"undisbeliever@gmail.com"
] | undisbeliever@gmail.com |
58f4bfa2ae2fb58677bcb7745a92dc56e7f45aaa | aa9c6b23ad708439c2553b2982bef9436c2c99b4 | /Source/Tokens/Globals/TGDate.cpp | 0129b1844293f338a965daf7bea21d67474ef95a | [] | no_license | Y-Less/yavascript | a07ba883380a81c86de2ed14416605b572284d30 | 4911c182d6b09fd46e67a61d6f080c4a97d0ca3f | refs/heads/master | 2021-01-19T07:43:26.120864 | 2013-06-01T20:07:42 | 2013-06-01T20:07:42 | 10,427,721 | 8 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 1,191 | cpp | // =========================================================================
// The contents of this file are subject to the Mozilla Public License
// Version 1.1 (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.mozilla.org/MPL/
//
// Software distributed under the License is distributed on an "AS IS"
// basis, WITHOUT WARRANTY OF ANY KIND, either express or implied. See the
// License for the specific language governing rights and limitations
// under the License.
//
// The Original Code is the yavascript development system - TGDate.cpp.
//
// The Initial Developer of the Original Code is Alex "Y_Less" Cole.
// =========================================================================
#include "TGDate.h"
| [
"alex@y-less.com"
] | alex@y-less.com |
8f3489e6b0095496c9678522c4ae26342f9cc072 | 0edfc6919ec7b1d1ec5fe41169304f28a4a98c6c | /main.cpp | b004a09adb0736f0d2855554710f97e722c85539 | [] | no_license | sanadtm/CS162 | 707825ef2af361f87a9be262330ac61e6879916d | ea00cf3cb19c675d37740536970cd9ea0b4e29b2 | refs/heads/master | 2023-03-08T04:39:51.940471 | 2021-02-26T04:15:31 | 2021-02-26T04:15:31 | 342,460,746 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,346 | cpp | // Sanad Thapa
// CS 162 - Program 5
//The purpose of the 5th program is to implement the new concepts learned which include linear linked lists.
//Our goal is to continue to create programs with a small main function that delegates to a series of functions where the real work takes place.
//Unlike the previous programs,this program should focus in on creating, modifying and removing data from a linear linked list.
#include "header.h"
int main()
{
list my_list;// Declaring the List variable;
int choice;
int res=0, len3=0;
//Declaring the required char variable
char favorite[SIZE], description[SIZE], how_often[SIZE];
char *search;
cout << "**********MENU**********\n";
cout << "1. ADD item to the LIST\n";
cout << "2. Search Item in the list AND DELETE IT \n";
cout << "3. DISPLAY ALL the Items \n";
cout << "4. Count ALL ITEMS\n";
cout << "5. Delete THE WHOLE LIST \n";
cout << "6. EXIT \n";
do{
cout << "Enter Choice :: \n";
cin >> choice;
cin.ignore();
switch(choice)
{
case 1:
// ADD ITEM in LINKED LIST
cout << "Enter you favorite thing to do \n";
cin.get(favorite,SIZE,'\n');
cin.ignore();
cout << "Enter Description for this\n";
cin.get(description,SIZE,'\n');
cin.ignore();
cout << "Enter HOw often do you want to do it\n";
cin.get(how_often,SIZE,'\n');
cin.ignore();
my_list.insert(favorite,description, how_often);
break;
case 2:
char s[SIZE];
// SEARCH FOR ITEM IN LINKED LIST to DELETE
cout << "Enter ACtivity TITLE to Delete \n";
cin.get(s,SIZE,'\n');
cin.ignore();
len3= strlen(s);
search = new char[len3+1];
strcpy(search, s);
my_list.search_delete(search);
break;
case 3:
// Display all the EXISTING ITEM
my_list.display_all();
break;
case 4:
// Counting Total Items in the LIST
res=my_list.cnt(); // Catching the value from te Function to a Variable
if(res == 0)
cout <<"There are NO items in the list to COUNT :: " << res <<endl;
else
cout << "Number of Items in the List:: " <<res <<endl;
break;
case 5:
// Delete all the items
my_list.delete_all();
break;
case 6:
cout << "Exiting PROGRAM!!! \n";
break;
default:
cout << "Invalid Input Enter Again\n";
break;
}
}while (choice !=6);
return 0;
}
| [
"sanad@babbage.cs.pdx.edu"
] | sanad@babbage.cs.pdx.edu |
06cb500203c83f6ee01c2b4b5d86b6a696a54d1e | 6e30d8bf61b216fddd1b9eb0c73486763dce7d67 | /WindowsKernel/ShadowDriver/PacketHelper.cpp | 90d405a54bfd35cdb83f84e4a5b06ffae65f1a8c | [] | no_license | XeonKHJ/ShadowDriver | c22039fa60a505fbf022bf691510d1ffba6875fc | b22dc3e9e7f8154976e2c5eb63db2da7bd4f4e0f | refs/heads/master | 2021-11-21T16:11:34.911088 | 2021-10-24T13:40:41 | 2021-10-24T13:40:41 | 249,103,890 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 666 | cpp | #include "PacketHelper.h"
#include "IOCTLHelper.h"
void PacketHelper::FilterFunc(NetLayer netLayer, NetPacketDirection direction, void* buffer, unsigned long long bufferSize, void * context)
{
UNREFERENCED_PARAMETER(direction);
UNREFERENCED_PARAMETER(netLayer);
auto helper = (IOCTLHelper*)context;
if (helper != nullptr)
{
char* outputBuffer = new char[bufferSize + sizeof(unsigned long long)];
RtlCopyMemory(outputBuffer, &bufferSize, sizeof(unsigned long long));
RtlCopyMemory(outputBuffer + sizeof(unsigned long long), buffer, bufferSize);
helper->NotifyUserApp(outputBuffer, bufferSize + sizeof(unsigned long long));
delete outputBuffer;
}
} | [
"redalertkhj@live.cn"
] | redalertkhj@live.cn |
7e31ecfbc3b0275fb9cd32a61a96c8b9c95b4a05 | 0b90d18bf8e2000d3c47a17f3403be51b4a8ecd8 | /src/Dataflow/Modules/Math/BuildNoiseColumnMatrix.cc | 8839209da0846c8e5254f145de08fb3093d05c9a | [
"MIT"
] | permissive | merced317/scirun4plus | c3d8d65dd68f9d119b43cf084ea8b9d94921ce33 | f29630e03d3cf13c0ce8b327676ad202e3981af0 | refs/heads/master | 2020-12-10T19:20:18.401161 | 2018-06-27T09:21:54 | 2018-06-27T09:21:54 | 233,683,375 | 0 | 0 | null | 2020-01-13T20:09:14 | 2020-01-13T20:09:13 | null | UTF-8 | C++ | false | false | 3,480 | cc | /*
For more information, please see: http://software.sci.utah.edu
The MIT License
Copyright (c) 2009 Scientific Computing and Imaging Institute,
University of Utah.
Permission is hereby granted, free of charge, to any person obtaining a
copy of this software 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:
The above copyright notice and this permission notice shall be included
in all copies or substantial portions of the Software.
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 AUTHORS 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.
*/
/*
* BuildNoiseColumnMatrix: Add BuildNoiseColumnMatrix to a matrix
*
* Written by:
* David Weinstein
* Department of Computer Science
* University of Utah
* June 1999
*
*/
#include <Core/Datatypes/ColumnMatrix.h>
#include <Core/Datatypes/DenseMatrix.h>
#include <Core/Datatypes/SparseRowMatrix.h>
#include <Dataflow/Network/Ports/MatrixPort.h>
#include <Dataflow/Network/Module.h>
#include <Dataflow/GuiInterface/GuiVar.h>
#include <Core/Math/MiscMath.h>
#include <Core/Math/MusilRNG.h>
#include <iostream>
#include <sstream>
namespace SCIRun {
class BuildNoiseColumnMatrix : public Module {
MusilRNG musil;
GuiDouble snr_;
public:
BuildNoiseColumnMatrix(GuiContext* ctx);
virtual ~BuildNoiseColumnMatrix();
virtual void execute();
};
DECLARE_MAKER(BuildNoiseColumnMatrix)
BuildNoiseColumnMatrix::BuildNoiseColumnMatrix(GuiContext* ctx)
: Module("BuildNoiseColumnMatrix", ctx, Filter,"Math", "SCIRun"),
snr_(get_ctx()->subVar("snr"), 10.0)
{
}
BuildNoiseColumnMatrix::~BuildNoiseColumnMatrix()
{
}
void
BuildNoiseColumnMatrix::execute()
{
update_state(NeedData);
MatrixHandle matH;
if (!get_input_handle("Signal", matH)) return;
// gotta make sure we have a Dense or Column matrix...
// ...if it's Sparse, change it to Dense
SparseRowMatrix *sm = dynamic_cast<SparseRowMatrix *>(matH.get_rep());
if (sm) matH = matH->dense();
else matH.detach();
double mean, power, sigma;
mean=power=sigma=0;
int r, c;
int nr = matH->nrows();
int nc = matH->ncols();
double curr;
double snr = snr_.get();
for (r=0; r<nr; r++)
for (c=0; c<nc; c++) {
curr = matH->get(r, c);
mean += curr;
}
mean /= nr*nc;
for (r=0; r<nr; r++)
for (c=0; c<nc; c++) {
curr = matH->get(r, c);
power += (curr-mean)*(curr-mean);
}
power /= nr*nc;
sigma = sqrt(power)/(snr*Sqrt(2*M_PI));
for (r=0; r<nr; r++)
{
for (c=0; c<nc; c++)
{
// Gaussian distribution about this percentage
const double rnd = 2.0 * musil() - 1.0;
double perturb = rnd * sigma * sqrt((-2.0 * log(rnd*rnd)) / (rnd*rnd));
matH->put(r, c, perturb);
}
}
send_output_handle("Noise", matH);
}
} // End namespace SCIRun
| [
"ppetrov@joker.umcutrecht.nl"
] | ppetrov@joker.umcutrecht.nl |
034a6338133cbbe2c196f97c1b515ff6f7c85327 | 931a8f1634feb32916cf20ac6cd28a3ee2830ba0 | /Native/System/Libraries/libpyro/gui/fontrequester/fonthandle.h | b5593ca0da4b45a34e7f102e8ee4633a57d78f42 | [] | no_license | PyroOS/Pyro | 2c4583bff246f80307fc722515c5e90668c00542 | ea709dc1f706c4dfc182d959df14696d604572f8 | refs/heads/master | 2021-01-10T19:47:17.787899 | 2012-04-15T12:20:14 | 2012-04-15T12:20:14 | 4,031,632 | 6 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,139 | h | // Sourcery -:- (C)opyright 2003-2004 Rick Caudill
//
// This 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, write to the Free Software
// Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
#ifndef FONT_HANDLE_H
#define FONT_HANDLE_H
#include <gui/font.h>
using namespace os;
/** \internal */
struct FontHandle {
char zFamilyName[FONT_FAMILY_LENGTH];
char zStyleName[FONT_STYLE_LENGTH];
uint32 nFlags;
float vSize;
float vShear;
float vRotation;
};
/** \internal */
static FontHandle* GetDefaultFontHandle()
{
FontHandle* pcHandle = new FontHandle;
font_properties sProp;
os::Font::GetDefaultFont(DEFAULT_FONT_FIXED,&sProp);
strcpy(pcHandle->zFamilyName,sProp.m_cFamily.c_str());
strcpy(pcHandle->zStyleName,sProp.m_cStyle.c_str());
pcHandle->vSize = sProp.m_vSize;
pcHandle->vShear = sProp.m_vShear;
pcHandle->vRotation = sProp.m_vRotation;
pcHandle->nFlags = sProp.m_nFlags;
return pcHandle;
}
/** \internal */
static font_properties GetFontProperties(FontHandle* pcHandle)
{
return (font_properties(pcHandle->zFamilyName,pcHandle->zStyleName,pcHandle->nFlags,pcHandle->vSize,pcHandle->vShear,pcHandle->vRotation));
}
/** \internal */
static FontHandle* GetNewFontHandle(FontHandle* pcHandle)
{
FontHandle* pcReturn=new FontHandle();
strcpy(pcReturn->zFamilyName,pcHandle->zFamilyName);
strcpy(pcReturn->zStyleName,pcHandle->zStyleName);
pcReturn->vSize = pcHandle->vSize;
pcReturn->vShear = pcHandle->vShear;
pcReturn->vRotation = pcHandle->vRotation;
pcReturn->nFlags = pcHandle->nFlags;
return pcReturn;
}
#endif //FONT_HANDLE_H
| [
"mail@pyro-os.org"
] | mail@pyro-os.org |
73bc440668a3dbb5317dc728e7c54f973993251f | ae2b328457a6df9dc967cda4e37878a4a48a7e79 | /Unity/iOS-Build/Classes/Native/Bulk_Generics_1.cpp | b4674d03c3521f9efd2b8b847f39d89a8f136b86 | [] | no_license | Adventure2Fitness/A2F_Mobile | 965e47902ebac76776e443b35b071a5a41044e10 | dea3966f9018c259cb2c5d03a2cfd7a5897ba78c | refs/heads/master | 2021-01-18T01:42:06.723267 | 2016-02-17T21:03:46 | 2016-02-17T21:03:46 | 51,940,762 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 586,180 | 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>
// System.Predicate`1<System.Object>
struct Predicate_1_t_1076464049_0;
// System.Object
struct Object_t;
// System.IAsyncResult
struct IAsyncResult_t_1647744885_0;
// System.AsyncCallback
struct AsyncCallback_t_266361018_0;
// System.Action`1<System.Object>
struct Action_1_t_715029990_0;
// System.Converter`2<System.Object,System.Object>
struct Converter_2_t1047945779_0;
// System.Collections.Generic.Comparer`1<System.Object>
struct Comparer_1_t_1127613549_0;
// System.Collections.Generic.Comparer`1/DefaultComparer<System.Object>
struct DefaultComparer_t_953866668_0;
// System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>
struct ReadOnlyCollection_1_t1311969555_0;
// System.Collections.Generic.IList`1<System.Object>
struct IList_1_t1166620943_0;
// System.Array
struct Array_t;
// System.Collections.IEnumerator
struct IEnumerator_t1412936761_0;
// System.Object[]
struct ObjectU5BU5D_t1774424924_0;
// System.Collections.Generic.IEnumerator`1<System.Object>
struct IEnumerator_1_t193337641_0;
// System.Collections.ObjectModel.Collection`1<System.Object>
struct Collection_1_t_731082539_0;
// System.Array/ArrayReadOnlyList`1<System.Object>
struct ArrayReadOnlyList_1_t_345512573_0;
// System.Exception
struct Exception_t2143823668_0;
// System.Array/ArrayReadOnlyList`1/<GetEnumerator>c__Iterator0<System.Object>
struct U3CGetEnumeratorU3Ec__Iterator0_t_696775629_0;
// System.Collections.Generic.Dictionary`2<System.Object,System.Int32>
struct Dictionary_2_t357803672_0;
// System.Collections.Generic.IEqualityComparer`1<System.Object>
struct IEqualityComparer_1_t_533356922_0;
// System.Runtime.Serialization.SerializationInfo
struct SerializationInfo_t526833679_0;
// System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>[]
struct KeyValuePair_2U5BU5D_t842258672_0;
// System.Collections.DictionaryEntry[]
struct DictionaryEntryU5BU5D_t_1171009526_0;
// System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Collections.DictionaryEntry>
struct Transform_1_t954325734_0;
// System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>
struct Transform_1_t_252603744_0;
// System.Collections.Generic.IEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>
struct IEnumerator_1_t303701525_0;
// System.Collections.IDictionaryEnumerator
struct IDictionaryEnumerator_t_855216337_0;
// System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Int32>
struct KeyCollection_t_1085388090_0;
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Int32>
struct ValueCollection_t1488631640_0;
// System.String
struct String_t;
// System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Object>
struct Transform_1_t1692641972_0;
// System.Collections.Generic.IEnumerator`1<System.Int32>
struct IEnumerator_1_t815623654_0;
// System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Int32>
struct Transform_1_t2110914299_0;
// System.Int32[]
struct Int32U5BU5D_t1872284309_0;
// System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Int32>
struct ShimEnumerator_t375085566_0;
// System.Collections.Generic.EqualityComparer`1<System.Int32>
struct EqualityComparer_1_t164988502_0;
// System.Collections.Generic.GenericEqualityComparer`1<System.Int32>
struct GenericEqualityComparer_1_t1098694295_0;
// System.Collections.Generic.EqualityComparer`1/DefaultComparer<System.Int32>
struct DefaultComparer_t1230637941_0;
// System.Collections.Generic.GenericComparer`1<System.Object>
struct GenericComparer_1_t2120948338_0;
// System.Collections.Generic.Dictionary`2<System.Object,System.Object>
struct Dictionary_2_t_1114179913_0;
// System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>[]
struct KeyValuePair_2U5BU5D_t_160275933_0;
// System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Collections.DictionaryEntry>
struct Transform_1_t1095225411_0;
// System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>
struct Transform_1_t1321960586_0;
// System.Collections.Generic.IEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>
struct IEnumerator_1_t393026776_0;
// System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Object>
struct KeyCollection_t1391515721_0;
// System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>
struct ValueCollection_t_418251273_0;
// System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Object>
struct Transform_1_t1919841591_0;
// System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Object>
struct ShimEnumerator_t_578441199_0;
// System.Collections.Generic.GenericEqualityComparer`1<System.Object>
struct GenericEqualityComparer_1_t378592920_0;
#include "class-internals.h"
#include "codegen/il2cpp-codegen.h"
#include "mscorlib_System_Array1621492670.h"
#include "mscorlib_System_Predicate_1_gen_1076464049.h"
#include "mscorlib_System_Predicate_1_gen_1076464049MethodDeclarations.h"
#include "mscorlib_System_IntPtr_1047952454.h"
#include "mscorlib_System_Void_224166001.h"
#include "mscorlib_System_Object_887538054.h"
#include "mscorlib_System_Boolean_19515315.h"
#include "mscorlib_System_AsyncCallback_266361018.h"
#include "mscorlib_System_Action_1_gen_715029990.h"
#include "mscorlib_System_Action_1_gen_715029990MethodDeclarations.h"
#include "mscorlib_System_Converter_2_gen1047945779.h"
#include "mscorlib_System_Converter_2_gen1047945779MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Comparer_1_ge_1127613549.h"
#include "mscorlib_System_Collections_Generic_Comparer_1_ge_1127613549MethodDeclarations.h"
#include "mscorlib_System_Object_887538054MethodDeclarations.h"
#include "mscorlib_System_Type_224215755MethodDeclarations.h"
#include "mscorlib_System_Activator866591226MethodDeclarations.h"
#include "mscorlib_System_Type_224215755.h"
#include "mscorlib_System_RuntimeTypeHandle_1394772513.h"
#include "mscorlib_ArrayTypes.h"
#include "mscorlib_System_Collections_Generic_Comparer_1_Def_953866668.h"
#include "mscorlib_System_Collections_Generic_Comparer_1_Def_953866668MethodDeclarations.h"
#include "mscorlib_System_Int321628762099.h"
#include "mscorlib_System_ArgumentException1159624695MethodDeclarations.h"
#include "mscorlib_System_ArgumentException1159624695.h"
#include "mscorlib_System_String_756155572.h"
#include "mscorlib_System_Collections_ObjectModel_ReadOnlyCo1311969555.h"
#include "mscorlib_System_Collections_ObjectModel_ReadOnlyCo1311969555MethodDeclarations.h"
#include "mscorlib_System_ArgumentNullException_1072101840MethodDeclarations.h"
#include "mscorlib_System_ArgumentNullException_1072101840.h"
#include "mscorlib_System_NotSupportedException1382227673MethodDeclarations.h"
#include "mscorlib_System_NotSupportedException1382227673.h"
#include "mscorlib_System_Collections_ObjectModel_Collection_731082539MethodDeclarations.h"
#include "mscorlib_System_Collections_ObjectModel_Collection_731082539.h"
#include "mscorlib_System_Collections_Generic_List_1_gen_71492158.h"
#include "mscorlib_System_Collections_Generic_List_1_gen_71492158MethodDeclarations.h"
#include "mscorlib_System_Array_ArrayReadOnlyList_1_gen_345512573.h"
#include "mscorlib_System_Array_ArrayReadOnlyList_1_gen_345512573MethodDeclarations.h"
#include "mscorlib_System_ArgumentOutOfRangeException_1011290529MethodDeclarations.h"
#include "mscorlib_System_ArgumentOutOfRangeException_1011290529.h"
#include "mscorlib_System_Exception2143823668.h"
#include "mscorlib_System_Array1621492670MethodDeclarations.h"
#include "mscorlib_System_Array_ArrayReadOnlyList_1_U3CGetEn_696775629.h"
#include "mscorlib_System_Array_ArrayReadOnlyList_1_U3CGetEn_696775629MethodDeclarations.h"
#include "mscorlib_System_UInt32_738719148.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen_1814435847.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen_1814435847MethodDeclarations.h"
#include "mscorlib_System_InvalidOperationException_523179548MethodDeclarations.h"
#include "mscorlib_System_InvalidOperationException_523179548.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen_1079392692.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen_1079392692MethodDeclarations.h"
#include "mscorlib_Mono_Globalization_Unicode_CodePointIndex1942381821.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_ge357803672.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_ge357803672MethodDeclarations.h"
#include "mscorlib_System_Runtime_Serialization_StreamingCo_1216992900.h"
#include "mscorlib_System_Runtime_Serialization_Serialization526833679.h"
#include "mscorlib_System_Collections_Generic_KeyValuePair_2_742775054.h"
#include "mscorlib_System_Collections_Generic_KeyValuePair_2_742775054MethodDeclarations.h"
#include "mscorlib_System_Collections_DictionaryEntry_1842557272.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_Tr954325734.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_Tr954325734MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_T_252603744.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_T_252603744MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2__1767787419.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2__1767787419MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_Sh375085566.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_Sh375085566MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_KeyNotFoundExce240136748MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Link976230437.h"
#include "mscorlib_System_Collections_Generic_KeyNotFoundExce240136748.h"
#include "mscorlib_System_Collections_Generic_EqualityCompar1498484409MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_EqualityCompar1498484409.h"
#include "mscorlib_System_Collections_Hashtable_2004451924MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_EqualityCompare164988502MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_EqualityCompare164988502.h"
#include "mscorlib_System_Runtime_Serialization_Serialization526833679MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2__1085388090.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2__1085388090MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_V1488631640.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_V1488631640MethodDeclarations.h"
#include "mscorlib_System_String_756155572MethodDeclarations.h"
#include "mscorlib_System_Collections_DictionaryEntry_1842557272MethodDeclarations.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen585243173.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen585243173MethodDeclarations.h"
#include "mscorlib_System_Int321628762099MethodDeclarations.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen1089936814.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen1089936814MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_Ke_62634121.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_T1692641972.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_T1692641972MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_Ke_62634121MethodDeclarations.h"
#include "mscorlib_System_ObjectDisposedException_1490685872MethodDeclarations.h"
#include "mscorlib_System_ObjectDisposedException_1490685872.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_V_596857947.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_T2110914299.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_T2110914299MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_V_596857947MethodDeclarations.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen_771082879.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen_771082879MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_EqualityCompar1230637941.h"
#include "mscorlib_System_Collections_Generic_EqualityCompar1230637941MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_GenericEqualit1098694295.h"
#include "mscorlib_System_Collections_Generic_GenericEqualit1098694295MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_CollectionDeb_1665083460.h"
#include "mscorlib_System_Collections_Generic_CollectionDeb_1665083460MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_CollectionDebu1333911017.h"
#include "mscorlib_System_Collections_Generic_CollectionDebu1333911017MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_GenericCompare2120948338.h"
#include "mscorlib_System_Collections_Generic_GenericCompare2120948338MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2__1114179913.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2__1114179913MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_KeyValuePair__2064968959.h"
#include "mscorlib_System_Collections_Generic_KeyValuePair__2064968959MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_T1095225411.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_T1095225411MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_T1321960586.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_T1321960586MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_E1711973002.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_E1711973002MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_S_578441199.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_S_578441199MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_K1391515721.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_K1391515721MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_V_418251273.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_V_418251273MethodDeclarations.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen530883272.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen530883272MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2__1262849608.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_T1919841591.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_T1919841591MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2__1262849608MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_V_643919030.h"
#include "mscorlib_System_Collections_Generic_Dictionary_2_V_643919030MethodDeclarations.h"
#include "mscorlib_System_Collections_Generic_GenericEquality378592920.h"
#include "mscorlib_System_Collections_Generic_GenericEquality378592920MethodDeclarations.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen1042047996.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen1042047996MethodDeclarations.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen1400405874.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen1400405874MethodDeclarations.h"
#include "mscorlib_System_Collections_Hashtable_Slot1363074209.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen1155067659.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen1155067659MethodDeclarations.h"
#include "mscorlib_System_Collections_SortedList_Slot20691934.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen399519576.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen399519576MethodDeclarations.h"
#include "mscorlib_System_Reflection_Emit_ILTokenInfo1935982065.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen1382438749.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen1382438749MethodDeclarations.h"
#include "mscorlib_System_Reflection_Emit_ILGenerator_Label_1204723828.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen_29285275.h"
#include "mscorlib_System_Array_InternalEnumerator_1_gen_29285275MethodDeclarations.h"
#include "mscorlib_System_Reflection_Emit_ILGenerator_LabelF1310356942.h"
// System.Int32 System.Array::IndexOf<System.Object>(!!0[],!!0)
extern "C" int32_t Array_IndexOf_TisObject_t_m_1633961791_0_gshared (Object_t * __this /* static, unused */, ObjectU5BU5D_t1774424924_0* p0, Object_t * p1, const MethodInfo* method);
#define Array_IndexOf_TisObject_t_m_1633961791_0(__this /* static, unused */, p0, p1, method) (( int32_t (*) (Object_t * /* static, unused */, ObjectU5BU5D_t1774424924_0*, Object_t *, const MethodInfo*))Array_IndexOf_TisObject_t_m_1633961791_0_gshared)(__this /* static, unused */, p0, p1, method)
// !!0 System.Array::InternalArray__get_Item<System.IntPtr>(System.Int32)
extern "C" IntPtr_t Array_InternalArray__get_Item_TisIntPtr_t_m1819425504_0_gshared (Array_t * __this, int32_t p0, const MethodInfo* method);
#define Array_InternalArray__get_Item_TisIntPtr_t_m1819425504_0(__this, p0, method) (( IntPtr_t (*) (Array_t *, int32_t, const MethodInfo*))Array_InternalArray__get_Item_TisIntPtr_t_m1819425504_0_gshared)(__this, p0, method)
// !!0 System.Array::InternalArray__get_Item<Mono.Globalization.Unicode.CodePointIndexer/TableRange>(System.Int32)
extern "C" TableRange_t1942381821_0 Array_InternalArray__get_Item_TisTableRange_t1942381821_0_m_940545047_0_gshared (Array_t * __this, int32_t p0, const MethodInfo* method);
#define Array_InternalArray__get_Item_TisTableRange_t1942381821_0_m_940545047_0(__this, p0, method) (( TableRange_t1942381821_0 (*) (Array_t *, int32_t, const MethodInfo*))Array_InternalArray__get_Item_TisTableRange_t1942381821_0_m_940545047_0_gshared)(__this, p0, method)
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Do_CopyTo<System.Collections.DictionaryEntry,System.Collections.DictionaryEntry>(!!1[],System.Int32,System.Collections.Generic.Dictionary`2/Transform`1<TKey,TValue,!!0>)
extern "C" void Dictionary_2_Do_CopyTo_TisDictionaryEntry_t_1842557272_0_TisDictionaryEntry_t_1842557272_0_m896136576_0_gshared (Dictionary_2_t357803672_0 * __this, DictionaryEntryU5BU5D_t_1171009526_0* p0, int32_t p1, Transform_1_t954325734_0 * p2, const MethodInfo* method);
#define Dictionary_2_Do_CopyTo_TisDictionaryEntry_t_1842557272_0_TisDictionaryEntry_t_1842557272_0_m896136576_0(__this, p0, p1, p2, method) (( void (*) (Dictionary_2_t357803672_0 *, DictionaryEntryU5BU5D_t_1171009526_0*, int32_t, Transform_1_t954325734_0 *, const MethodInfo*))Dictionary_2_Do_CopyTo_TisDictionaryEntry_t_1842557272_0_TisDictionaryEntry_t_1842557272_0_m896136576_0_gshared)(__this, p0, p1, p2, method)
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Do_ICollectionCopyTo<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>(System.Array,System.Int32,System.Collections.Generic.Dictionary`2/Transform`1<TKey,TValue,!!0>)
extern "C" void Dictionary_2_Do_ICollectionCopyTo_TisKeyValuePair_2_t742775054_0_m608407894_0_gshared (Dictionary_2_t357803672_0 * __this, Array_t * p0, int32_t p1, Transform_1_t_252603744_0 * p2, const MethodInfo* method);
#define Dictionary_2_Do_ICollectionCopyTo_TisKeyValuePair_2_t742775054_0_m608407894_0(__this, p0, p1, p2, method) (( void (*) (Dictionary_2_t357803672_0 *, Array_t *, int32_t, Transform_1_t_252603744_0 *, const MethodInfo*))Dictionary_2_Do_ICollectionCopyTo_TisKeyValuePair_2_t742775054_0_m608407894_0_gshared)(__this, p0, p1, p2, method)
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Do_CopyTo<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>,System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>(!!1[],System.Int32,System.Collections.Generic.Dictionary`2/Transform`1<TKey,TValue,!!0>)
extern "C" void Dictionary_2_Do_CopyTo_TisKeyValuePair_2_t742775054_0_TisKeyValuePair_2_t742775054_0_m_535349580_0_gshared (Dictionary_2_t357803672_0 * __this, KeyValuePair_2U5BU5D_t842258672_0* p0, int32_t p1, Transform_1_t_252603744_0 * p2, const MethodInfo* method);
#define Dictionary_2_Do_CopyTo_TisKeyValuePair_2_t742775054_0_TisKeyValuePair_2_t742775054_0_m_535349580_0(__this, p0, p1, p2, method) (( void (*) (Dictionary_2_t357803672_0 *, KeyValuePair_2U5BU5D_t842258672_0*, int32_t, Transform_1_t_252603744_0 *, const MethodInfo*))Dictionary_2_Do_CopyTo_TisKeyValuePair_2_t742775054_0_TisKeyValuePair_2_t742775054_0_m_535349580_0_gshared)(__this, p0, p1, p2, method)
// !!0 System.Array::InternalArray__get_Item<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>(System.Int32)
extern "C" KeyValuePair_2_t742775054_0 Array_InternalArray__get_Item_TisKeyValuePair_2_t742775054_0_m1457368332_0_gshared (Array_t * __this, int32_t p0, const MethodInfo* method);
#define Array_InternalArray__get_Item_TisKeyValuePair_2_t742775054_0_m1457368332_0(__this, p0, method) (( KeyValuePair_2_t742775054_0 (*) (Array_t *, int32_t, const MethodInfo*))Array_InternalArray__get_Item_TisKeyValuePair_2_t742775054_0_m1457368332_0_gshared)(__this, p0, method)
// !!0 System.Array::InternalArray__get_Item<System.Collections.Generic.Link>(System.Int32)
extern "C" Link_t976230437_0 Array_InternalArray__get_Item_TisLink_t976230437_0_m818406549_0_gshared (Array_t * __this, int32_t p0, const MethodInfo* method);
#define Array_InternalArray__get_Item_TisLink_t976230437_0_m818406549_0(__this, p0, method) (( Link_t976230437_0 (*) (Array_t *, int32_t, const MethodInfo*))Array_InternalArray__get_Item_TisLink_t976230437_0_m818406549_0_gshared)(__this, p0, method)
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Do_ICollectionCopyTo<System.Object>(System.Array,System.Int32,System.Collections.Generic.Dictionary`2/Transform`1<TKey,TValue,!!0>)
extern "C" void Dictionary_2_Do_ICollectionCopyTo_TisObject_t_m298980802_0_gshared (Dictionary_2_t357803672_0 * __this, Array_t * p0, int32_t p1, Transform_1_t1692641972_0 * p2, const MethodInfo* method);
#define Dictionary_2_Do_ICollectionCopyTo_TisObject_t_m298980802_0(__this, p0, p1, p2, method) (( void (*) (Dictionary_2_t357803672_0 *, Array_t *, int32_t, Transform_1_t1692641972_0 *, const MethodInfo*))Dictionary_2_Do_ICollectionCopyTo_TisObject_t_m298980802_0_gshared)(__this, p0, p1, p2, method)
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Do_CopyTo<System.Object,System.Object>(!!1[],System.Int32,System.Collections.Generic.Dictionary`2/Transform`1<TKey,TValue,!!0>)
extern "C" void Dictionary_2_Do_CopyTo_TisObject_t_TisObject_t_m_1068970020_0_gshared (Dictionary_2_t357803672_0 * __this, ObjectU5BU5D_t1774424924_0* p0, int32_t p1, Transform_1_t1692641972_0 * p2, const MethodInfo* method);
#define Dictionary_2_Do_CopyTo_TisObject_t_TisObject_t_m_1068970020_0(__this, p0, p1, p2, method) (( void (*) (Dictionary_2_t357803672_0 *, ObjectU5BU5D_t1774424924_0*, int32_t, Transform_1_t1692641972_0 *, const MethodInfo*))Dictionary_2_Do_CopyTo_TisObject_t_TisObject_t_m_1068970020_0_gshared)(__this, p0, p1, p2, method)
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Do_ICollectionCopyTo<System.Int32>(System.Array,System.Int32,System.Collections.Generic.Dictionary`2/Transform`1<TKey,TValue,!!0>)
extern "C" void Dictionary_2_Do_ICollectionCopyTo_TisInt32_t1628762099_0_m_235054257_0_gshared (Dictionary_2_t357803672_0 * __this, Array_t * p0, int32_t p1, Transform_1_t2110914299_0 * p2, const MethodInfo* method);
#define Dictionary_2_Do_ICollectionCopyTo_TisInt32_t1628762099_0_m_235054257_0(__this, p0, p1, p2, method) (( void (*) (Dictionary_2_t357803672_0 *, Array_t *, int32_t, Transform_1_t2110914299_0 *, const MethodInfo*))Dictionary_2_Do_ICollectionCopyTo_TisInt32_t1628762099_0_m_235054257_0_gshared)(__this, p0, p1, p2, method)
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Do_CopyTo<System.Int32,System.Int32>(!!1[],System.Int32,System.Collections.Generic.Dictionary`2/Transform`1<TKey,TValue,!!0>)
extern "C" void Dictionary_2_Do_CopyTo_TisInt32_t1628762099_0_TisInt32_t1628762099_0_m796686880_0_gshared (Dictionary_2_t357803672_0 * __this, Int32U5BU5D_t1872284309_0* p0, int32_t p1, Transform_1_t2110914299_0 * p2, const MethodInfo* method);
#define Dictionary_2_Do_CopyTo_TisInt32_t1628762099_0_TisInt32_t1628762099_0_m796686880_0(__this, p0, p1, p2, method) (( void (*) (Dictionary_2_t357803672_0 *, Int32U5BU5D_t1872284309_0*, int32_t, Transform_1_t2110914299_0 *, const MethodInfo*))Dictionary_2_Do_CopyTo_TisInt32_t1628762099_0_TisInt32_t1628762099_0_m796686880_0_gshared)(__this, p0, p1, p2, method)
// !!0 System.Array::InternalArray__get_Item<System.Collections.DictionaryEntry>(System.Int32)
extern "C" DictionaryEntry_t_1842557272_0 Array_InternalArray__get_Item_TisDictionaryEntry_t_1842557272_0_m297283038_0_gshared (Array_t * __this, int32_t p0, const MethodInfo* method);
#define Array_InternalArray__get_Item_TisDictionaryEntry_t_1842557272_0_m297283038_0(__this, p0, method) (( DictionaryEntry_t_1842557272_0 (*) (Array_t *, int32_t, const MethodInfo*))Array_InternalArray__get_Item_TisDictionaryEntry_t_1842557272_0_m297283038_0_gshared)(__this, p0, method)
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Do_CopyTo<System.Collections.DictionaryEntry,System.Collections.DictionaryEntry>(!!1[],System.Int32,System.Collections.Generic.Dictionary`2/Transform`1<TKey,TValue,!!0>)
extern "C" void Dictionary_2_Do_CopyTo_TisDictionaryEntry_t_1842557272_0_TisDictionaryEntry_t_1842557272_0_m_977614951_0_gshared (Dictionary_2_t_1114179913_0 * __this, DictionaryEntryU5BU5D_t_1171009526_0* p0, int32_t p1, Transform_1_t1095225411_0 * p2, const MethodInfo* method);
#define Dictionary_2_Do_CopyTo_TisDictionaryEntry_t_1842557272_0_TisDictionaryEntry_t_1842557272_0_m_977614951_0(__this, p0, p1, p2, method) (( void (*) (Dictionary_2_t_1114179913_0 *, DictionaryEntryU5BU5D_t_1171009526_0*, int32_t, Transform_1_t1095225411_0 *, const MethodInfo*))Dictionary_2_Do_CopyTo_TisDictionaryEntry_t_1842557272_0_TisDictionaryEntry_t_1842557272_0_m_977614951_0_gshared)(__this, p0, p1, p2, method)
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Do_ICollectionCopyTo<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>(System.Array,System.Int32,System.Collections.Generic.Dictionary`2/Transform`1<TKey,TValue,!!0>)
extern "C" void Dictionary_2_Do_ICollectionCopyTo_TisKeyValuePair_2_t_2064968959_0_m_1896833692_0_gshared (Dictionary_2_t_1114179913_0 * __this, Array_t * p0, int32_t p1, Transform_1_t1321960586_0 * p2, const MethodInfo* method);
#define Dictionary_2_Do_ICollectionCopyTo_TisKeyValuePair_2_t_2064968959_0_m_1896833692_0(__this, p0, p1, p2, method) (( void (*) (Dictionary_2_t_1114179913_0 *, Array_t *, int32_t, Transform_1_t1321960586_0 *, const MethodInfo*))Dictionary_2_Do_ICollectionCopyTo_TisKeyValuePair_2_t_2064968959_0_m_1896833692_0_gshared)(__this, p0, p1, p2, method)
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Do_CopyTo<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>,System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>(!!1[],System.Int32,System.Collections.Generic.Dictionary`2/Transform`1<TKey,TValue,!!0>)
extern "C" void Dictionary_2_Do_CopyTo_TisKeyValuePair_2_t_2064968959_0_TisKeyValuePair_2_t_2064968959_0_m_1258690119_0_gshared (Dictionary_2_t_1114179913_0 * __this, KeyValuePair_2U5BU5D_t_160275933_0* p0, int32_t p1, Transform_1_t1321960586_0 * p2, const MethodInfo* method);
#define Dictionary_2_Do_CopyTo_TisKeyValuePair_2_t_2064968959_0_TisKeyValuePair_2_t_2064968959_0_m_1258690119_0(__this, p0, p1, p2, method) (( void (*) (Dictionary_2_t_1114179913_0 *, KeyValuePair_2U5BU5D_t_160275933_0*, int32_t, Transform_1_t1321960586_0 *, const MethodInfo*))Dictionary_2_Do_CopyTo_TisKeyValuePair_2_t_2064968959_0_TisKeyValuePair_2_t_2064968959_0_m_1258690119_0_gshared)(__this, p0, p1, p2, method)
// !!0 System.Array::InternalArray__get_Item<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>(System.Int32)
extern "C" KeyValuePair_2_t_2064968959_0 Array_InternalArray__get_Item_TisKeyValuePair_2_t_2064968959_0_m1021495653_0_gshared (Array_t * __this, int32_t p0, const MethodInfo* method);
#define Array_InternalArray__get_Item_TisKeyValuePair_2_t_2064968959_0_m1021495653_0(__this, p0, method) (( KeyValuePair_2_t_2064968959_0 (*) (Array_t *, int32_t, const MethodInfo*))Array_InternalArray__get_Item_TisKeyValuePair_2_t_2064968959_0_m1021495653_0_gshared)(__this, p0, method)
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Do_ICollectionCopyTo<System.Object>(System.Array,System.Int32,System.Collections.Generic.Dictionary`2/Transform`1<TKey,TValue,!!0>)
extern "C" void Dictionary_2_Do_ICollectionCopyTo_TisObject_t_m_288770853_0_gshared (Dictionary_2_t_1114179913_0 * __this, Array_t * p0, int32_t p1, Transform_1_t1919841591_0 * p2, const MethodInfo* method);
#define Dictionary_2_Do_ICollectionCopyTo_TisObject_t_m_288770853_0(__this, p0, p1, p2, method) (( void (*) (Dictionary_2_t_1114179913_0 *, Array_t *, int32_t, Transform_1_t1919841591_0 *, const MethodInfo*))Dictionary_2_Do_ICollectionCopyTo_TisObject_t_m_288770853_0_gshared)(__this, p0, p1, p2, method)
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Do_CopyTo<System.Object,System.Object>(!!1[],System.Int32,System.Collections.Generic.Dictionary`2/Transform`1<TKey,TValue,!!0>)
extern "C" void Dictionary_2_Do_CopyTo_TisObject_t_TisObject_t_m1486840117_0_gshared (Dictionary_2_t_1114179913_0 * __this, ObjectU5BU5D_t1774424924_0* p0, int32_t p1, Transform_1_t1919841591_0 * p2, const MethodInfo* method);
#define Dictionary_2_Do_CopyTo_TisObject_t_TisObject_t_m1486840117_0(__this, p0, p1, p2, method) (( void (*) (Dictionary_2_t_1114179913_0 *, ObjectU5BU5D_t1774424924_0*, int32_t, Transform_1_t1919841591_0 *, const MethodInfo*))Dictionary_2_Do_CopyTo_TisObject_t_TisObject_t_m1486840117_0_gshared)(__this, p0, p1, p2, method)
// !!0 System.Array::InternalArray__get_Item<System.Boolean>(System.Int32)
extern "C" bool Array_InternalArray__get_Item_TisBoolean_t_19515315_0_m1243823257_0_gshared (Array_t * __this, int32_t p0, const MethodInfo* method);
#define Array_InternalArray__get_Item_TisBoolean_t_19515315_0_m1243823257_0(__this, p0, method) (( bool (*) (Array_t *, int32_t, const MethodInfo*))Array_InternalArray__get_Item_TisBoolean_t_19515315_0_m1243823257_0_gshared)(__this, p0, method)
// !!0 System.Array::InternalArray__get_Item<System.Collections.Hashtable/Slot>(System.Int32)
extern "C" Slot_t1363074209_0 Array_InternalArray__get_Item_TisSlot_t1363074209_0_m_1610641895_0_gshared (Array_t * __this, int32_t p0, const MethodInfo* method);
#define Array_InternalArray__get_Item_TisSlot_t1363074209_0_m_1610641895_0(__this, p0, method) (( Slot_t1363074209_0 (*) (Array_t *, int32_t, const MethodInfo*))Array_InternalArray__get_Item_TisSlot_t1363074209_0_m_1610641895_0_gshared)(__this, p0, method)
// !!0 System.Array::InternalArray__get_Item<System.Collections.SortedList/Slot>(System.Int32)
extern "C" Slot_t20691934_0 Array_InternalArray__get_Item_TisSlot_t20691934_0_m_2078904856_0_gshared (Array_t * __this, int32_t p0, const MethodInfo* method);
#define Array_InternalArray__get_Item_TisSlot_t20691934_0_m_2078904856_0(__this, p0, method) (( Slot_t20691934_0 (*) (Array_t *, int32_t, const MethodInfo*))Array_InternalArray__get_Item_TisSlot_t20691934_0_m_2078904856_0_gshared)(__this, p0, method)
// !!0 System.Array::InternalArray__get_Item<System.Reflection.Emit.ILTokenInfo>(System.Int32)
extern "C" ILTokenInfo_t1935982065_0 Array_InternalArray__get_Item_TisILTokenInfo_t1935982065_0_m1012704117_0_gshared (Array_t * __this, int32_t p0, const MethodInfo* method);
#define Array_InternalArray__get_Item_TisILTokenInfo_t1935982065_0_m1012704117_0(__this, p0, method) (( ILTokenInfo_t1935982065_0 (*) (Array_t *, int32_t, const MethodInfo*))Array_InternalArray__get_Item_TisILTokenInfo_t1935982065_0_m1012704117_0_gshared)(__this, p0, method)
// !!0 System.Array::InternalArray__get_Item<System.Reflection.Emit.ILGenerator/LabelData>(System.Int32)
extern "C" LabelData_t_1204723828_0 Array_InternalArray__get_Item_TisLabelData_t_1204723828_0_m64093434_0_gshared (Array_t * __this, int32_t p0, const MethodInfo* method);
#define Array_InternalArray__get_Item_TisLabelData_t_1204723828_0_m64093434_0(__this, p0, method) (( LabelData_t_1204723828_0 (*) (Array_t *, int32_t, const MethodInfo*))Array_InternalArray__get_Item_TisLabelData_t_1204723828_0_m64093434_0_gshared)(__this, p0, method)
// !!0 System.Array::InternalArray__get_Item<System.Reflection.Emit.ILGenerator/LabelFixup>(System.Int32)
extern "C" LabelFixup_t1310356942_0 Array_InternalArray__get_Item_TisLabelFixup_t1310356942_0_m_2039695796_0_gshared (Array_t * __this, int32_t p0, const MethodInfo* method);
#define Array_InternalArray__get_Item_TisLabelFixup_t1310356942_0_m_2039695796_0(__this, p0, method) (( LabelFixup_t1310356942_0 (*) (Array_t *, int32_t, const MethodInfo*))Array_InternalArray__get_Item_TisLabelFixup_t1310356942_0_m_2039695796_0_gshared)(__this, p0, method)
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Predicate`1<System.Object>::.ctor(System.Object,System.IntPtr)
extern "C" void Predicate_1__ctor_m982040097_0_gshared (Predicate_1_t_1076464049_0 * __this, Object_t * ___object, IntPtr_t ___method, const MethodInfo* method)
{
__this->___method_ptr_0 = (methodPointerType)((MethodInfo*)___method.___m_value_0)->method;
__this->___method_3 = ___method;
__this->___m_target_2 = ___object;
}
// System.Boolean System.Predicate`1<System.Object>::Invoke(T)
extern "C" bool Predicate_1_Invoke_m_188788987_0_gshared (Predicate_1_t_1076464049_0 * __this, Object_t * ___obj, const MethodInfo* method)
{
if(__this->___prev_9 != NULL)
{
Predicate_1_Invoke_m_188788987_0((Predicate_1_t_1076464049_0 *)__this->___prev_9,___obj, method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->___method_3.___m_value_0));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->___method_3.___m_value_0));
if (__this->___m_target_2 != NULL && ___methodIsStatic)
{
typedef bool (*FunctionPointerType) (Object_t *, Object_t * __this, Object_t * ___obj, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(NULL,__this->___m_target_2,___obj,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else if (__this->___m_target_2 != NULL || ___methodIsStatic)
{
typedef bool (*FunctionPointerType) (Object_t * __this, Object_t * ___obj, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(__this->___m_target_2,___obj,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else
{
typedef bool (*FunctionPointerType) (Object_t * __this, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(___obj,(MethodInfo*)(__this->___method_3.___m_value_0));
}
}
// System.IAsyncResult System.Predicate`1<System.Object>::BeginInvoke(T,System.AsyncCallback,System.Object)
extern "C" Object_t * Predicate_1_BeginInvoke_m2038073176_0_gshared (Predicate_1_t_1076464049_0 * __this, Object_t * ___obj, AsyncCallback_t_266361018_0 * ___callback, Object_t * ___object, const MethodInfo* method)
{
void *__d_args[2] = {0};
__d_args[0] = ___obj;
return (Object_t *)il2cpp_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback, (Il2CppObject*)___object);
}
// System.Boolean System.Predicate`1<System.Object>::EndInvoke(System.IAsyncResult)
extern "C" bool Predicate_1_EndInvoke_m_324470289_0_gshared (Predicate_1_t_1076464049_0 * __this, Object_t * ___result, const MethodInfo* method)
{
Il2CppObject *__result = il2cpp_delegate_end_invoke((Il2CppAsyncResult*) ___result, 0);
return *(bool*)UnBox ((Il2CppCodeGenObject*)__result);
}
// System.Void System.Action`1<System.Object>::.ctor(System.Object,System.IntPtr)
extern "C" void Action_1__ctor_m881151526_0_gshared (Action_1_t_715029990_0 * __this, Object_t * ___object, IntPtr_t ___method, const MethodInfo* method)
{
__this->___method_ptr_0 = (methodPointerType)((MethodInfo*)___method.___m_value_0)->method;
__this->___method_3 = ___method;
__this->___m_target_2 = ___object;
}
// System.Void System.Action`1<System.Object>::Invoke(T)
extern "C" void Action_1_Invoke_m663971678_0_gshared (Action_1_t_715029990_0 * __this, Object_t * ___obj, const MethodInfo* method)
{
if(__this->___prev_9 != NULL)
{
Action_1_Invoke_m663971678_0((Action_1_t_715029990_0 *)__this->___prev_9,___obj, method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->___method_3.___m_value_0));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->___method_3.___m_value_0));
if (__this->___m_target_2 != NULL && ___methodIsStatic)
{
typedef void (*FunctionPointerType) (Object_t *, Object_t * __this, Object_t * ___obj, const MethodInfo* method);
((FunctionPointerType)__this->___method_ptr_0)(NULL,__this->___m_target_2,___obj,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else if (__this->___m_target_2 != NULL || ___methodIsStatic)
{
typedef void (*FunctionPointerType) (Object_t * __this, Object_t * ___obj, const MethodInfo* method);
((FunctionPointerType)__this->___method_ptr_0)(__this->___m_target_2,___obj,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else
{
typedef void (*FunctionPointerType) (Object_t * __this, const MethodInfo* method);
((FunctionPointerType)__this->___method_ptr_0)(___obj,(MethodInfo*)(__this->___method_3.___m_value_0));
}
}
// System.IAsyncResult System.Action`1<System.Object>::BeginInvoke(T,System.AsyncCallback,System.Object)
extern "C" Object_t * Action_1_BeginInvoke_m917692971_0_gshared (Action_1_t_715029990_0 * __this, Object_t * ___obj, AsyncCallback_t_266361018_0 * ___callback, Object_t * ___object, const MethodInfo* method)
{
void *__d_args[2] = {0};
__d_args[0] = ___obj;
return (Object_t *)il2cpp_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback, (Il2CppObject*)___object);
}
// System.Void System.Action`1<System.Object>::EndInvoke(System.IAsyncResult)
extern "C" void Action_1_EndInvoke_m_732839114_0_gshared (Action_1_t_715029990_0 * __this, Object_t * ___result, const MethodInfo* method)
{
il2cpp_delegate_end_invoke((Il2CppAsyncResult*) ___result, 0);
}
// System.Void System.Converter`2<System.Object,System.Object>::.ctor(System.Object,System.IntPtr)
extern "C" void Converter_2__ctor_m15321797_0_gshared (Converter_2_t1047945779_0 * __this, Object_t * ___object, IntPtr_t ___method, const MethodInfo* method)
{
__this->___method_ptr_0 = (methodPointerType)((MethodInfo*)___method.___m_value_0)->method;
__this->___method_3 = ___method;
__this->___m_target_2 = ___object;
}
// TOutput System.Converter`2<System.Object,System.Object>::Invoke(TInput)
extern "C" Object_t * Converter_2_Invoke_m606895179_0_gshared (Converter_2_t1047945779_0 * __this, Object_t * ___input, const MethodInfo* method)
{
if(__this->___prev_9 != NULL)
{
Converter_2_Invoke_m606895179_0((Converter_2_t1047945779_0 *)__this->___prev_9,___input, method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->___method_3.___m_value_0));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->___method_3.___m_value_0));
if (__this->___m_target_2 != NULL && ___methodIsStatic)
{
typedef Object_t * (*FunctionPointerType) (Object_t *, Object_t * __this, Object_t * ___input, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(NULL,__this->___m_target_2,___input,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else if (__this->___m_target_2 != NULL || ___methodIsStatic)
{
typedef Object_t * (*FunctionPointerType) (Object_t * __this, Object_t * ___input, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(__this->___m_target_2,___input,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else
{
typedef Object_t * (*FunctionPointerType) (Object_t * __this, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(___input,(MethodInfo*)(__this->___method_3.___m_value_0));
}
}
// System.IAsyncResult System.Converter`2<System.Object,System.Object>::BeginInvoke(TInput,System.AsyncCallback,System.Object)
extern "C" Object_t * Converter_2_BeginInvoke_m_1162613208_0_gshared (Converter_2_t1047945779_0 * __this, Object_t * ___input, AsyncCallback_t_266361018_0 * ___callback, Object_t * ___object, const MethodInfo* method)
{
void *__d_args[2] = {0};
__d_args[0] = ___input;
return (Object_t *)il2cpp_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback, (Il2CppObject*)___object);
}
// TOutput System.Converter`2<System.Object,System.Object>::EndInvoke(System.IAsyncResult)
extern "C" Object_t * Converter_2_EndInvoke_m_421495337_0_gshared (Converter_2_t1047945779_0 * __this, Object_t * ___result, const MethodInfo* method)
{
Il2CppObject *__result = il2cpp_delegate_end_invoke((Il2CppAsyncResult*) ___result, 0);
return (Object_t *)__result;
}
// System.Void System.Collections.Generic.Comparer`1<System.Object>::.ctor()
extern "C" void Comparer_1__ctor_m453627619_0_gshared (Comparer_1_t_1127613549_0 * __this, const MethodInfo* method)
{
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Collections.Generic.Comparer`1<System.Object>::.cctor()
extern const Il2CppType* GenericComparer_1_t370888618_0_0_0_0_var;
extern TypeInfo* Type_t_il2cpp_TypeInfo_var;
extern TypeInfo* TypeU5BU5D_t_722972841_0_il2cpp_TypeInfo_var;
extern "C" void Comparer_1__cctor_m695458090_0_gshared (Object_t * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
GenericComparer_1_t370888618_0_0_0_0_var = il2cpp_codegen_type_from_index(2802);
Type_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(3);
TypeU5BU5D_t_722972841_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(57);
s_Il2CppMethodIntialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_0 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)), /*hidden argument*/NULL);
Type_t * L_1 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)), /*hidden argument*/NULL);
NullCheck((Type_t *)L_0);
bool L_2 = (bool)VirtFuncInvoker1< bool, Type_t * >::Invoke(40 /* System.Boolean System.Type::IsAssignableFrom(System.Type) */, (Type_t *)L_0, (Type_t *)L_1);
if (!L_2)
{
goto IL_0054;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_3 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(GenericComparer_1_t370888618_0_0_0_0_var), /*hidden argument*/NULL);
TypeU5BU5D_t_722972841_0* L_4 = (TypeU5BU5D_t_722972841_0*)((TypeU5BU5D_t_722972841_0*)SZArrayNew(TypeU5BU5D_t_722972841_0_il2cpp_TypeInfo_var, (uint32_t)1));
Type_t * L_5 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)), /*hidden argument*/NULL);
NullCheck(L_4);
IL2CPP_ARRAY_BOUNDS_CHECK(L_4, 0);
ArrayElementTypeCheck (L_4, L_5);
*((Type_t **)(Type_t **)SZArrayLdElema(L_4, 0, sizeof(Type_t *))) = (Type_t *)L_5;
NullCheck((Type_t *)L_3);
Type_t * L_6 = (Type_t *)VirtFuncInvoker1< Type_t *, TypeU5BU5D_t_722972841_0* >::Invoke(77 /* System.Type System.Type::MakeGenericType(System.Type[]) */, (Type_t *)L_3, (TypeU5BU5D_t_722972841_0*)L_4);
Object_t * L_7 = Activator_CreateInstance_m1399154923_0(NULL /*static, unused*/, (Type_t *)L_6, /*hidden argument*/NULL);
((Comparer_1_t_1127613549_0_StaticFields*)IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->static_fields)->____default_0 = ((Comparer_1_t_1127613549_0 *)Castclass(L_7, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)));
goto IL_005e;
}
IL_0054:
{
DefaultComparer_t_953866668_0 * L_8 = (DefaultComparer_t_953866668_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
(( void (*) (DefaultComparer_t_953866668_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)(L_8, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
((Comparer_1_t_1127613549_0_StaticFields*)IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->static_fields)->____default_0 = L_8;
}
IL_005e:
{
return;
}
}
// System.Int32 System.Collections.Generic.Comparer`1<System.Object>::System.Collections.IComparer.Compare(System.Object,System.Object)
extern TypeInfo* ArgumentException_t1159624695_0_il2cpp_TypeInfo_var;
extern "C" int32_t Comparer_1_System_Collections_IComparer_Compare_m1794290832_0_gshared (Comparer_1_t_1127613549_0 * __this, Object_t * ___x, Object_t * ___y, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentException_t1159624695_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(4);
s_Il2CppMethodIntialized = true;
}
int32_t G_B4_0 = 0;
{
Object_t * L_0 = ___x;
if (L_0)
{
goto IL_0014;
}
}
{
Object_t * L_1 = ___y;
if (L_1)
{
goto IL_0012;
}
}
{
G_B4_0 = 0;
goto IL_0013;
}
IL_0012:
{
G_B4_0 = (-1);
}
IL_0013:
{
return G_B4_0;
}
IL_0014:
{
Object_t * L_2 = ___y;
if (L_2)
{
goto IL_001c;
}
}
{
return 1;
}
IL_001c:
{
Object_t * L_3 = ___x;
if (!((Object_t *)IsInst(L_3, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6))))
{
goto IL_0045;
}
}
{
Object_t * L_4 = ___y;
if (!((Object_t *)IsInst(L_4, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6))))
{
goto IL_0045;
}
}
{
Object_t * L_5 = ___x;
Object_t * L_6 = ___y;
NullCheck((Comparer_1_t_1127613549_0 *)__this);
int32_t L_7 = (int32_t)VirtFuncInvoker2< int32_t, Object_t *, Object_t * >::Invoke(6 /* System.Int32 System.Collections.Generic.Comparer`1<System.Object>::Compare(T,T) */, (Comparer_1_t_1127613549_0 *)__this, (Object_t *)((Object_t *)Castclass(L_5, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6))), (Object_t *)((Object_t *)Castclass(L_6, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6))));
return L_7;
}
IL_0045:
{
ArgumentException_t1159624695_0 * L_8 = (ArgumentException_t1159624695_0 *)il2cpp_codegen_object_new (ArgumentException_t1159624695_0_il2cpp_TypeInfo_var);
ArgumentException__ctor_m571182463_0(L_8, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_8);
}
}
// System.Collections.Generic.Comparer`1<T> System.Collections.Generic.Comparer`1<System.Object>::get_Default()
extern "C" Comparer_1_t_1127613549_0 * Comparer_1_get_Default_m2088913959_0_gshared (Object_t * __this /* static, unused */, const MethodInfo* method)
{
{
IL2CPP_RUNTIME_CLASS_INIT(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
Comparer_1_t_1127613549_0 * L_0 = ((Comparer_1_t_1127613549_0_StaticFields*)IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->static_fields)->____default_0;
return L_0;
}
}
// System.Void System.Collections.Generic.Comparer`1/DefaultComparer<System.Object>::.ctor()
extern "C" void DefaultComparer__ctor_m86943554_0_gshared (DefaultComparer_t_953866668_0 * __this, const MethodInfo* method)
{
{
NullCheck((Comparer_1_t_1127613549_0 *)__this);
IL2CPP_RUNTIME_CLASS_INIT(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
(( void (*) (Comparer_1_t_1127613549_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Comparer_1_t_1127613549_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
return;
}
}
// System.Int32 System.Collections.Generic.Comparer`1/DefaultComparer<System.Object>::Compare(T,T)
extern TypeInfo* IComparable_t_2130417720_0_il2cpp_TypeInfo_var;
extern TypeInfo* ArgumentException_t1159624695_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_1891050300_0;
extern "C" int32_t DefaultComparer_Compare_m341753389_0_gshared (DefaultComparer_t_953866668_0 * __this, Object_t * ___x, Object_t * ___y, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
IComparable_t_2130417720_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(76);
ArgumentException_t1159624695_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(4);
_stringLiteral_1891050300_0 = il2cpp_codegen_string_literal_from_index(491);
s_Il2CppMethodIntialized = true;
}
int32_t G_B4_0 = 0;
{
Object_t * L_0 = ___x;
if (L_0)
{
goto IL_001e;
}
}
{
Object_t * L_1 = ___y;
if (L_1)
{
goto IL_001c;
}
}
{
G_B4_0 = 0;
goto IL_001d;
}
IL_001c:
{
G_B4_0 = (-1);
}
IL_001d:
{
return G_B4_0;
}
IL_001e:
{
Object_t * L_2 = ___y;
if (L_2)
{
goto IL_002b;
}
}
{
return 1;
}
IL_002b:
{
Object_t * L_3 = ___x;
if (!((Object_t*)IsInst(L_3, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3))))
{
goto IL_004d;
}
}
{
Object_t * L_4 = ___x;
Object_t * L_5 = ___y;
NullCheck((Object_t*)((Object_t*)Castclass(L_4, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3))));
int32_t L_6 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(0 /* System.Int32 System.IComparable`1<System.Object>::CompareTo(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3), (Object_t*)((Object_t*)Castclass(L_4, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3))), (Object_t *)L_5);
return L_6;
}
IL_004d:
{
Object_t * L_7 = ___x;
if (!((Object_t *)IsInst(L_7, IComparable_t_2130417720_0_il2cpp_TypeInfo_var)))
{
goto IL_0074;
}
}
{
Object_t * L_8 = ___x;
Object_t * L_9 = ___y;
NullCheck((Object_t *)((Object_t *)Castclass(L_8, IComparable_t_2130417720_0_il2cpp_TypeInfo_var)));
int32_t L_10 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(0 /* System.Int32 System.IComparable::CompareTo(System.Object) */, IComparable_t_2130417720_0_il2cpp_TypeInfo_var, (Object_t *)((Object_t *)Castclass(L_8, IComparable_t_2130417720_0_il2cpp_TypeInfo_var)), (Object_t *)L_9);
return L_10;
}
IL_0074:
{
ArgumentException_t1159624695_0 * L_11 = (ArgumentException_t1159624695_0 *)il2cpp_codegen_object_new (ArgumentException_t1159624695_0_il2cpp_TypeInfo_var);
ArgumentException__ctor_m_750110749_0(L_11, (String_t*)_stringLiteral_1891050300_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_11);
}
}
// System.Void System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::.ctor(System.Collections.Generic.IList`1<T>)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral3322014_0;
extern "C" void ReadOnlyCollection_1__ctor_m1366664402_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, Object_t* ___list, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral3322014_0 = il2cpp_codegen_string_literal_from_index(511);
s_Il2CppMethodIntialized = true;
}
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
Object_t* L_0 = ___list;
if (L_0)
{
goto IL_0017;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral3322014_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0017:
{
Object_t* L_2 = ___list;
__this->___list_0 = L_2;
return;
}
}
// System.Void System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.Generic.ICollection<T>.Add(T)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern "C" void ReadOnlyCollection_1_System_Collections_Generic_ICollectionU3CTU3E_Add_m_1753801284_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, Object_t * ___item, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m149930845_0(L_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Void System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.Generic.ICollection<T>.Clear()
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern "C" void ReadOnlyCollection_1_System_Collections_Generic_ICollectionU3CTU3E_Clear_m_821541234_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m149930845_0(L_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Void System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.Generic.IList<T>.Insert(System.Int32,T)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern "C" void ReadOnlyCollection_1_System_Collections_Generic_IListU3CTU3E_Insert_m_798579293_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, int32_t ___index, Object_t * ___item, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m149930845_0(L_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Boolean System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.Generic.ICollection<T>.Remove(T)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern "C" bool ReadOnlyCollection_1_System_Collections_Generic_ICollectionU3CTU3E_Remove_m348744375_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, Object_t * ___item, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m149930845_0(L_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Void System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.Generic.IList<T>.RemoveAt(System.Int32)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern "C" void ReadOnlyCollection_1_System_Collections_Generic_IListU3CTU3E_RemoveAt_m1370240873_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, int32_t ___index, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m149930845_0(L_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// T System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.Generic.IList<T>.get_Item(System.Int32)
extern "C" Object_t * ReadOnlyCollection_1_System_Collections_Generic_IListU3CTU3E_get_Item_m_760357971_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, int32_t ___index, const MethodInfo* method)
{
{
int32_t L_0 = ___index;
NullCheck((ReadOnlyCollection_1_t1311969555_0 *)__this);
Object_t * L_1 = (Object_t *)VirtFuncInvoker1< Object_t *, int32_t >::Invoke(30 /* T System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::get_Item(System.Int32) */, (ReadOnlyCollection_1_t1311969555_0 *)__this, (int32_t)L_0);
return L_1;
}
}
// System.Void System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.Generic.IList<T>.set_Item(System.Int32,T)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern "C" void ReadOnlyCollection_1_System_Collections_Generic_IListU3CTU3E_set_Item_m_1120925254_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, int32_t ___index, Object_t * ___value, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m149930845_0(L_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Boolean System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.Generic.ICollection<T>.get_IsReadOnly()
extern "C" bool ReadOnlyCollection_1_System_Collections_Generic_ICollectionU3CTU3E_get_IsReadOnly_m_1835391240_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, const MethodInfo* method)
{
{
return (bool)1;
}
}
// System.Void System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.ICollection.CopyTo(System.Array,System.Int32)
extern TypeInfo* ICollection_t592284435_0_il2cpp_TypeInfo_var;
extern "C" void ReadOnlyCollection_1_System_Collections_ICollection_CopyTo_m1945557633_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, Array_t * ___array, int32_t ___index, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ICollection_t592284435_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(184);
s_Il2CppMethodIntialized = true;
}
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
Array_t * L_1 = ___array;
int32_t L_2 = ___index;
NullCheck((Object_t *)((Object_t *)Castclass(L_0, ICollection_t592284435_0_il2cpp_TypeInfo_var)));
InterfaceActionInvoker2< Array_t *, int32_t >::Invoke(2 /* System.Void System.Collections.ICollection::CopyTo(System.Array,System.Int32) */, ICollection_t592284435_0_il2cpp_TypeInfo_var, (Object_t *)((Object_t *)Castclass(L_0, ICollection_t592284435_0_il2cpp_TypeInfo_var)), (Array_t *)L_1, (int32_t)L_2);
return;
}
}
// System.Collections.IEnumerator System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.IEnumerable.GetEnumerator()
extern TypeInfo* IEnumerable_t1412919357_0_il2cpp_TypeInfo_var;
extern "C" Object_t * ReadOnlyCollection_1_System_Collections_IEnumerable_GetEnumerator_m_964901828_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
IEnumerable_t1412919357_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(168);
s_Il2CppMethodIntialized = true;
}
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
NullCheck((Object_t *)L_0);
Object_t * L_1 = (Object_t *)InterfaceFuncInvoker0< Object_t * >::Invoke(0 /* System.Collections.IEnumerator System.Collections.IEnumerable::GetEnumerator() */, IEnumerable_t1412919357_0_il2cpp_TypeInfo_var, (Object_t *)L_0);
return L_1;
}
}
// System.Int32 System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.IList.Add(System.Object)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern "C" int32_t ReadOnlyCollection_1_System_Collections_IList_Add_m1628967861_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, Object_t * ___value, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m149930845_0(L_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Void System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.IList.Clear()
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern "C" void ReadOnlyCollection_1_System_Collections_IList_Clear_m514207119_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m149930845_0(L_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Boolean System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.IList.Contains(System.Object)
extern "C" bool ReadOnlyCollection_1_System_Collections_IList_Contains_m736178103_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___value;
bool L_1 = (( bool (*) (Object_t * /* static, unused */, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)(NULL /*static, unused*/, (Object_t *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
if (!L_1)
{
goto IL_001d;
}
}
{
Object_t* L_2 = (Object_t*)(__this->___list_0);
Object_t * L_3 = ___value;
NullCheck((Object_t*)L_2);
bool L_4 = (bool)InterfaceFuncInvoker1< bool, Object_t * >::Invoke(4 /* System.Boolean System.Collections.Generic.ICollection`1<System.Object>::Contains(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4), (Object_t*)L_2, (Object_t *)((Object_t *)Castclass(L_3, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3))));
return L_4;
}
IL_001d:
{
return (bool)0;
}
}
// System.Int32 System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.IList.IndexOf(System.Object)
extern "C" int32_t ReadOnlyCollection_1_System_Collections_IList_IndexOf_m_636655731_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___value;
bool L_1 = (( bool (*) (Object_t * /* static, unused */, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)(NULL /*static, unused*/, (Object_t *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
if (!L_1)
{
goto IL_001d;
}
}
{
Object_t* L_2 = (Object_t*)(__this->___list_0);
Object_t * L_3 = ___value;
NullCheck((Object_t*)L_2);
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(0 /* System.Int32 System.Collections.Generic.IList`1<System.Object>::IndexOf(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5), (Object_t*)L_2, (Object_t *)((Object_t *)Castclass(L_3, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3))));
return L_4;
}
IL_001d:
{
return (-1);
}
}
// System.Void System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.IList.Insert(System.Int32,System.Object)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern "C" void ReadOnlyCollection_1_System_Collections_IList_Insert_m_1471161032_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, int32_t ___index, Object_t * ___value, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m149930845_0(L_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Void System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.IList.Remove(System.Object)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern "C" void ReadOnlyCollection_1_System_Collections_IList_Remove_m_1796427536_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, Object_t * ___value, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m149930845_0(L_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Void System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.IList.RemoveAt(System.Int32)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern "C" void ReadOnlyCollection_1_System_Collections_IList_RemoveAt_m1730676936_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, int32_t ___index, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m149930845_0(L_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Object System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.ICollection.get_SyncRoot()
extern "C" Object_t * ReadOnlyCollection_1_System_Collections_ICollection_get_SyncRoot_m918746289_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, const MethodInfo* method)
{
{
return __this;
}
}
// System.Object System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.IList.get_Item(System.Int32)
extern "C" Object_t * ReadOnlyCollection_1_System_Collections_IList_get_Item_m_782467592_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, int32_t ___index, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
int32_t L_1 = ___index;
NullCheck((Object_t*)L_0);
Object_t * L_2 = (Object_t *)InterfaceFuncInvoker1< Object_t *, int32_t >::Invoke(3 /* T System.Collections.Generic.IList`1<System.Object>::get_Item(System.Int32) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5), (Object_t*)L_0, (int32_t)L_1);
return L_2;
}
}
// System.Void System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::System.Collections.IList.set_Item(System.Int32,System.Object)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern "C" void ReadOnlyCollection_1_System_Collections_IList_set_Item_m_127558897_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, int32_t ___index, Object_t * ___value, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m149930845_0(L_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Boolean System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::Contains(T)
extern "C" bool ReadOnlyCollection_1_Contains_m687553276_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, Object_t * ___value, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
Object_t * L_1 = ___value;
NullCheck((Object_t*)L_0);
bool L_2 = (bool)InterfaceFuncInvoker1< bool, Object_t * >::Invoke(4 /* System.Boolean System.Collections.Generic.ICollection`1<System.Object>::Contains(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4), (Object_t*)L_0, (Object_t *)L_1);
return L_2;
}
}
// System.Void System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::CopyTo(T[],System.Int32)
extern "C" void ReadOnlyCollection_1_CopyTo_m475587820_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, ObjectU5BU5D_t1774424924_0* ___array, int32_t ___index, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
ObjectU5BU5D_t1774424924_0* L_1 = ___array;
int32_t L_2 = ___index;
NullCheck((Object_t*)L_0);
InterfaceActionInvoker2< ObjectU5BU5D_t1774424924_0*, int32_t >::Invoke(5 /* System.Void System.Collections.Generic.ICollection`1<System.Object>::CopyTo(T[],System.Int32) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4), (Object_t*)L_0, (ObjectU5BU5D_t1774424924_0*)L_1, (int32_t)L_2);
return;
}
}
// System.Collections.Generic.IEnumerator`1<T> System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::GetEnumerator()
extern "C" Object_t* ReadOnlyCollection_1_GetEnumerator_m809369055_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
NullCheck((Object_t*)L_0);
Object_t* L_1 = (Object_t*)InterfaceFuncInvoker0< Object_t* >::Invoke(0 /* System.Collections.Generic.IEnumerator`1<T> System.Collections.Generic.IEnumerable`1<System.Object>::GetEnumerator() */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6), (Object_t*)L_0);
return L_1;
}
}
// System.Int32 System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::IndexOf(T)
extern "C" int32_t ReadOnlyCollection_1_IndexOf_m817393776_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, Object_t * ___value, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
Object_t * L_1 = ___value;
NullCheck((Object_t*)L_0);
int32_t L_2 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(0 /* System.Int32 System.Collections.Generic.IList`1<System.Object>::IndexOf(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5), (Object_t*)L_0, (Object_t *)L_1);
return L_2;
}
}
// System.Int32 System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::get_Count()
extern "C" int32_t ReadOnlyCollection_1_get_Count_m_613289205_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
NullCheck((Object_t*)L_0);
int32_t L_1 = (int32_t)InterfaceFuncInvoker0< int32_t >::Invoke(0 /* System.Int32 System.Collections.Generic.ICollection`1<System.Object>::get_Count() */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4), (Object_t*)L_0);
return L_1;
}
}
// T System.Collections.ObjectModel.ReadOnlyCollection`1<System.Object>::get_Item(System.Int32)
extern "C" Object_t * ReadOnlyCollection_1_get_Item_m_1873326099_0_gshared (ReadOnlyCollection_1_t1311969555_0 * __this, int32_t ___index, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
int32_t L_1 = ___index;
NullCheck((Object_t*)L_0);
Object_t * L_2 = (Object_t *)InterfaceFuncInvoker1< Object_t *, int32_t >::Invoke(3 /* T System.Collections.Generic.IList`1<System.Object>::get_Item(System.Int32) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5), (Object_t*)L_0, (int32_t)L_1);
return L_2;
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::.ctor()
extern TypeInfo* ICollection_t592284435_0_il2cpp_TypeInfo_var;
extern "C" void Collection_1__ctor_m1690372513_0_gshared (Collection_1_t_731082539_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ICollection_t592284435_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(184);
s_Il2CppMethodIntialized = true;
}
List_1_t_685623363_0 * V_0 = {0};
Object_t * V_1 = {0};
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
List_1_t_685623363_0 * L_0 = (List_1_t_685623363_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
(( void (*) (List_1_t_685623363_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
V_0 = (List_1_t_685623363_0 *)L_0;
List_1_t_685623363_0 * L_1 = V_0;
V_1 = (Object_t *)L_1;
Object_t * L_2 = V_1;
NullCheck((Object_t *)L_2);
Object_t * L_3 = (Object_t *)InterfaceFuncInvoker0< Object_t * >::Invoke(1 /* System.Object System.Collections.ICollection::get_SyncRoot() */, ICollection_t592284435_0_il2cpp_TypeInfo_var, (Object_t *)L_2);
__this->___syncRoot_1 = L_3;
List_1_t_685623363_0 * L_4 = V_0;
__this->___list_0 = L_4;
return;
}
}
// System.Boolean System.Collections.ObjectModel.Collection`1<System.Object>::System.Collections.Generic.ICollection<T>.get_IsReadOnly()
extern "C" bool Collection_1_System_Collections_Generic_ICollectionU3CTU3E_get_IsReadOnly_m1624016570_0_gshared (Collection_1_t_731082539_0 * __this, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
NullCheck((Object_t*)L_0);
bool L_1 = (bool)InterfaceFuncInvoker0< bool >::Invoke(1 /* System.Boolean System.Collections.Generic.ICollection`1<System.Object>::get_IsReadOnly() */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), (Object_t*)L_0);
return L_1;
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::System.Collections.ICollection.CopyTo(System.Array,System.Int32)
extern TypeInfo* ICollection_t592284435_0_il2cpp_TypeInfo_var;
extern "C" void Collection_1_System_Collections_ICollection_CopyTo_m1285013187_0_gshared (Collection_1_t_731082539_0 * __this, Array_t * ___array, int32_t ___index, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ICollection_t592284435_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(184);
s_Il2CppMethodIntialized = true;
}
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
Array_t * L_1 = ___array;
int32_t L_2 = ___index;
NullCheck((Object_t *)((Object_t *)Castclass(L_0, ICollection_t592284435_0_il2cpp_TypeInfo_var)));
InterfaceActionInvoker2< Array_t *, int32_t >::Invoke(2 /* System.Void System.Collections.ICollection::CopyTo(System.Array,System.Int32) */, ICollection_t592284435_0_il2cpp_TypeInfo_var, (Object_t *)((Object_t *)Castclass(L_0, ICollection_t592284435_0_il2cpp_TypeInfo_var)), (Array_t *)L_1, (int32_t)L_2);
return;
}
}
// System.Collections.IEnumerator System.Collections.ObjectModel.Collection`1<System.Object>::System.Collections.IEnumerable.GetEnumerator()
extern "C" Object_t * Collection_1_System_Collections_IEnumerable_GetEnumerator_m_1466496258_0_gshared (Collection_1_t_731082539_0 * __this, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
NullCheck((Object_t*)L_0);
Object_t* L_1 = (Object_t*)InterfaceFuncInvoker0< Object_t* >::Invoke(0 /* System.Collections.Generic.IEnumerator`1<T> System.Collections.Generic.IEnumerable`1<System.Object>::GetEnumerator() */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3), (Object_t*)L_0);
return L_1;
}
}
// System.Int32 System.Collections.ObjectModel.Collection`1<System.Object>::System.Collections.IList.Add(System.Object)
extern "C" int32_t Collection_1_System_Collections_IList_Add_m1708617267_0_gshared (Collection_1_t_731082539_0 * __this, Object_t * ___value, const MethodInfo* method)
{
int32_t V_0 = 0;
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
NullCheck((Object_t*)L_0);
int32_t L_1 = (int32_t)InterfaceFuncInvoker0< int32_t >::Invoke(0 /* System.Int32 System.Collections.Generic.ICollection`1<System.Object>::get_Count() */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), (Object_t*)L_0);
V_0 = (int32_t)L_1;
int32_t L_2 = V_0;
Object_t * L_3 = ___value;
Object_t * L_4 = (( Object_t * (*) (Object_t * /* static, unused */, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)(NULL /*static, unused*/, (Object_t *)L_3, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
NullCheck((Collection_1_t_731082539_0 *)__this);
VirtActionInvoker2< int32_t, Object_t * >::Invoke(31 /* System.Void System.Collections.ObjectModel.Collection`1<System.Object>::InsertItem(System.Int32,T) */, (Collection_1_t_731082539_0 *)__this, (int32_t)L_2, (Object_t *)L_4);
int32_t L_5 = V_0;
return L_5;
}
}
// System.Boolean System.Collections.ObjectModel.Collection`1<System.Object>::System.Collections.IList.Contains(System.Object)
extern "C" bool Collection_1_System_Collections_IList_Contains_m504494585_0_gshared (Collection_1_t_731082539_0 * __this, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___value;
bool L_1 = (( bool (*) (Object_t * /* static, unused */, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7)->method)(NULL /*static, unused*/, (Object_t *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7));
if (!L_1)
{
goto IL_001d;
}
}
{
Object_t* L_2 = (Object_t*)(__this->___list_0);
Object_t * L_3 = ___value;
NullCheck((Object_t*)L_2);
bool L_4 = (bool)InterfaceFuncInvoker1< bool, Object_t * >::Invoke(4 /* System.Boolean System.Collections.Generic.ICollection`1<System.Object>::Contains(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), (Object_t*)L_2, (Object_t *)((Object_t *)Castclass(L_3, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8))));
return L_4;
}
IL_001d:
{
return (bool)0;
}
}
// System.Int32 System.Collections.ObjectModel.Collection`1<System.Object>::System.Collections.IList.IndexOf(System.Object)
extern "C" int32_t Collection_1_System_Collections_IList_IndexOf_m1652511499_0_gshared (Collection_1_t_731082539_0 * __this, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___value;
bool L_1 = (( bool (*) (Object_t * /* static, unused */, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7)->method)(NULL /*static, unused*/, (Object_t *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7));
if (!L_1)
{
goto IL_001d;
}
}
{
Object_t* L_2 = (Object_t*)(__this->___list_0);
Object_t * L_3 = ___value;
NullCheck((Object_t*)L_2);
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(0 /* System.Int32 System.Collections.Generic.IList`1<System.Object>::IndexOf(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9), (Object_t*)L_2, (Object_t *)((Object_t *)Castclass(L_3, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8))));
return L_4;
}
IL_001d:
{
return (-1);
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::System.Collections.IList.Insert(System.Int32,System.Object)
extern "C" void Collection_1_System_Collections_IList_Insert_m_2107779146_0_gshared (Collection_1_t_731082539_0 * __this, int32_t ___index, Object_t * ___value, const MethodInfo* method)
{
{
int32_t L_0 = ___index;
Object_t * L_1 = ___value;
Object_t * L_2 = (( Object_t * (*) (Object_t * /* static, unused */, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)(NULL /*static, unused*/, (Object_t *)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
NullCheck((Collection_1_t_731082539_0 *)__this);
VirtActionInvoker2< int32_t, Object_t * >::Invoke(31 /* System.Void System.Collections.ObjectModel.Collection`1<System.Object>::InsertItem(System.Int32,T) */, (Collection_1_t_731082539_0 *)__this, (int32_t)L_0, (Object_t *)L_2);
return;
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::System.Collections.IList.Remove(System.Object)
extern "C" void Collection_1_System_Collections_IList_Remove_m_1669103182_0_gshared (Collection_1_t_731082539_0 * __this, Object_t * ___value, const MethodInfo* method)
{
int32_t V_0 = 0;
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
(( void (*) (Object_t * /* static, unused */, Object_t*, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)(NULL /*static, unused*/, (Object_t*)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
Object_t * L_1 = ___value;
Object_t * L_2 = (( Object_t * (*) (Object_t * /* static, unused */, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)(NULL /*static, unused*/, (Object_t *)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
NullCheck((Collection_1_t_731082539_0 *)__this);
int32_t L_3 = (int32_t)VirtFuncInvoker1< int32_t, Object_t * >::Invoke(25 /* System.Int32 System.Collections.ObjectModel.Collection`1<System.Object>::IndexOf(T) */, (Collection_1_t_731082539_0 *)__this, (Object_t *)L_2);
V_0 = (int32_t)L_3;
int32_t L_4 = V_0;
NullCheck((Collection_1_t_731082539_0 *)__this);
VirtActionInvoker1< int32_t >::Invoke(32 /* System.Void System.Collections.ObjectModel.Collection`1<System.Object>::RemoveItem(System.Int32) */, (Collection_1_t_731082539_0 *)__this, (int32_t)L_4);
return;
}
}
// System.Object System.Collections.ObjectModel.Collection`1<System.Object>::System.Collections.ICollection.get_SyncRoot()
extern "C" Object_t * Collection_1_System_Collections_ICollection_get_SyncRoot_m1873829551_0_gshared (Collection_1_t_731082539_0 * __this, const MethodInfo* method)
{
{
Object_t * L_0 = (Object_t *)(__this->___syncRoot_1);
return L_0;
}
}
// System.Object System.Collections.ObjectModel.Collection`1<System.Object>::System.Collections.IList.get_Item(System.Int32)
extern "C" Object_t * Collection_1_System_Collections_IList_get_Item_m_2070454154_0_gshared (Collection_1_t_731082539_0 * __this, int32_t ___index, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
int32_t L_1 = ___index;
NullCheck((Object_t*)L_0);
Object_t * L_2 = (Object_t *)InterfaceFuncInvoker1< Object_t *, int32_t >::Invoke(3 /* T System.Collections.Generic.IList`1<System.Object>::get_Item(System.Int32) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9), (Object_t*)L_0, (int32_t)L_1);
return L_2;
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::System.Collections.IList.set_Item(System.Int32,System.Object)
extern "C" void Collection_1_System_Collections_IList_set_Item_m_2032210419_0_gshared (Collection_1_t_731082539_0 * __this, int32_t ___index, Object_t * ___value, const MethodInfo* method)
{
{
int32_t L_0 = ___index;
Object_t * L_1 = ___value;
Object_t * L_2 = (( Object_t * (*) (Object_t * /* static, unused */, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)(NULL /*static, unused*/, (Object_t *)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
NullCheck((Collection_1_t_731082539_0 *)__this);
VirtActionInvoker2< int32_t, Object_t * >::Invoke(33 /* System.Void System.Collections.ObjectModel.Collection`1<System.Object>::SetItem(System.Int32,T) */, (Collection_1_t_731082539_0 *)__this, (int32_t)L_0, (Object_t *)L_2);
return;
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::Add(T)
extern "C" void Collection_1_Add_m321765054_0_gshared (Collection_1_t_731082539_0 * __this, Object_t * ___item, const MethodInfo* method)
{
int32_t V_0 = 0;
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
NullCheck((Object_t*)L_0);
int32_t L_1 = (int32_t)InterfaceFuncInvoker0< int32_t >::Invoke(0 /* System.Int32 System.Collections.Generic.ICollection`1<System.Object>::get_Count() */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), (Object_t*)L_0);
V_0 = (int32_t)L_1;
int32_t L_2 = V_0;
Object_t * L_3 = ___item;
NullCheck((Collection_1_t_731082539_0 *)__this);
VirtActionInvoker2< int32_t, Object_t * >::Invoke(31 /* System.Void System.Collections.ObjectModel.Collection`1<System.Object>::InsertItem(System.Int32,T) */, (Collection_1_t_731082539_0 *)__this, (int32_t)L_2, (Object_t *)L_3);
return;
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::Clear()
extern "C" void Collection_1_Clear_m_903494196_0_gshared (Collection_1_t_731082539_0 * __this, const MethodInfo* method)
{
{
NullCheck((Collection_1_t_731082539_0 *)__this);
VirtActionInvoker0::Invoke(30 /* System.Void System.Collections.ObjectModel.Collection`1<System.Object>::ClearItems() */, (Collection_1_t_731082539_0 *)__this);
return;
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::ClearItems()
extern "C" void Collection_1_ClearItems_m_1556768074_0_gshared (Collection_1_t_731082539_0 * __this, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
NullCheck((Object_t*)L_0);
InterfaceActionInvoker0::Invoke(3 /* System.Void System.Collections.Generic.ICollection`1<System.Object>::Clear() */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), (Object_t*)L_0);
return;
}
}
// System.Boolean System.Collections.ObjectModel.Collection`1<System.Object>::Contains(T)
extern "C" bool Collection_1_Contains_m1050871674_0_gshared (Collection_1_t_731082539_0 * __this, Object_t * ___item, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
Object_t * L_1 = ___item;
NullCheck((Object_t*)L_0);
bool L_2 = (bool)InterfaceFuncInvoker1< bool, Object_t * >::Invoke(4 /* System.Boolean System.Collections.Generic.ICollection`1<System.Object>::Contains(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), (Object_t*)L_0, (Object_t *)L_1);
return L_2;
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::CopyTo(T[],System.Int32)
extern "C" void Collection_1_CopyTo_m1746187054_0_gshared (Collection_1_t_731082539_0 * __this, ObjectU5BU5D_t1774424924_0* ___array, int32_t ___index, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
ObjectU5BU5D_t1774424924_0* L_1 = ___array;
int32_t L_2 = ___index;
NullCheck((Object_t*)L_0);
InterfaceActionInvoker2< ObjectU5BU5D_t1774424924_0*, int32_t >::Invoke(5 /* System.Void System.Collections.Generic.ICollection`1<System.Object>::CopyTo(T[],System.Int32) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), (Object_t*)L_0, (ObjectU5BU5D_t1774424924_0*)L_1, (int32_t)L_2);
return;
}
}
// System.Collections.Generic.IEnumerator`1<T> System.Collections.ObjectModel.Collection`1<System.Object>::GetEnumerator()
extern "C" Object_t* Collection_1_GetEnumerator_m625631581_0_gshared (Collection_1_t_731082539_0 * __this, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
NullCheck((Object_t*)L_0);
Object_t* L_1 = (Object_t*)InterfaceFuncInvoker0< Object_t* >::Invoke(0 /* System.Collections.Generic.IEnumerator`1<T> System.Collections.Generic.IEnumerable`1<System.Object>::GetEnumerator() */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3), (Object_t*)L_0);
return L_1;
}
}
// System.Int32 System.Collections.ObjectModel.Collection`1<System.Object>::IndexOf(T)
extern "C" int32_t Collection_1_IndexOf_m_1193519566_0_gshared (Collection_1_t_731082539_0 * __this, Object_t * ___item, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
Object_t * L_1 = ___item;
NullCheck((Object_t*)L_0);
int32_t L_2 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(0 /* System.Int32 System.Collections.Generic.IList`1<System.Object>::IndexOf(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9), (Object_t*)L_0, (Object_t *)L_1);
return L_2;
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::Insert(System.Int32,T)
extern "C" void Collection_1_Insert_m1208073509_0_gshared (Collection_1_t_731082539_0 * __this, int32_t ___index, Object_t * ___item, const MethodInfo* method)
{
{
int32_t L_0 = ___index;
Object_t * L_1 = ___item;
NullCheck((Collection_1_t_731082539_0 *)__this);
VirtActionInvoker2< int32_t, Object_t * >::Invoke(31 /* System.Void System.Collections.ObjectModel.Collection`1<System.Object>::InsertItem(System.Int32,T) */, (Collection_1_t_731082539_0 *)__this, (int32_t)L_0, (Object_t *)L_1);
return;
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::InsertItem(System.Int32,T)
extern "C" void Collection_1_InsertItem_m714854616_0_gshared (Collection_1_t_731082539_0 * __this, int32_t ___index, Object_t * ___item, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
int32_t L_1 = ___index;
Object_t * L_2 = ___item;
NullCheck((Object_t*)L_0);
InterfaceActionInvoker2< int32_t, Object_t * >::Invoke(1 /* System.Void System.Collections.Generic.IList`1<System.Object>::Insert(System.Int32,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9), (Object_t*)L_0, (int32_t)L_1, (Object_t *)L_2);
return;
}
}
// System.Boolean System.Collections.ObjectModel.Collection`1<System.Object>::Remove(T)
extern "C" bool Collection_1_Remove_m_2113446411_0_gshared (Collection_1_t_731082539_0 * __this, Object_t * ___item, const MethodInfo* method)
{
int32_t V_0 = 0;
{
Object_t * L_0 = ___item;
NullCheck((Collection_1_t_731082539_0 *)__this);
int32_t L_1 = (int32_t)VirtFuncInvoker1< int32_t, Object_t * >::Invoke(25 /* System.Int32 System.Collections.ObjectModel.Collection`1<System.Object>::IndexOf(T) */, (Collection_1_t_731082539_0 *)__this, (Object_t *)L_0);
V_0 = (int32_t)L_1;
int32_t L_2 = V_0;
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_0011;
}
}
{
return (bool)0;
}
IL_0011:
{
int32_t L_3 = V_0;
NullCheck((Collection_1_t_731082539_0 *)__this);
VirtActionInvoker1< int32_t >::Invoke(32 /* System.Void System.Collections.ObjectModel.Collection`1<System.Object>::RemoveItem(System.Int32) */, (Collection_1_t_731082539_0 *)__this, (int32_t)L_3);
return (bool)1;
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::RemoveAt(System.Int32)
extern "C" void Collection_1_RemoveAt_m_918073621_0_gshared (Collection_1_t_731082539_0 * __this, int32_t ___index, const MethodInfo* method)
{
{
int32_t L_0 = ___index;
NullCheck((Collection_1_t_731082539_0 *)__this);
VirtActionInvoker1< int32_t >::Invoke(32 /* System.Void System.Collections.ObjectModel.Collection`1<System.Object>::RemoveItem(System.Int32) */, (Collection_1_t_731082539_0 *)__this, (int32_t)L_0);
return;
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::RemoveItem(System.Int32)
extern "C" void Collection_1_RemoveItem_m1099170891_0_gshared (Collection_1_t_731082539_0 * __this, int32_t ___index, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
int32_t L_1 = ___index;
NullCheck((Object_t*)L_0);
InterfaceActionInvoker1< int32_t >::Invoke(2 /* System.Void System.Collections.Generic.IList`1<System.Object>::RemoveAt(System.Int32) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9), (Object_t*)L_0, (int32_t)L_1);
return;
}
}
// System.Int32 System.Collections.ObjectModel.Collection`1<System.Object>::get_Count()
extern "C" int32_t Collection_1_get_Count_m1472906633_0_gshared (Collection_1_t_731082539_0 * __this, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
NullCheck((Object_t*)L_0);
int32_t L_1 = (int32_t)InterfaceFuncInvoker0< int32_t >::Invoke(0 /* System.Int32 System.Collections.Generic.ICollection`1<System.Object>::get_Count() */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), (Object_t*)L_0);
return L_1;
}
}
// T System.Collections.ObjectModel.Collection`1<System.Object>::get_Item(System.Int32)
extern "C" Object_t * Collection_1_get_Item_m_1938606673_0_gshared (Collection_1_t_731082539_0 * __this, int32_t ___index, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
int32_t L_1 = ___index;
NullCheck((Object_t*)L_0);
Object_t * L_2 = (Object_t *)InterfaceFuncInvoker1< Object_t *, int32_t >::Invoke(3 /* T System.Collections.Generic.IList`1<System.Object>::get_Item(System.Int32) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9), (Object_t*)L_0, (int32_t)L_1);
return L_2;
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::set_Item(System.Int32,T)
extern "C" void Collection_1_set_Item_m_1167898436_0_gshared (Collection_1_t_731082539_0 * __this, int32_t ___index, Object_t * ___value, const MethodInfo* method)
{
{
int32_t L_0 = ___index;
Object_t * L_1 = ___value;
NullCheck((Collection_1_t_731082539_0 *)__this);
VirtActionInvoker2< int32_t, Object_t * >::Invoke(33 /* System.Void System.Collections.ObjectModel.Collection`1<System.Object>::SetItem(System.Int32,T) */, (Collection_1_t_731082539_0 *)__this, (int32_t)L_0, (Object_t *)L_1);
return;
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::SetItem(System.Int32,T)
extern "C" void Collection_1_SetItem_m112162877_0_gshared (Collection_1_t_731082539_0 * __this, int32_t ___index, Object_t * ___item, const MethodInfo* method)
{
{
Object_t* L_0 = (Object_t*)(__this->___list_0);
int32_t L_1 = ___index;
Object_t * L_2 = ___item;
NullCheck((Object_t*)L_0);
InterfaceActionInvoker2< int32_t, Object_t * >::Invoke(4 /* System.Void System.Collections.Generic.IList`1<System.Object>::set_Item(System.Int32,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9), (Object_t*)L_0, (int32_t)L_1, (Object_t *)L_2);
return;
}
}
// System.Boolean System.Collections.ObjectModel.Collection`1<System.Object>::IsValidItem(System.Object)
extern TypeInfo* Type_t_il2cpp_TypeInfo_var;
extern "C" bool Collection_1_IsValidItem_m1993492338_0_gshared (Object_t * __this /* static, unused */, Object_t * ___item, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
Type_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(3);
s_Il2CppMethodIntialized = true;
}
int32_t G_B4_0 = 0;
int32_t G_B6_0 = 0;
{
Object_t * L_0 = ___item;
if (((Object_t *)IsInst(L_0, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8))))
{
goto IL_0028;
}
}
{
Object_t * L_1 = ___item;
if (L_1)
{
goto IL_0025;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_2 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 15)), /*hidden argument*/NULL);
NullCheck((Type_t *)L_2);
bool L_3 = (bool)VirtFuncInvoker0< bool >::Invoke(33 /* System.Boolean System.Type::get_IsValueType() */, (Type_t *)L_2);
G_B4_0 = ((((int32_t)L_3) == ((int32_t)0))? 1 : 0);
goto IL_0026;
}
IL_0025:
{
G_B4_0 = 0;
}
IL_0026:
{
G_B6_0 = G_B4_0;
goto IL_0029;
}
IL_0028:
{
G_B6_0 = 1;
}
IL_0029:
{
return (bool)G_B6_0;
}
}
// T System.Collections.ObjectModel.Collection`1<System.Object>::ConvertItem(System.Object)
extern TypeInfo* ArgumentException_t1159624695_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral3242771_0;
extern "C" Object_t * Collection_1_ConvertItem_m1655469326_0_gshared (Object_t * __this /* static, unused */, Object_t * ___item, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentException_t1159624695_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(4);
_stringLiteral3242771_0 = il2cpp_codegen_string_literal_from_index(508);
s_Il2CppMethodIntialized = true;
}
{
Object_t * L_0 = ___item;
bool L_1 = (( bool (*) (Object_t * /* static, unused */, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7)->method)(NULL /*static, unused*/, (Object_t *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7));
if (!L_1)
{
goto IL_0012;
}
}
{
Object_t * L_2 = ___item;
return ((Object_t *)Castclass(L_2, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8)));
}
IL_0012:
{
ArgumentException_t1159624695_0 * L_3 = (ArgumentException_t1159624695_0 *)il2cpp_codegen_object_new (ArgumentException_t1159624695_0_il2cpp_TypeInfo_var);
ArgumentException__ctor_m_750110749_0(L_3, (String_t*)_stringLiteral3242771_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
}
// System.Void System.Collections.ObjectModel.Collection`1<System.Object>::CheckWritable(System.Collections.Generic.IList`1<T>)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern "C" void Collection_1_CheckWritable_m651250670_0_gshared (Object_t * __this /* static, unused */, Object_t* ___list, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
s_Il2CppMethodIntialized = true;
}
{
Object_t* L_0 = ___list;
NullCheck((Object_t*)L_0);
bool L_1 = (bool)InterfaceFuncInvoker0< bool >::Invoke(1 /* System.Boolean System.Collections.Generic.ICollection`1<System.Object>::get_IsReadOnly() */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), (Object_t*)L_0);
if (!L_1)
{
goto IL_0011;
}
}
{
NotSupportedException_t1382227673_0 * L_2 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m149930845_0(L_2, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_2);
}
IL_0011:
{
return;
}
}
// System.Void System.Array/ArrayReadOnlyList`1<System.Object>::.ctor(T[])
extern "C" void ArrayReadOnlyList_1__ctor_m240689135_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, ObjectU5BU5D_t1774424924_0* ___array, const MethodInfo* method)
{
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
ObjectU5BU5D_t1774424924_0* L_0 = ___array;
__this->___array_0 = L_0;
return;
}
}
// System.Collections.IEnumerator System.Array/ArrayReadOnlyList`1<System.Object>::System.Collections.IEnumerable.GetEnumerator()
extern "C" Object_t * ArrayReadOnlyList_1_System_Collections_IEnumerable_GetEnumerator_m_1795468090_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, const MethodInfo* method)
{
{
NullCheck((ArrayReadOnlyList_1_t_345512573_0 *)__this);
Object_t* L_0 = (Object_t*)VirtFuncInvoker0< Object_t* >::Invoke(17 /* System.Collections.Generic.IEnumerator`1<T> System.Array/ArrayReadOnlyList`1<System.Object>::GetEnumerator() */, (ArrayReadOnlyList_1_t_345512573_0 *)__this);
return L_0;
}
}
// T System.Array/ArrayReadOnlyList`1<System.Object>::get_Item(System.Int32)
extern TypeInfo* ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral100346066_0;
extern "C" Object_t * ArrayReadOnlyList_1_get_Item_m535939909_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, int32_t ___index, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(27);
_stringLiteral100346066_0 = il2cpp_codegen_string_literal_from_index(146);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = ___index;
ObjectU5BU5D_t1774424924_0* L_1 = (ObjectU5BU5D_t1774424924_0*)(__this->___array_0);
NullCheck(L_1);
if ((!(((uint32_t)L_0) >= ((uint32_t)(((int32_t)((int32_t)(((Array_t *)L_1)->max_length))))))))
{
goto IL_0019;
}
}
{
ArgumentOutOfRangeException_t_1011290529_0 * L_2 = (ArgumentOutOfRangeException_t_1011290529_0 *)il2cpp_codegen_object_new (ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m2026296331_0(L_2, (String_t*)_stringLiteral100346066_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_2);
}
IL_0019:
{
ObjectU5BU5D_t1774424924_0* L_3 = (ObjectU5BU5D_t1774424924_0*)(__this->___array_0);
int32_t L_4 = ___index;
NullCheck(L_3);
IL2CPP_ARRAY_BOUNDS_CHECK(L_3, L_4);
int32_t L_5 = L_4;
return (*(Object_t **)(Object_t **)SZArrayLdElema(L_3, L_5, sizeof(Object_t *)));
}
}
// System.Void System.Array/ArrayReadOnlyList`1<System.Object>::set_Item(System.Int32,T)
extern "C" void ArrayReadOnlyList_1_set_Item_m_1669592592_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, int32_t ___index, Object_t * ___value, const MethodInfo* method)
{
{
Exception_t2143823668_0 * L_0 = (( Exception_t2143823668_0 * (*) (Object_t * /* static, unused */, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)(NULL /*static, unused*/, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Int32 System.Array/ArrayReadOnlyList`1<System.Object>::get_Count()
extern "C" int32_t ArrayReadOnlyList_1_get_Count_m_481518195_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, const MethodInfo* method)
{
{
ObjectU5BU5D_t1774424924_0* L_0 = (ObjectU5BU5D_t1774424924_0*)(__this->___array_0);
NullCheck(L_0);
return (((int32_t)((int32_t)(((Array_t *)L_0)->max_length))));
}
}
// System.Boolean System.Array/ArrayReadOnlyList`1<System.Object>::get_IsReadOnly()
extern "C" bool ArrayReadOnlyList_1_get_IsReadOnly_m1486920810_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, const MethodInfo* method)
{
{
return (bool)1;
}
}
// System.Void System.Array/ArrayReadOnlyList`1<System.Object>::Add(T)
extern "C" void ArrayReadOnlyList_1_Add_m976758002_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, Object_t * ___item, const MethodInfo* method)
{
{
Exception_t2143823668_0 * L_0 = (( Exception_t2143823668_0 * (*) (Object_t * /* static, unused */, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)(NULL /*static, unused*/, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Void System.Array/ArrayReadOnlyList`1<System.Object>::Clear()
extern "C" void ArrayReadOnlyList_1_Clear_m_2073549288_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, const MethodInfo* method)
{
{
Exception_t2143823668_0 * L_0 = (( Exception_t2143823668_0 * (*) (Object_t * /* static, unused */, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)(NULL /*static, unused*/, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Boolean System.Array/ArrayReadOnlyList`1<System.Object>::Contains(T)
extern "C" bool ArrayReadOnlyList_1_Contains_m158553866_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, Object_t * ___item, const MethodInfo* method)
{
{
ObjectU5BU5D_t1774424924_0* L_0 = (ObjectU5BU5D_t1774424924_0*)(__this->___array_0);
Object_t * L_1 = ___item;
int32_t L_2 = (( int32_t (*) (Object_t * /* static, unused */, ObjectU5BU5D_t1774424924_0*, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)(NULL /*static, unused*/, (ObjectU5BU5D_t1774424924_0*)L_0, (Object_t *)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
return (bool)((((int32_t)((((int32_t)L_2) < ((int32_t)0))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
}
// System.Void System.Array/ArrayReadOnlyList`1<System.Object>::CopyTo(T[],System.Int32)
extern "C" void ArrayReadOnlyList_1_CopyTo_m1244492898_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, ObjectU5BU5D_t1774424924_0* ___array, int32_t ___index, const MethodInfo* method)
{
{
ObjectU5BU5D_t1774424924_0* L_0 = (ObjectU5BU5D_t1774424924_0*)(__this->___array_0);
ObjectU5BU5D_t1774424924_0* L_1 = ___array;
int32_t L_2 = ___index;
NullCheck((Array_t *)L_0);
VirtActionInvoker2< Array_t *, int32_t >::Invoke(8 /* System.Void System.Array::CopyTo(System.Array,System.Int32) */, (Array_t *)L_0, (Array_t *)(Array_t *)L_1, (int32_t)L_2);
return;
}
}
// System.Collections.Generic.IEnumerator`1<T> System.Array/ArrayReadOnlyList`1<System.Object>::GetEnumerator()
extern "C" Object_t* ArrayReadOnlyList_1_GetEnumerator_m1770413409_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, const MethodInfo* method)
{
U3CGetEnumeratorU3Ec__Iterator0_t_696775629_0 * V_0 = {0};
{
U3CGetEnumeratorU3Ec__Iterator0_t_696775629_0 * L_0 = (U3CGetEnumeratorU3Ec__Iterator0_t_696775629_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
(( void (*) (U3CGetEnumeratorU3Ec__Iterator0_t_696775629_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)(L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
V_0 = (U3CGetEnumeratorU3Ec__Iterator0_t_696775629_0 *)L_0;
U3CGetEnumeratorU3Ec__Iterator0_t_696775629_0 * L_1 = V_0;
NullCheck(L_1);
L_1->___U3CU3Ef__this_3 = __this;
U3CGetEnumeratorU3Ec__Iterator0_t_696775629_0 * L_2 = V_0;
return L_2;
}
}
// System.Int32 System.Array/ArrayReadOnlyList`1<System.Object>::IndexOf(T)
extern "C" int32_t ArrayReadOnlyList_1_IndexOf_m1098739118_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, Object_t * ___item, const MethodInfo* method)
{
{
ObjectU5BU5D_t1774424924_0* L_0 = (ObjectU5BU5D_t1774424924_0*)(__this->___array_0);
Object_t * L_1 = ___item;
int32_t L_2 = (( int32_t (*) (Object_t * /* static, unused */, ObjectU5BU5D_t1774424924_0*, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)(NULL /*static, unused*/, (ObjectU5BU5D_t1774424924_0*)L_0, (Object_t *)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
return L_2;
}
}
// System.Void System.Array/ArrayReadOnlyList`1<System.Object>::Insert(System.Int32,T)
extern "C" void ArrayReadOnlyList_1_Insert_m738278233_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, int32_t ___index, Object_t * ___item, const MethodInfo* method)
{
{
Exception_t2143823668_0 * L_0 = (( Exception_t2143823668_0 * (*) (Object_t * /* static, unused */, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)(NULL /*static, unused*/, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Boolean System.Array/ArrayReadOnlyList`1<System.Object>::Remove(T)
extern "C" bool ArrayReadOnlyList_1_Remove_m12996997_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, Object_t * ___item, const MethodInfo* method)
{
{
Exception_t2143823668_0 * L_0 = (( Exception_t2143823668_0 * (*) (Object_t * /* static, unused */, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)(NULL /*static, unused*/, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Void System.Array/ArrayReadOnlyList`1<System.Object>::RemoveAt(System.Int32)
extern "C" void ArrayReadOnlyList_1_RemoveAt_m_1387868897_0_gshared (ArrayReadOnlyList_1_t_345512573_0 * __this, int32_t ___index, const MethodInfo* method)
{
{
Exception_t2143823668_0 * L_0 = (( Exception_t2143823668_0 * (*) (Object_t * /* static, unused */, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)(NULL /*static, unused*/, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Exception System.Array/ArrayReadOnlyList`1<System.Object>::ReadOnlyError()
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral823020769_0;
extern "C" Exception_t2143823668_0 * ArrayReadOnlyList_1_ReadOnlyError_m740547916_0_gshared (Object_t * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
_stringLiteral823020769_0 = il2cpp_codegen_string_literal_from_index(197);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m133757637_0(L_0, (String_t*)_stringLiteral823020769_0, /*hidden argument*/NULL);
return L_0;
}
}
// System.Void System.Array/ArrayReadOnlyList`1/<GetEnumerator>c__Iterator0<System.Object>::.ctor()
extern "C" void U3CGetEnumeratorU3Ec__Iterator0__ctor_m_32889923_0_gshared (U3CGetEnumeratorU3Ec__Iterator0_t_696775629_0 * __this, const MethodInfo* method)
{
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
return;
}
}
// T System.Array/ArrayReadOnlyList`1/<GetEnumerator>c__Iterator0<System.Object>::System.Collections.Generic.IEnumerator<T>.get_Current()
extern "C" Object_t * U3CGetEnumeratorU3Ec__Iterator0_System_Collections_Generic_IEnumeratorU3CTU3E_get_Current_m_2090440828_0_gshared (U3CGetEnumeratorU3Ec__Iterator0_t_696775629_0 * __this, const MethodInfo* method)
{
{
Object_t * L_0 = (Object_t *)(__this->___U24current_2);
return L_0;
}
}
// System.Object System.Array/ArrayReadOnlyList`1/<GetEnumerator>c__Iterator0<System.Object>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * U3CGetEnumeratorU3Ec__Iterator0_System_Collections_IEnumerator_get_Current_m_240698615_0_gshared (U3CGetEnumeratorU3Ec__Iterator0_t_696775629_0 * __this, const MethodInfo* method)
{
{
Object_t * L_0 = (Object_t *)(__this->___U24current_2);
return L_0;
}
}
// System.Boolean System.Array/ArrayReadOnlyList`1/<GetEnumerator>c__Iterator0<System.Object>::MoveNext()
extern "C" bool U3CGetEnumeratorU3Ec__Iterator0_MoveNext_m_93025527_0_gshared (U3CGetEnumeratorU3Ec__Iterator0_t_696775629_0 * __this, const MethodInfo* method)
{
uint32_t V_0 = 0;
bool V_1 = false;
{
int32_t L_0 = (int32_t)(__this->___U24PC_1);
V_0 = (uint32_t)L_0;
__this->___U24PC_1 = (-1);
uint32_t L_1 = V_0;
if (L_1 == 0)
{
goto IL_0021;
}
if (L_1 == 1)
{
goto IL_0055;
}
}
{
goto IL_0082;
}
IL_0021:
{
__this->___U3CiU3E__0_0 = 0;
goto IL_0063;
}
IL_002d:
{
ArrayReadOnlyList_1_t_345512573_0 * L_2 = (ArrayReadOnlyList_1_t_345512573_0 *)(__this->___U3CU3Ef__this_3);
NullCheck(L_2);
ObjectU5BU5D_t1774424924_0* L_3 = (ObjectU5BU5D_t1774424924_0*)(L_2->___array_0);
int32_t L_4 = (int32_t)(__this->___U3CiU3E__0_0);
NullCheck(L_3);
IL2CPP_ARRAY_BOUNDS_CHECK(L_3, L_4);
int32_t L_5 = L_4;
__this->___U24current_2 = (*(Object_t **)(Object_t **)SZArrayLdElema(L_3, L_5, sizeof(Object_t *)));
__this->___U24PC_1 = 1;
goto IL_0084;
}
IL_0055:
{
int32_t L_6 = (int32_t)(__this->___U3CiU3E__0_0);
__this->___U3CiU3E__0_0 = ((int32_t)((int32_t)L_6+(int32_t)1));
}
IL_0063:
{
int32_t L_7 = (int32_t)(__this->___U3CiU3E__0_0);
ArrayReadOnlyList_1_t_345512573_0 * L_8 = (ArrayReadOnlyList_1_t_345512573_0 *)(__this->___U3CU3Ef__this_3);
NullCheck(L_8);
ObjectU5BU5D_t1774424924_0* L_9 = (ObjectU5BU5D_t1774424924_0*)(L_8->___array_0);
NullCheck(L_9);
if ((((int32_t)L_7) < ((int32_t)(((int32_t)((int32_t)(((Array_t *)L_9)->max_length)))))))
{
goto IL_002d;
}
}
{
__this->___U24PC_1 = (-1);
}
IL_0082:
{
return (bool)0;
}
IL_0084:
{
return (bool)1;
}
// Dead block : IL_0086: ldloc.1
}
// System.Void System.Array/ArrayReadOnlyList`1/<GetEnumerator>c__Iterator0<System.Object>::Dispose()
extern "C" void U3CGetEnumeratorU3Ec__Iterator0_Dispose_m_1644161862_0_gshared (U3CGetEnumeratorU3Ec__Iterator0_t_696775629_0 * __this, const MethodInfo* method)
{
{
__this->___U24PC_1 = (-1);
return;
}
}
// System.Void System.Array/ArrayReadOnlyList`1/<GetEnumerator>c__Iterator0<System.Object>::Reset()
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern "C" void U3CGetEnumeratorU3Ec__Iterator0_Reset_m1908510314_0_gshared (U3CGetEnumeratorU3Ec__Iterator0_t_696775629_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m149930845_0(L_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Void System.Array/InternalEnumerator`1<System.IntPtr>::.ctor(System.Array)
extern "C" void InternalEnumerator_1__ctor_m152804899_0_gshared (InternalEnumerator_1_t_1814435847_0 * __this, Array_t * ___array, const MethodInfo* method)
{
{
Array_t * L_0 = ___array;
__this->___array_0 = L_0;
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Void System.Array/InternalEnumerator`1<System.IntPtr>::System.Collections.IEnumerator.Reset()
extern "C" void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m_1396562275_0_gshared (InternalEnumerator_1_t_1814435847_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Object System.Array/InternalEnumerator`1<System.IntPtr>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1126443155_0_gshared (InternalEnumerator_1_t_1814435847_0 * __this, const MethodInfo* method)
{
{
IntPtr_t L_0 = (( IntPtr_t (*) (InternalEnumerator_1_t_1814435847_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((InternalEnumerator_1_t_1814435847_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
IntPtr_t L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array/InternalEnumerator`1<System.IntPtr>::Dispose()
extern "C" void InternalEnumerator_1_Dispose_m1686038458_0_gshared (InternalEnumerator_1_t_1814435847_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Boolean System.Array/InternalEnumerator`1<System.IntPtr>::MoveNext()
extern "C" bool InternalEnumerator_1_MoveNext_m467683661_0_gshared (InternalEnumerator_1_t_1814435847_0 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t G_B5_0 = 0;
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001e;
}
}
{
Array_t * L_1 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_1);
int32_t L_2 = Array_get_Length_m1203127607_0((Array_t *)L_1, /*hidden argument*/NULL);
__this->___idx_1 = L_2;
}
IL_001e:
{
int32_t L_3 = (int32_t)(__this->___idx_1);
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_0043;
}
}
{
int32_t L_4 = (int32_t)(__this->___idx_1);
int32_t L_5 = (int32_t)((int32_t)((int32_t)L_4-(int32_t)1));
V_0 = (int32_t)L_5;
__this->___idx_1 = L_5;
int32_t L_6 = V_0;
G_B5_0 = ((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0044;
}
IL_0043:
{
G_B5_0 = 0;
}
IL_0044:
{
return (bool)G_B5_0;
}
}
// T System.Array/InternalEnumerator`1<System.IntPtr>::get_Current()
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_673706721_0;
extern Il2CppCodeGenString* _stringLiteral_2097638381_0;
extern "C" IntPtr_t InternalEnumerator_1_get_Current_m_1952683188_0_gshared (InternalEnumerator_1_t_1814435847_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral_673706721_0 = il2cpp_codegen_string_literal_from_index(193);
_stringLiteral_2097638381_0 = il2cpp_codegen_string_literal_from_index(194);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0018;
}
}
{
InvalidOperationException_t_523179548_0 * L_1 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_1, (String_t*)_stringLiteral_673706721_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0018:
{
int32_t L_2 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_002f;
}
}
{
InvalidOperationException_t_523179548_0 * L_3 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_3, (String_t*)_stringLiteral_2097638381_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
IL_002f:
{
Array_t * L_4 = (Array_t *)(__this->___array_0);
Array_t * L_5 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_5);
int32_t L_6 = Array_get_Length_m1203127607_0((Array_t *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)(__this->___idx_1);
NullCheck((Array_t *)L_4);
IntPtr_t L_8 = (( IntPtr_t (*) (Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((Array_t *)L_4, (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_6-(int32_t)1))-(int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
return L_8;
}
}
// System.Void System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::.ctor(System.Array)
extern "C" void InternalEnumerator_1__ctor_m_1784131606_0_gshared (InternalEnumerator_1_t_1079392692_0 * __this, Array_t * ___array, const MethodInfo* method)
{
{
Array_t * L_0 = ___array;
__this->___array_0 = L_0;
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Void System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::System.Collections.IEnumerator.Reset()
extern "C" void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m_793020042_0_gshared (InternalEnumerator_1_t_1079392692_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Object System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m_2413342_0_gshared (InternalEnumerator_1_t_1079392692_0 * __this, const MethodInfo* method)
{
{
TableRange_t1942381821_0 L_0 = (( TableRange_t1942381821_0 (*) (InternalEnumerator_1_t_1079392692_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((InternalEnumerator_1_t_1079392692_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
TableRange_t1942381821_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::Dispose()
extern "C" void InternalEnumerator_1_Dispose_m_1778198975_0_gshared (InternalEnumerator_1_t_1079392692_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Boolean System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::MoveNext()
extern "C" bool InternalEnumerator_1_MoveNext_m1609192930_0_gshared (InternalEnumerator_1_t_1079392692_0 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t G_B5_0 = 0;
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001e;
}
}
{
Array_t * L_1 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_1);
int32_t L_2 = Array_get_Length_m1203127607_0((Array_t *)L_1, /*hidden argument*/NULL);
__this->___idx_1 = L_2;
}
IL_001e:
{
int32_t L_3 = (int32_t)(__this->___idx_1);
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_0043;
}
}
{
int32_t L_4 = (int32_t)(__this->___idx_1);
int32_t L_5 = (int32_t)((int32_t)((int32_t)L_4-(int32_t)1));
V_0 = (int32_t)L_5;
__this->___idx_1 = L_5;
int32_t L_6 = V_0;
G_B5_0 = ((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0044;
}
IL_0043:
{
G_B5_0 = 0;
}
IL_0044:
{
return (bool)G_B5_0;
}
}
// T System.Array/InternalEnumerator`1<Mono.Globalization.Unicode.CodePointIndexer/TableRange>::get_Current()
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_673706721_0;
extern Il2CppCodeGenString* _stringLiteral_2097638381_0;
extern "C" TableRange_t1942381821_0 InternalEnumerator_1_get_Current_m_1988666191_0_gshared (InternalEnumerator_1_t_1079392692_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral_673706721_0 = il2cpp_codegen_string_literal_from_index(193);
_stringLiteral_2097638381_0 = il2cpp_codegen_string_literal_from_index(194);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0018;
}
}
{
InvalidOperationException_t_523179548_0 * L_1 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_1, (String_t*)_stringLiteral_673706721_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0018:
{
int32_t L_2 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_002f;
}
}
{
InvalidOperationException_t_523179548_0 * L_3 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_3, (String_t*)_stringLiteral_2097638381_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
IL_002f:
{
Array_t * L_4 = (Array_t *)(__this->___array_0);
Array_t * L_5 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_5);
int32_t L_6 = Array_get_Length_m1203127607_0((Array_t *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)(__this->___idx_1);
NullCheck((Array_t *)L_4);
TableRange_t1942381821_0 L_8 = (( TableRange_t1942381821_0 (*) (Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((Array_t *)L_4, (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_6-(int32_t)1))-(int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
return L_8;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::.ctor()
extern "C" void Dictionary_2__ctor_m491177976_0_gshared (Dictionary_2_t357803672_0 * __this, const MethodInfo* method)
{
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
NullCheck((Dictionary_2_t357803672_0 *)__this);
(( void (*) (Dictionary_2_t357803672_0 *, int32_t, Object_t*, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Dictionary_2_t357803672_0 *)__this, (int32_t)((int32_t)10), (Object_t*)NULL, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::.ctor(System.Collections.Generic.IEqualityComparer`1<TKey>)
extern "C" void Dictionary_2__ctor_m1817203311_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t* ___comparer, const MethodInfo* method)
{
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
Object_t* L_0 = ___comparer;
NullCheck((Dictionary_2_t357803672_0 *)__this);
(( void (*) (Dictionary_2_t357803672_0 *, int32_t, Object_t*, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Dictionary_2_t357803672_0 *)__this, (int32_t)((int32_t)10), (Object_t*)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::.ctor(System.Int32)
extern "C" void Dictionary_2__ctor_m1674594633_0_gshared (Dictionary_2_t357803672_0 * __this, int32_t ___capacity, const MethodInfo* method)
{
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
int32_t L_0 = ___capacity;
NullCheck((Dictionary_2_t357803672_0 *)__this);
(( void (*) (Dictionary_2_t357803672_0 *, int32_t, Object_t*, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Dictionary_2_t357803672_0 *)__this, (int32_t)L_0, (Object_t*)NULL, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::.ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
extern "C" void Dictionary_2__ctor_m_2127059655_0_gshared (Dictionary_2_t357803672_0 * __this, SerializationInfo_t526833679_0 * ___info, StreamingContext_t_1216992900_0 ___context, const MethodInfo* method)
{
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
SerializationInfo_t526833679_0 * L_0 = ___info;
__this->___serialization_info_13 = L_0;
return;
}
}
// System.Object System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.IDictionary.get_Item(System.Object)
extern "C" Object_t * Dictionary_2_System_Collections_IDictionary_get_Item_m_1697855738_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t * ___key, const MethodInfo* method)
{
{
Object_t * L_0 = ___key;
if (!((Object_t *)IsInst(L_0, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1))))
{
goto IL_002f;
}
}
{
Object_t * L_1 = ___key;
NullCheck((Dictionary_2_t357803672_0 *)__this);
bool L_2 = (bool)VirtFuncInvoker1< bool, Object_t * >::Invoke(27 /* System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::ContainsKey(TKey) */, (Dictionary_2_t357803672_0 *)__this, (Object_t *)((Object_t *)Castclass(L_1, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1))));
if (!L_2)
{
goto IL_002f;
}
}
{
Object_t * L_3 = ___key;
NullCheck((Dictionary_2_t357803672_0 *)__this);
Object_t * L_4 = (( Object_t * (*) (Dictionary_2_t357803672_0 *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((Dictionary_2_t357803672_0 *)__this, (Object_t *)L_3, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
NullCheck((Dictionary_2_t357803672_0 *)__this);
int32_t L_5 = (int32_t)VirtFuncInvoker1< int32_t, Object_t * >::Invoke(24 /* TValue System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::get_Item(TKey) */, (Dictionary_2_t357803672_0 *)__this, (Object_t *)L_4);
int32_t L_6 = L_5;
Object_t * L_7 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5), &L_6);
return L_7;
}
IL_002f:
{
return NULL;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.IDictionary.set_Item(System.Object,System.Object)
extern "C" void Dictionary_2_System_Collections_IDictionary_set_Item_m_561343435_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___key;
NullCheck((Dictionary_2_t357803672_0 *)__this);
Object_t * L_1 = (( Object_t * (*) (Dictionary_2_t357803672_0 *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((Dictionary_2_t357803672_0 *)__this, (Object_t *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
Object_t * L_2 = ___value;
NullCheck((Dictionary_2_t357803672_0 *)__this);
int32_t L_3 = (( int32_t (*) (Dictionary_2_t357803672_0 *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6)->method)((Dictionary_2_t357803672_0 *)__this, (Object_t *)L_2, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6));
NullCheck((Dictionary_2_t357803672_0 *)__this);
VirtActionInvoker2< Object_t *, int32_t >::Invoke(25 /* System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::set_Item(TKey,TValue) */, (Dictionary_2_t357803672_0 *)__this, (Object_t *)L_1, (int32_t)L_3);
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.IDictionary.Add(System.Object,System.Object)
extern "C" void Dictionary_2_System_Collections_IDictionary_Add_m_933028612_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___key;
NullCheck((Dictionary_2_t357803672_0 *)__this);
Object_t * L_1 = (( Object_t * (*) (Dictionary_2_t357803672_0 *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((Dictionary_2_t357803672_0 *)__this, (Object_t *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
Object_t * L_2 = ___value;
NullCheck((Dictionary_2_t357803672_0 *)__this);
int32_t L_3 = (( int32_t (*) (Dictionary_2_t357803672_0 *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6)->method)((Dictionary_2_t357803672_0 *)__this, (Object_t *)L_2, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6));
NullCheck((Dictionary_2_t357803672_0 *)__this);
VirtActionInvoker2< Object_t *, int32_t >::Invoke(26 /* System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Add(TKey,TValue) */, (Dictionary_2_t357803672_0 *)__this, (Object_t *)L_1, (int32_t)L_3);
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.IDictionary.Contains(System.Object)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern "C" bool Dictionary_2_System_Collections_IDictionary_Contains_m1847490614_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t * ___key, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
s_Il2CppMethodIntialized = true;
}
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0011;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0011:
{
Object_t * L_2 = ___key;
if (!((Object_t *)IsInst(L_2, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1))))
{
goto IL_0029;
}
}
{
Object_t * L_3 = ___key;
NullCheck((Dictionary_2_t357803672_0 *)__this);
bool L_4 = (bool)VirtFuncInvoker1< bool, Object_t * >::Invoke(27 /* System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::ContainsKey(TKey) */, (Dictionary_2_t357803672_0 *)__this, (Object_t *)((Object_t *)Castclass(L_3, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1))));
return L_4;
}
IL_0029:
{
return (bool)0;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.IDictionary.Remove(System.Object)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern "C" void Dictionary_2_System_Collections_IDictionary_Remove_m_418506637_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t * ___key, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
s_Il2CppMethodIntialized = true;
}
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0011;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0011:
{
Object_t * L_2 = ___key;
if (!((Object_t *)IsInst(L_2, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1))))
{
goto IL_0029;
}
}
{
Object_t * L_3 = ___key;
NullCheck((Dictionary_2_t357803672_0 *)__this);
VirtFuncInvoker1< bool, Object_t * >::Invoke(30 /* System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Remove(TKey) */, (Dictionary_2_t357803672_0 *)__this, (Object_t *)((Object_t *)Castclass(L_3, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1))));
}
IL_0029:
{
return;
}
}
// System.Object System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.ICollection.get_SyncRoot()
extern "C" Object_t * Dictionary_2_System_Collections_ICollection_get_SyncRoot_m1202758096_0_gshared (Dictionary_2_t357803672_0 * __this, const MethodInfo* method)
{
{
return __this;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.get_IsReadOnly()
extern "C" bool Dictionary_2_System_Collections_Generic_ICollectionU3CSystem_Collections_Generic_KeyValuePairU3CTKeyU2CTValueU3EU3E_get_IsReadOnly_m703863202_0_gshared (Dictionary_2_t357803672_0 * __this, const MethodInfo* method)
{
{
return (bool)0;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Add(System.Collections.Generic.KeyValuePair`2<TKey,TValue>)
extern "C" void Dictionary_2_System_Collections_Generic_ICollectionU3CSystem_Collections_Generic_KeyValuePairU3CTKeyU2CTValueU3EU3E_Add_m_884953207_0_gshared (Dictionary_2_t357803672_0 * __this, KeyValuePair_2_t742775054_0 ___keyValuePair, const MethodInfo* method)
{
{
Object_t * L_0 = (( Object_t * (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)((KeyValuePair_2_t742775054_0 *)(&___keyValuePair), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
int32_t L_1 = (( int32_t (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11)->method)((KeyValuePair_2_t742775054_0 *)(&___keyValuePair), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11));
NullCheck((Dictionary_2_t357803672_0 *)__this);
VirtActionInvoker2< Object_t *, int32_t >::Invoke(26 /* System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Add(TKey,TValue) */, (Dictionary_2_t357803672_0 *)__this, (Object_t *)L_0, (int32_t)L_1);
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Contains(System.Collections.Generic.KeyValuePair`2<TKey,TValue>)
extern "C" bool Dictionary_2_System_Collections_Generic_ICollectionU3CSystem_Collections_Generic_KeyValuePairU3CTKeyU2CTValueU3EU3E_Contains_m_626225635_0_gshared (Dictionary_2_t357803672_0 * __this, KeyValuePair_2_t742775054_0 ___keyValuePair, const MethodInfo* method)
{
{
KeyValuePair_2_t742775054_0 L_0 = ___keyValuePair;
NullCheck((Dictionary_2_t357803672_0 *)__this);
bool L_1 = (( bool (*) (Dictionary_2_t357803672_0 *, KeyValuePair_2_t742775054_0 , const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 12)->method)((Dictionary_2_t357803672_0 *)__this, (KeyValuePair_2_t742775054_0 )L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 12));
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.CopyTo(System.Collections.Generic.KeyValuePair`2<TKey,TValue>[],System.Int32)
extern "C" void Dictionary_2_System_Collections_Generic_ICollectionU3CSystem_Collections_Generic_KeyValuePairU3CTKeyU2CTValueU3EU3E_CopyTo_m_782356691_0_gshared (Dictionary_2_t357803672_0 * __this, KeyValuePair_2U5BU5D_t842258672_0* ___array, int32_t ___index, const MethodInfo* method)
{
{
KeyValuePair_2U5BU5D_t842258672_0* L_0 = ___array;
int32_t L_1 = ___index;
NullCheck((Dictionary_2_t357803672_0 *)__this);
(( void (*) (Dictionary_2_t357803672_0 *, KeyValuePair_2U5BU5D_t842258672_0*, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 13)->method)((Dictionary_2_t357803672_0 *)__this, (KeyValuePair_2U5BU5D_t842258672_0*)L_0, (int32_t)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 13));
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Remove(System.Collections.Generic.KeyValuePair`2<TKey,TValue>)
extern "C" bool Dictionary_2_System_Collections_Generic_ICollectionU3CSystem_Collections_Generic_KeyValuePairU3CTKeyU2CTValueU3EU3E_Remove_m827431042_0_gshared (Dictionary_2_t357803672_0 * __this, KeyValuePair_2_t742775054_0 ___keyValuePair, const MethodInfo* method)
{
{
KeyValuePair_2_t742775054_0 L_0 = ___keyValuePair;
NullCheck((Dictionary_2_t357803672_0 *)__this);
bool L_1 = (( bool (*) (Dictionary_2_t357803672_0 *, KeyValuePair_2_t742775054_0 , const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 12)->method)((Dictionary_2_t357803672_0 *)__this, (KeyValuePair_2_t742775054_0 )L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 12));
if (L_1)
{
goto IL_000e;
}
}
{
return (bool)0;
}
IL_000e:
{
Object_t * L_2 = (( Object_t * (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)((KeyValuePair_2_t742775054_0 *)(&___keyValuePair), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
NullCheck((Dictionary_2_t357803672_0 *)__this);
bool L_3 = (bool)VirtFuncInvoker1< bool, Object_t * >::Invoke(30 /* System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Remove(TKey) */, (Dictionary_2_t357803672_0 *)__this, (Object_t *)L_2);
return L_3;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.ICollection.CopyTo(System.Array,System.Int32)
extern TypeInfo* DictionaryEntryU5BU5D_t_1171009526_0_il2cpp_TypeInfo_var;
extern "C" void Dictionary_2_System_Collections_ICollection_CopyTo_m1936628812_0_gshared (Dictionary_2_t357803672_0 * __this, Array_t * ___array, int32_t ___index, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
DictionaryEntryU5BU5D_t_1171009526_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2803);
s_Il2CppMethodIntialized = true;
}
KeyValuePair_2U5BU5D_t842258672_0* V_0 = {0};
DictionaryEntryU5BU5D_t_1171009526_0* V_1 = {0};
int32_t G_B5_0 = 0;
DictionaryEntryU5BU5D_t_1171009526_0* G_B5_1 = {0};
Dictionary_2_t357803672_0 * G_B5_2 = {0};
int32_t G_B4_0 = 0;
DictionaryEntryU5BU5D_t_1171009526_0* G_B4_1 = {0};
Dictionary_2_t357803672_0 * G_B4_2 = {0};
{
Array_t * L_0 = ___array;
V_0 = (KeyValuePair_2U5BU5D_t842258672_0*)((KeyValuePair_2U5BU5D_t842258672_0*)IsInst(L_0, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 14)));
KeyValuePair_2U5BU5D_t842258672_0* L_1 = V_0;
if (!L_1)
{
goto IL_0016;
}
}
{
KeyValuePair_2U5BU5D_t842258672_0* L_2 = V_0;
int32_t L_3 = ___index;
NullCheck((Dictionary_2_t357803672_0 *)__this);
(( void (*) (Dictionary_2_t357803672_0 *, KeyValuePair_2U5BU5D_t842258672_0*, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 13)->method)((Dictionary_2_t357803672_0 *)__this, (KeyValuePair_2U5BU5D_t842258672_0*)L_2, (int32_t)L_3, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 13));
return;
}
IL_0016:
{
Array_t * L_4 = ___array;
int32_t L_5 = ___index;
NullCheck((Dictionary_2_t357803672_0 *)__this);
(( void (*) (Dictionary_2_t357803672_0 *, Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 15)->method)((Dictionary_2_t357803672_0 *)__this, (Array_t *)L_4, (int32_t)L_5, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 15));
Array_t * L_6 = ___array;
V_1 = (DictionaryEntryU5BU5D_t_1171009526_0*)((DictionaryEntryU5BU5D_t_1171009526_0*)IsInst(L_6, DictionaryEntryU5BU5D_t_1171009526_0_il2cpp_TypeInfo_var));
DictionaryEntryU5BU5D_t_1171009526_0* L_7 = V_1;
if (!L_7)
{
goto IL_0051;
}
}
{
DictionaryEntryU5BU5D_t_1171009526_0* L_8 = V_1;
int32_t L_9 = ___index;
Transform_1_t954325734_0 * L_10 = ((Dictionary_2_t357803672_0_StaticFields*)IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 16)->static_fields)->___U3CU3Ef__amU24cacheB_15;
G_B4_0 = L_9;
G_B4_1 = L_8;
G_B4_2 = ((Dictionary_2_t357803672_0 *)(__this));
if (L_10)
{
G_B5_0 = L_9;
G_B5_1 = L_8;
G_B5_2 = ((Dictionary_2_t357803672_0 *)(__this));
goto IL_0046;
}
}
{
IntPtr_t L_11 = { (void*)IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 17) };
Transform_1_t954325734_0 * L_12 = (Transform_1_t954325734_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 18));
(( void (*) (Transform_1_t954325734_0 *, Object_t *, IntPtr_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 19)->method)(L_12, (Object_t *)NULL, (IntPtr_t)L_11, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 19));
((Dictionary_2_t357803672_0_StaticFields*)IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 16)->static_fields)->___U3CU3Ef__amU24cacheB_15 = L_12;
G_B5_0 = G_B4_0;
G_B5_1 = G_B4_1;
G_B5_2 = ((Dictionary_2_t357803672_0 *)(G_B4_2));
}
IL_0046:
{
Transform_1_t954325734_0 * L_13 = ((Dictionary_2_t357803672_0_StaticFields*)IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 16)->static_fields)->___U3CU3Ef__amU24cacheB_15;
NullCheck((Dictionary_2_t357803672_0 *)G_B5_2);
(( void (*) (Dictionary_2_t357803672_0 *, DictionaryEntryU5BU5D_t_1171009526_0*, int32_t, Transform_1_t954325734_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 20)->method)((Dictionary_2_t357803672_0 *)G_B5_2, (DictionaryEntryU5BU5D_t_1171009526_0*)G_B5_1, (int32_t)G_B5_0, (Transform_1_t954325734_0 *)L_13, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 20));
return;
}
IL_0051:
{
Array_t * L_14 = ___array;
int32_t L_15 = ___index;
IntPtr_t L_16 = { (void*)IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 21) };
Transform_1_t_252603744_0 * L_17 = (Transform_1_t_252603744_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 22));
(( void (*) (Transform_1_t_252603744_0 *, Object_t *, IntPtr_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 23)->method)(L_17, (Object_t *)NULL, (IntPtr_t)L_16, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 23));
NullCheck((Dictionary_2_t357803672_0 *)__this);
(( void (*) (Dictionary_2_t357803672_0 *, Array_t *, int32_t, Transform_1_t_252603744_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 24)->method)((Dictionary_2_t357803672_0 *)__this, (Array_t *)L_14, (int32_t)L_15, (Transform_1_t_252603744_0 *)L_17, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 24));
return;
}
}
// System.Collections.IEnumerator System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.IEnumerable.GetEnumerator()
extern "C" Object_t * Dictionary_2_System_Collections_IEnumerable_GetEnumerator_m1911592795_0_gshared (Dictionary_2_t357803672_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 L_0 = {0};
(( void (*) (Enumerator_t_1767787419_0 *, Dictionary_2_t357803672_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 26)->method)(&L_0, (Dictionary_2_t357803672_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 26));
Enumerator_t_1767787419_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 25), &L_1);
return (Object_t *)L_2;
}
}
// System.Collections.Generic.IEnumerator`1<System.Collections.Generic.KeyValuePair`2<TKey,TValue>> System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>.GetEnumerator()
extern "C" Object_t* Dictionary_2_System_Collections_Generic_IEnumerableU3CSystem_Collections_Generic_KeyValuePairU3CTKeyU2CTValueU3EU3E_GetEnumerator_m_1070043694_0_gshared (Dictionary_2_t357803672_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 L_0 = {0};
(( void (*) (Enumerator_t_1767787419_0 *, Dictionary_2_t357803672_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 26)->method)(&L_0, (Dictionary_2_t357803672_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 26));
Enumerator_t_1767787419_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 25), &L_1);
return (Object_t*)L_2;
}
}
// System.Collections.IDictionaryEnumerator System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::System.Collections.IDictionary.GetEnumerator()
extern "C" Object_t * Dictionary_2_System_Collections_IDictionary_GetEnumerator_m339784735_0_gshared (Dictionary_2_t357803672_0 * __this, const MethodInfo* method)
{
{
ShimEnumerator_t375085566_0 * L_0 = (ShimEnumerator_t375085566_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 27));
(( void (*) (ShimEnumerator_t375085566_0 *, Dictionary_2_t357803672_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 28)->method)(L_0, (Dictionary_2_t357803672_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 28));
return L_0;
}
}
// System.Int32 System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::get_Count()
extern "C" int32_t Dictionary_2_get_Count_m1783486488_0_gshared (Dictionary_2_t357803672_0 * __this, const MethodInfo* method)
{
{
int32_t L_0 = (int32_t)(__this->___count_10);
return L_0;
}
}
// TValue System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::get_Item(TKey)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern TypeInfo* KeyNotFoundException_t240136748_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern "C" int32_t Dictionary_2_get_Item_m757075567_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t * ___key, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
KeyNotFoundException_t240136748_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2804);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0016;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0016:
{
Object_t* L_2 = (Object_t*)(__this->___hcp_12);
Object_t * L_3 = ___key;
NullCheck((Object_t*)L_2);
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(1 /* System.Int32 System.Collections.Generic.IEqualityComparer`1<System.Object>::GetHashCode(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_2, (Object_t *)L_3);
V_0 = (int32_t)((int32_t)((int32_t)L_4|(int32_t)((int32_t)-2147483648LL)));
Int32U5BU5D_t1872284309_0* L_5 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_6 = V_0;
Int32U5BU5D_t1872284309_0* L_7 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_7);
NullCheck(L_5);
IL2CPP_ARRAY_BOUNDS_CHECK(L_5, ((int32_t)((int32_t)((int32_t)((int32_t)L_6&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_7)->max_length)))))));
int32_t L_8 = ((int32_t)((int32_t)((int32_t)((int32_t)L_6&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_7)->max_length))))));
V_1 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_5, L_8, sizeof(int32_t)))-(int32_t)1));
goto IL_009b;
}
IL_0048:
{
LinkU5BU5D_t1854582343_0* L_9 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_10 = V_1;
NullCheck(L_9);
IL2CPP_ARRAY_BOUNDS_CHECK(L_9, L_10);
int32_t L_11 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_9, L_10, sizeof(Link_t976230437_0 )))->___HashCode_0);
int32_t L_12 = V_0;
if ((!(((uint32_t)L_11) == ((uint32_t)L_12))))
{
goto IL_0089;
}
}
{
Object_t* L_13 = (Object_t*)(__this->___hcp_12);
ObjectU5BU5D_t1774424924_0* L_14 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_15 = V_1;
NullCheck(L_14);
IL2CPP_ARRAY_BOUNDS_CHECK(L_14, L_15);
int32_t L_16 = L_15;
Object_t * L_17 = ___key;
NullCheck((Object_t*)L_13);
bool L_18 = (bool)InterfaceFuncInvoker2< bool, Object_t *, Object_t * >::Invoke(0 /* System.Boolean System.Collections.Generic.IEqualityComparer`1<System.Object>::Equals(T,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_13, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_14, L_16, sizeof(Object_t *))), (Object_t *)L_17);
if (!L_18)
{
goto IL_0089;
}
}
{
Int32U5BU5D_t1872284309_0* L_19 = (Int32U5BU5D_t1872284309_0*)(__this->___valueSlots_7);
int32_t L_20 = V_1;
NullCheck(L_19);
IL2CPP_ARRAY_BOUNDS_CHECK(L_19, L_20);
int32_t L_21 = L_20;
return (*(int32_t*)(int32_t*)SZArrayLdElema(L_19, L_21, sizeof(int32_t)));
}
IL_0089:
{
LinkU5BU5D_t1854582343_0* L_22 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_23 = V_1;
NullCheck(L_22);
IL2CPP_ARRAY_BOUNDS_CHECK(L_22, L_23);
int32_t L_24 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_22, L_23, sizeof(Link_t976230437_0 )))->___Next_1);
V_1 = (int32_t)L_24;
}
IL_009b:
{
int32_t L_25 = V_1;
if ((!(((uint32_t)L_25) == ((uint32_t)(-1)))))
{
goto IL_0048;
}
}
{
KeyNotFoundException_t240136748_0 * L_26 = (KeyNotFoundException_t240136748_0 *)il2cpp_codegen_object_new (KeyNotFoundException_t240136748_0_il2cpp_TypeInfo_var);
KeyNotFoundException__ctor_m_752071836_0(L_26, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_26);
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::set_Item(TKey,TValue)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern "C" void Dictionary_2_set_Item_m_421418056_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
int32_t V_2 = 0;
int32_t V_3 = 0;
int32_t V_4 = 0;
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0016;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0016:
{
Object_t* L_2 = (Object_t*)(__this->___hcp_12);
Object_t * L_3 = ___key;
NullCheck((Object_t*)L_2);
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(1 /* System.Int32 System.Collections.Generic.IEqualityComparer`1<System.Object>::GetHashCode(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_2, (Object_t *)L_3);
V_0 = (int32_t)((int32_t)((int32_t)L_4|(int32_t)((int32_t)-2147483648LL)));
int32_t L_5 = V_0;
Int32U5BU5D_t1872284309_0* L_6 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_6);
V_1 = (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_5&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_6)->max_length))))));
Int32U5BU5D_t1872284309_0* L_7 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_8 = V_1;
NullCheck(L_7);
IL2CPP_ARRAY_BOUNDS_CHECK(L_7, L_8);
int32_t L_9 = L_8;
V_2 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_7, L_9, sizeof(int32_t)))-(int32_t)1));
V_3 = (int32_t)(-1);
int32_t L_10 = V_2;
if ((((int32_t)L_10) == ((int32_t)(-1))))
{
goto IL_00a2;
}
}
IL_004e:
{
LinkU5BU5D_t1854582343_0* L_11 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_12 = V_2;
NullCheck(L_11);
IL2CPP_ARRAY_BOUNDS_CHECK(L_11, L_12);
int32_t L_13 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_11, L_12, sizeof(Link_t976230437_0 )))->___HashCode_0);
int32_t L_14 = V_0;
if ((!(((uint32_t)L_13) == ((uint32_t)L_14))))
{
goto IL_0087;
}
}
{
Object_t* L_15 = (Object_t*)(__this->___hcp_12);
ObjectU5BU5D_t1774424924_0* L_16 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_17 = V_2;
NullCheck(L_16);
IL2CPP_ARRAY_BOUNDS_CHECK(L_16, L_17);
int32_t L_18 = L_17;
Object_t * L_19 = ___key;
NullCheck((Object_t*)L_15);
bool L_20 = (bool)InterfaceFuncInvoker2< bool, Object_t *, Object_t * >::Invoke(0 /* System.Boolean System.Collections.Generic.IEqualityComparer`1<System.Object>::Equals(T,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_15, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_16, L_18, sizeof(Object_t *))), (Object_t *)L_19);
if (!L_20)
{
goto IL_0087;
}
}
{
goto IL_00a2;
}
IL_0087:
{
int32_t L_21 = V_2;
V_3 = (int32_t)L_21;
LinkU5BU5D_t1854582343_0* L_22 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_23 = V_2;
NullCheck(L_22);
IL2CPP_ARRAY_BOUNDS_CHECK(L_22, L_23);
int32_t L_24 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_22, L_23, sizeof(Link_t976230437_0 )))->___Next_1);
V_2 = (int32_t)L_24;
int32_t L_25 = V_2;
if ((!(((uint32_t)L_25) == ((uint32_t)(-1)))))
{
goto IL_004e;
}
}
IL_00a2:
{
int32_t L_26 = V_2;
if ((!(((uint32_t)L_26) == ((uint32_t)(-1)))))
{
goto IL_0166;
}
}
{
int32_t L_27 = (int32_t)(__this->___count_10);
int32_t L_28 = (int32_t)((int32_t)((int32_t)L_27+(int32_t)1));
V_4 = (int32_t)L_28;
__this->___count_10 = L_28;
int32_t L_29 = V_4;
int32_t L_30 = (int32_t)(__this->___threshold_11);
if ((((int32_t)L_29) <= ((int32_t)L_30)))
{
goto IL_00de;
}
}
{
NullCheck((Dictionary_2_t357803672_0 *)__this);
(( void (*) (Dictionary_2_t357803672_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 30)->method)((Dictionary_2_t357803672_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 30));
int32_t L_31 = V_0;
Int32U5BU5D_t1872284309_0* L_32 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_32);
V_1 = (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_31&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_32)->max_length))))));
}
IL_00de:
{
int32_t L_33 = (int32_t)(__this->___emptySlot_9);
V_2 = (int32_t)L_33;
int32_t L_34 = V_2;
if ((!(((uint32_t)L_34) == ((uint32_t)(-1)))))
{
goto IL_0105;
}
}
{
int32_t L_35 = (int32_t)(__this->___touchedSlots_8);
int32_t L_36 = (int32_t)L_35;
V_4 = (int32_t)L_36;
__this->___touchedSlots_8 = ((int32_t)((int32_t)L_36+(int32_t)1));
int32_t L_37 = V_4;
V_2 = (int32_t)L_37;
goto IL_011c;
}
IL_0105:
{
LinkU5BU5D_t1854582343_0* L_38 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_39 = V_2;
NullCheck(L_38);
IL2CPP_ARRAY_BOUNDS_CHECK(L_38, L_39);
int32_t L_40 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_38, L_39, sizeof(Link_t976230437_0 )))->___Next_1);
__this->___emptySlot_9 = L_40;
}
IL_011c:
{
LinkU5BU5D_t1854582343_0* L_41 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_42 = V_2;
NullCheck(L_41);
IL2CPP_ARRAY_BOUNDS_CHECK(L_41, L_42);
Int32U5BU5D_t1872284309_0* L_43 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_44 = V_1;
NullCheck(L_43);
IL2CPP_ARRAY_BOUNDS_CHECK(L_43, L_44);
int32_t L_45 = L_44;
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_41, L_42, sizeof(Link_t976230437_0 )))->___Next_1 = ((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_43, L_45, sizeof(int32_t)))-(int32_t)1));
Int32U5BU5D_t1872284309_0* L_46 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_47 = V_1;
int32_t L_48 = V_2;
NullCheck(L_46);
IL2CPP_ARRAY_BOUNDS_CHECK(L_46, L_47);
*((int32_t*)(int32_t*)SZArrayLdElema(L_46, L_47, sizeof(int32_t))) = (int32_t)((int32_t)((int32_t)L_48+(int32_t)1));
LinkU5BU5D_t1854582343_0* L_49 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_50 = V_2;
NullCheck(L_49);
IL2CPP_ARRAY_BOUNDS_CHECK(L_49, L_50);
int32_t L_51 = V_0;
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_49, L_50, sizeof(Link_t976230437_0 )))->___HashCode_0 = L_51;
ObjectU5BU5D_t1774424924_0* L_52 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_53 = V_2;
Object_t * L_54 = ___key;
NullCheck(L_52);
IL2CPP_ARRAY_BOUNDS_CHECK(L_52, L_53);
*((Object_t **)(Object_t **)SZArrayLdElema(L_52, L_53, sizeof(Object_t *))) = (Object_t *)L_54;
goto IL_01b5;
}
IL_0166:
{
int32_t L_55 = V_3;
if ((((int32_t)L_55) == ((int32_t)(-1))))
{
goto IL_01b5;
}
}
{
LinkU5BU5D_t1854582343_0* L_56 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_57 = V_3;
NullCheck(L_56);
IL2CPP_ARRAY_BOUNDS_CHECK(L_56, L_57);
LinkU5BU5D_t1854582343_0* L_58 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_59 = V_2;
NullCheck(L_58);
IL2CPP_ARRAY_BOUNDS_CHECK(L_58, L_59);
int32_t L_60 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_58, L_59, sizeof(Link_t976230437_0 )))->___Next_1);
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_56, L_57, sizeof(Link_t976230437_0 )))->___Next_1 = L_60;
LinkU5BU5D_t1854582343_0* L_61 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_62 = V_2;
NullCheck(L_61);
IL2CPP_ARRAY_BOUNDS_CHECK(L_61, L_62);
Int32U5BU5D_t1872284309_0* L_63 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_64 = V_1;
NullCheck(L_63);
IL2CPP_ARRAY_BOUNDS_CHECK(L_63, L_64);
int32_t L_65 = L_64;
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_61, L_62, sizeof(Link_t976230437_0 )))->___Next_1 = ((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_63, L_65, sizeof(int32_t)))-(int32_t)1));
Int32U5BU5D_t1872284309_0* L_66 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_67 = V_1;
int32_t L_68 = V_2;
NullCheck(L_66);
IL2CPP_ARRAY_BOUNDS_CHECK(L_66, L_67);
*((int32_t*)(int32_t*)SZArrayLdElema(L_66, L_67, sizeof(int32_t))) = (int32_t)((int32_t)((int32_t)L_68+(int32_t)1));
}
IL_01b5:
{
Int32U5BU5D_t1872284309_0* L_69 = (Int32U5BU5D_t1872284309_0*)(__this->___valueSlots_7);
int32_t L_70 = V_2;
int32_t L_71 = ___value;
NullCheck(L_69);
IL2CPP_ARRAY_BOUNDS_CHECK(L_69, L_70);
*((int32_t*)(int32_t*)SZArrayLdElema(L_69, L_70, sizeof(int32_t))) = (int32_t)L_71;
int32_t L_72 = (int32_t)(__this->___generation_14);
__this->___generation_14 = ((int32_t)((int32_t)L_72+(int32_t)1));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Init(System.Int32,System.Collections.Generic.IEqualityComparer`1<TKey>)
extern TypeInfo* ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_67824454_0;
extern "C" void Dictionary_2_Init_m2034229104_0_gshared (Dictionary_2_t357803672_0 * __this, int32_t ___capacity, Object_t* ___hcp, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(27);
_stringLiteral_67824454_0 = il2cpp_codegen_string_literal_from_index(493);
s_Il2CppMethodIntialized = true;
}
Object_t* V_0 = {0};
Dictionary_2_t357803672_0 * G_B4_0 = {0};
Dictionary_2_t357803672_0 * G_B3_0 = {0};
Object_t* G_B5_0 = {0};
Dictionary_2_t357803672_0 * G_B5_1 = {0};
{
int32_t L_0 = ___capacity;
if ((((int32_t)L_0) >= ((int32_t)0)))
{
goto IL_0012;
}
}
{
ArgumentOutOfRangeException_t_1011290529_0 * L_1 = (ArgumentOutOfRangeException_t_1011290529_0 *)il2cpp_codegen_object_new (ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m2026296331_0(L_1, (String_t*)_stringLiteral_67824454_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0012:
{
Object_t* L_2 = ___hcp;
G_B3_0 = ((Dictionary_2_t357803672_0 *)(__this));
if (!L_2)
{
G_B4_0 = ((Dictionary_2_t357803672_0 *)(__this));
goto IL_0021;
}
}
{
Object_t* L_3 = ___hcp;
V_0 = (Object_t*)L_3;
Object_t* L_4 = V_0;
G_B5_0 = L_4;
G_B5_1 = ((Dictionary_2_t357803672_0 *)(G_B3_0));
goto IL_0026;
}
IL_0021:
{
IL2CPP_RUNTIME_CLASS_INIT(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 32));
EqualityComparer_1_t1498484409_0 * L_5 = (( EqualityComparer_1_t1498484409_0 * (*) (Object_t * /* static, unused */, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 31)->method)(NULL /*static, unused*/, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 31));
G_B5_0 = ((Object_t*)(L_5));
G_B5_1 = ((Dictionary_2_t357803672_0 *)(G_B4_0));
}
IL_0026:
{
NullCheck(G_B5_1);
G_B5_1->___hcp_12 = G_B5_0;
int32_t L_6 = ___capacity;
if (L_6)
{
goto IL_0035;
}
}
{
___capacity = (int32_t)((int32_t)10);
}
IL_0035:
{
int32_t L_7 = ___capacity;
___capacity = (int32_t)((int32_t)((int32_t)(((int32_t)((int32_t)((float)((float)(((float)((float)L_7)))/(float)(0.9f))))))+(int32_t)1));
int32_t L_8 = ___capacity;
NullCheck((Dictionary_2_t357803672_0 *)__this);
(( void (*) (Dictionary_2_t357803672_0 *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 33)->method)((Dictionary_2_t357803672_0 *)__this, (int32_t)L_8, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 33));
__this->___generation_14 = 0;
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::InitArrays(System.Int32)
extern TypeInfo* Int32U5BU5D_t1872284309_0_il2cpp_TypeInfo_var;
extern TypeInfo* LinkU5BU5D_t1854582343_0_il2cpp_TypeInfo_var;
extern "C" void Dictionary_2_InitArrays_m_1307753913_0_gshared (Dictionary_2_t357803672_0 * __this, int32_t ___size, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
Int32U5BU5D_t1872284309_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(47);
LinkU5BU5D_t1854582343_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2805);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = ___size;
__this->___table_4 = ((Int32U5BU5D_t1872284309_0*)SZArrayNew(Int32U5BU5D_t1872284309_0_il2cpp_TypeInfo_var, (uint32_t)L_0));
int32_t L_1 = ___size;
__this->___linkSlots_5 = ((LinkU5BU5D_t1854582343_0*)SZArrayNew(LinkU5BU5D_t1854582343_0_il2cpp_TypeInfo_var, (uint32_t)L_1));
__this->___emptySlot_9 = (-1);
int32_t L_2 = ___size;
__this->___keySlots_6 = ((ObjectU5BU5D_t1774424924_0*)SZArrayNew(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 34), (uint32_t)L_2));
int32_t L_3 = ___size;
__this->___valueSlots_7 = ((Int32U5BU5D_t1872284309_0*)SZArrayNew(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 35), (uint32_t)L_3));
__this->___touchedSlots_8 = 0;
Int32U5BU5D_t1872284309_0* L_4 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_4);
__this->___threshold_11 = (((int32_t)((int32_t)((float)((float)(((float)((float)(((int32_t)((int32_t)(((Array_t *)L_4)->max_length)))))))*(float)(0.9f))))));
int32_t L_5 = (int32_t)(__this->___threshold_11);
if (L_5)
{
goto IL_0074;
}
}
{
Int32U5BU5D_t1872284309_0* L_6 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_6);
if ((((int32_t)(((int32_t)((int32_t)(((Array_t *)L_6)->max_length))))) <= ((int32_t)0)))
{
goto IL_0074;
}
}
{
__this->___threshold_11 = 1;
}
IL_0074:
{
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::CopyToCheck(System.Array,System.Int32)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern TypeInfo* ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var;
extern TypeInfo* ArgumentException_t1159624695_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral93090393_0;
extern Il2CppCodeGenString* _stringLiteral100346066_0;
extern Il2CppCodeGenString* _stringLiteral1142730282_0;
extern Il2CppCodeGenString* _stringLiteral_1492452532_0;
extern "C" void Dictionary_2_CopyToCheck_m_535882237_0_gshared (Dictionary_2_t357803672_0 * __this, Array_t * ___array, int32_t ___index, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(27);
ArgumentException_t1159624695_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(4);
_stringLiteral93090393_0 = il2cpp_codegen_string_literal_from_index(149);
_stringLiteral100346066_0 = il2cpp_codegen_string_literal_from_index(146);
_stringLiteral1142730282_0 = il2cpp_codegen_string_literal_from_index(494);
_stringLiteral_1492452532_0 = il2cpp_codegen_string_literal_from_index(495);
s_Il2CppMethodIntialized = true;
}
{
Array_t * L_0 = ___array;
if (L_0)
{
goto IL_0011;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral93090393_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0011:
{
int32_t L_2 = ___index;
if ((((int32_t)L_2) >= ((int32_t)0)))
{
goto IL_0023;
}
}
{
ArgumentOutOfRangeException_t_1011290529_0 * L_3 = (ArgumentOutOfRangeException_t_1011290529_0 *)il2cpp_codegen_object_new (ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m2026296331_0(L_3, (String_t*)_stringLiteral100346066_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
IL_0023:
{
int32_t L_4 = ___index;
Array_t * L_5 = ___array;
NullCheck((Array_t *)L_5);
int32_t L_6 = Array_get_Length_m1203127607_0((Array_t *)L_5, /*hidden argument*/NULL);
if ((((int32_t)L_4) <= ((int32_t)L_6)))
{
goto IL_003a;
}
}
{
ArgumentException_t1159624695_0 * L_7 = (ArgumentException_t1159624695_0 *)il2cpp_codegen_object_new (ArgumentException_t1159624695_0_il2cpp_TypeInfo_var);
ArgumentException__ctor_m_750110749_0(L_7, (String_t*)_stringLiteral1142730282_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_7);
}
IL_003a:
{
Array_t * L_8 = ___array;
NullCheck((Array_t *)L_8);
int32_t L_9 = Array_get_Length_m1203127607_0((Array_t *)L_8, /*hidden argument*/NULL);
int32_t L_10 = ___index;
NullCheck((Dictionary_2_t357803672_0 *)__this);
int32_t L_11 = (int32_t)VirtFuncInvoker0< int32_t >::Invoke(9 /* System.Int32 System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::get_Count() */, (Dictionary_2_t357803672_0 *)__this);
if ((((int32_t)((int32_t)((int32_t)L_9-(int32_t)L_10))) >= ((int32_t)L_11)))
{
goto IL_0058;
}
}
{
ArgumentException_t1159624695_0 * L_12 = (ArgumentException_t1159624695_0 *)il2cpp_codegen_object_new (ArgumentException_t1159624695_0_il2cpp_TypeInfo_var);
ArgumentException__ctor_m_750110749_0(L_12, (String_t*)_stringLiteral_1492452532_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_12);
}
IL_0058:
{
return;
}
}
// System.Collections.Generic.KeyValuePair`2<TKey,TValue> System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::make_pair(TKey,TValue)
extern "C" KeyValuePair_2_t742775054_0 Dictionary_2_make_pair_m1135832215_0_gshared (Object_t * __this /* static, unused */, Object_t * ___key, int32_t ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___key;
int32_t L_1 = ___value;
KeyValuePair_2_t742775054_0 L_2 = {0};
(( void (*) (KeyValuePair_2_t742775054_0 *, Object_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 38)->method)(&L_2, (Object_t *)L_0, (int32_t)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 38));
return L_2;
}
}
// TKey System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::pick_key(TKey,TValue)
extern "C" Object_t * Dictionary_2_pick_key_m2048703303_0_gshared (Object_t * __this /* static, unused */, Object_t * ___key, int32_t ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___key;
return L_0;
}
}
// TValue System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::pick_value(TKey,TValue)
extern "C" int32_t Dictionary_2_pick_value_m_1631738141_0_gshared (Object_t * __this /* static, unused */, Object_t * ___key, int32_t ___value, const MethodInfo* method)
{
{
int32_t L_0 = ___value;
return L_0;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::CopyTo(System.Collections.Generic.KeyValuePair`2<TKey,TValue>[],System.Int32)
extern "C" void Dictionary_2_CopyTo_m_822620052_0_gshared (Dictionary_2_t357803672_0 * __this, KeyValuePair_2U5BU5D_t842258672_0* ___array, int32_t ___index, const MethodInfo* method)
{
{
KeyValuePair_2U5BU5D_t842258672_0* L_0 = ___array;
int32_t L_1 = ___index;
NullCheck((Dictionary_2_t357803672_0 *)__this);
(( void (*) (Dictionary_2_t357803672_0 *, Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 15)->method)((Dictionary_2_t357803672_0 *)__this, (Array_t *)(Array_t *)L_0, (int32_t)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 15));
KeyValuePair_2U5BU5D_t842258672_0* L_2 = ___array;
int32_t L_3 = ___index;
IntPtr_t L_4 = { (void*)IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 21) };
Transform_1_t_252603744_0 * L_5 = (Transform_1_t_252603744_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 22));
(( void (*) (Transform_1_t_252603744_0 *, Object_t *, IntPtr_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 23)->method)(L_5, (Object_t *)NULL, (IntPtr_t)L_4, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 23));
NullCheck((Dictionary_2_t357803672_0 *)__this);
(( void (*) (Dictionary_2_t357803672_0 *, KeyValuePair_2U5BU5D_t842258672_0*, int32_t, Transform_1_t_252603744_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 39)->method)((Dictionary_2_t357803672_0 *)__this, (KeyValuePair_2U5BU5D_t842258672_0*)L_2, (int32_t)L_3, (Transform_1_t_252603744_0 *)L_5, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 39));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Resize()
extern TypeInfo* Hashtable_t_2004451924_0_il2cpp_TypeInfo_var;
extern TypeInfo* Int32U5BU5D_t1872284309_0_il2cpp_TypeInfo_var;
extern TypeInfo* LinkU5BU5D_t1854582343_0_il2cpp_TypeInfo_var;
extern "C" void Dictionary_2_Resize_m_1895555264_0_gshared (Dictionary_2_t357803672_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
Hashtable_t_2004451924_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(196);
Int32U5BU5D_t1872284309_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(47);
LinkU5BU5D_t1854582343_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2805);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
Int32U5BU5D_t1872284309_0* V_1 = {0};
LinkU5BU5D_t1854582343_0* V_2 = {0};
int32_t V_3 = 0;
int32_t V_4 = 0;
int32_t V_5 = 0;
int32_t V_6 = 0;
ObjectU5BU5D_t1774424924_0* V_7 = {0};
Int32U5BU5D_t1872284309_0* V_8 = {0};
int32_t V_9 = 0;
{
Int32U5BU5D_t1872284309_0* L_0 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_0);
IL2CPP_RUNTIME_CLASS_INIT(Hashtable_t_2004451924_0_il2cpp_TypeInfo_var);
int32_t L_1 = Hashtable_ToPrime_m840372929_0(NULL /*static, unused*/, (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)(((int32_t)((int32_t)(((Array_t *)L_0)->max_length))))<<(int32_t)1))|(int32_t)1)), /*hidden argument*/NULL);
V_0 = (int32_t)L_1;
int32_t L_2 = V_0;
V_1 = (Int32U5BU5D_t1872284309_0*)((Int32U5BU5D_t1872284309_0*)SZArrayNew(Int32U5BU5D_t1872284309_0_il2cpp_TypeInfo_var, (uint32_t)L_2));
int32_t L_3 = V_0;
V_2 = (LinkU5BU5D_t1854582343_0*)((LinkU5BU5D_t1854582343_0*)SZArrayNew(LinkU5BU5D_t1854582343_0_il2cpp_TypeInfo_var, (uint32_t)L_3));
V_3 = (int32_t)0;
goto IL_00b1;
}
IL_0027:
{
Int32U5BU5D_t1872284309_0* L_4 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_5 = V_3;
NullCheck(L_4);
IL2CPP_ARRAY_BOUNDS_CHECK(L_4, L_5);
int32_t L_6 = L_5;
V_4 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_4, L_6, sizeof(int32_t)))-(int32_t)1));
goto IL_00a5;
}
IL_0038:
{
LinkU5BU5D_t1854582343_0* L_7 = V_2;
int32_t L_8 = V_4;
NullCheck(L_7);
IL2CPP_ARRAY_BOUNDS_CHECK(L_7, L_8);
Object_t* L_9 = (Object_t*)(__this->___hcp_12);
ObjectU5BU5D_t1774424924_0* L_10 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_11 = V_4;
NullCheck(L_10);
IL2CPP_ARRAY_BOUNDS_CHECK(L_10, L_11);
int32_t L_12 = L_11;
NullCheck((Object_t*)L_9);
int32_t L_13 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(1 /* System.Int32 System.Collections.Generic.IEqualityComparer`1<System.Object>::GetHashCode(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_9, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_10, L_12, sizeof(Object_t *))));
int32_t L_14 = (int32_t)((int32_t)((int32_t)L_13|(int32_t)((int32_t)-2147483648LL)));
V_9 = (int32_t)L_14;
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_7, L_8, sizeof(Link_t976230437_0 )))->___HashCode_0 = L_14;
int32_t L_15 = V_9;
V_5 = (int32_t)L_15;
int32_t L_16 = V_5;
int32_t L_17 = V_0;
V_6 = (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_16&(int32_t)((int32_t)2147483647LL)))%(int32_t)L_17));
LinkU5BU5D_t1854582343_0* L_18 = V_2;
int32_t L_19 = V_4;
NullCheck(L_18);
IL2CPP_ARRAY_BOUNDS_CHECK(L_18, L_19);
Int32U5BU5D_t1872284309_0* L_20 = V_1;
int32_t L_21 = V_6;
NullCheck(L_20);
IL2CPP_ARRAY_BOUNDS_CHECK(L_20, L_21);
int32_t L_22 = L_21;
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_18, L_19, sizeof(Link_t976230437_0 )))->___Next_1 = ((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_20, L_22, sizeof(int32_t)))-(int32_t)1));
Int32U5BU5D_t1872284309_0* L_23 = V_1;
int32_t L_24 = V_6;
int32_t L_25 = V_4;
NullCheck(L_23);
IL2CPP_ARRAY_BOUNDS_CHECK(L_23, L_24);
*((int32_t*)(int32_t*)SZArrayLdElema(L_23, L_24, sizeof(int32_t))) = (int32_t)((int32_t)((int32_t)L_25+(int32_t)1));
LinkU5BU5D_t1854582343_0* L_26 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_27 = V_4;
NullCheck(L_26);
IL2CPP_ARRAY_BOUNDS_CHECK(L_26, L_27);
int32_t L_28 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_26, L_27, sizeof(Link_t976230437_0 )))->___Next_1);
V_4 = (int32_t)L_28;
}
IL_00a5:
{
int32_t L_29 = V_4;
if ((!(((uint32_t)L_29) == ((uint32_t)(-1)))))
{
goto IL_0038;
}
}
{
int32_t L_30 = V_3;
V_3 = (int32_t)((int32_t)((int32_t)L_30+(int32_t)1));
}
IL_00b1:
{
int32_t L_31 = V_3;
Int32U5BU5D_t1872284309_0* L_32 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_32);
if ((((int32_t)L_31) < ((int32_t)(((int32_t)((int32_t)(((Array_t *)L_32)->max_length)))))))
{
goto IL_0027;
}
}
{
Int32U5BU5D_t1872284309_0* L_33 = V_1;
__this->___table_4 = L_33;
LinkU5BU5D_t1854582343_0* L_34 = V_2;
__this->___linkSlots_5 = L_34;
int32_t L_35 = V_0;
V_7 = (ObjectU5BU5D_t1774424924_0*)((ObjectU5BU5D_t1774424924_0*)SZArrayNew(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 34), (uint32_t)L_35));
int32_t L_36 = V_0;
V_8 = (Int32U5BU5D_t1872284309_0*)((Int32U5BU5D_t1872284309_0*)SZArrayNew(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 35), (uint32_t)L_36));
ObjectU5BU5D_t1774424924_0* L_37 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
ObjectU5BU5D_t1774424924_0* L_38 = V_7;
int32_t L_39 = (int32_t)(__this->___touchedSlots_8);
Array_Copy_m_1696350628_0(NULL /*static, unused*/, (Array_t *)(Array_t *)L_37, (int32_t)0, (Array_t *)(Array_t *)L_38, (int32_t)0, (int32_t)L_39, /*hidden argument*/NULL);
Int32U5BU5D_t1872284309_0* L_40 = (Int32U5BU5D_t1872284309_0*)(__this->___valueSlots_7);
Int32U5BU5D_t1872284309_0* L_41 = V_8;
int32_t L_42 = (int32_t)(__this->___touchedSlots_8);
Array_Copy_m_1696350628_0(NULL /*static, unused*/, (Array_t *)(Array_t *)L_40, (int32_t)0, (Array_t *)(Array_t *)L_41, (int32_t)0, (int32_t)L_42, /*hidden argument*/NULL);
ObjectU5BU5D_t1774424924_0* L_43 = V_7;
__this->___keySlots_6 = L_43;
Int32U5BU5D_t1872284309_0* L_44 = V_8;
__this->___valueSlots_7 = L_44;
int32_t L_45 = V_0;
__this->___threshold_11 = (((int32_t)((int32_t)((float)((float)(((float)((float)L_45)))*(float)(0.9f))))));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Add(TKey,TValue)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern TypeInfo* ArgumentException_t1159624695_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern Il2CppCodeGenString* _stringLiteral628480033_0;
extern "C" void Dictionary_2_Add_m_1684675651_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
ArgumentException_t1159624695_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(4);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
_stringLiteral628480033_0 = il2cpp_codegen_string_literal_from_index(497);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
int32_t V_2 = 0;
int32_t V_3 = 0;
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0016;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0016:
{
Object_t* L_2 = (Object_t*)(__this->___hcp_12);
Object_t * L_3 = ___key;
NullCheck((Object_t*)L_2);
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(1 /* System.Int32 System.Collections.Generic.IEqualityComparer`1<System.Object>::GetHashCode(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_2, (Object_t *)L_3);
V_0 = (int32_t)((int32_t)((int32_t)L_4|(int32_t)((int32_t)-2147483648LL)));
int32_t L_5 = V_0;
Int32U5BU5D_t1872284309_0* L_6 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_6);
V_1 = (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_5&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_6)->max_length))))));
Int32U5BU5D_t1872284309_0* L_7 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_8 = V_1;
NullCheck(L_7);
IL2CPP_ARRAY_BOUNDS_CHECK(L_7, L_8);
int32_t L_9 = L_8;
V_2 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_7, L_9, sizeof(int32_t)))-(int32_t)1));
goto IL_009b;
}
IL_004a:
{
LinkU5BU5D_t1854582343_0* L_10 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_11 = V_2;
NullCheck(L_10);
IL2CPP_ARRAY_BOUNDS_CHECK(L_10, L_11);
int32_t L_12 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_10, L_11, sizeof(Link_t976230437_0 )))->___HashCode_0);
int32_t L_13 = V_0;
if ((!(((uint32_t)L_12) == ((uint32_t)L_13))))
{
goto IL_0089;
}
}
{
Object_t* L_14 = (Object_t*)(__this->___hcp_12);
ObjectU5BU5D_t1774424924_0* L_15 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_16 = V_2;
NullCheck(L_15);
IL2CPP_ARRAY_BOUNDS_CHECK(L_15, L_16);
int32_t L_17 = L_16;
Object_t * L_18 = ___key;
NullCheck((Object_t*)L_14);
bool L_19 = (bool)InterfaceFuncInvoker2< bool, Object_t *, Object_t * >::Invoke(0 /* System.Boolean System.Collections.Generic.IEqualityComparer`1<System.Object>::Equals(T,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_14, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_15, L_17, sizeof(Object_t *))), (Object_t *)L_18);
if (!L_19)
{
goto IL_0089;
}
}
{
ArgumentException_t1159624695_0 * L_20 = (ArgumentException_t1159624695_0 *)il2cpp_codegen_object_new (ArgumentException_t1159624695_0_il2cpp_TypeInfo_var);
ArgumentException__ctor_m_750110749_0(L_20, (String_t*)_stringLiteral628480033_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_20);
}
IL_0089:
{
LinkU5BU5D_t1854582343_0* L_21 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_22 = V_2;
NullCheck(L_21);
IL2CPP_ARRAY_BOUNDS_CHECK(L_21, L_22);
int32_t L_23 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_21, L_22, sizeof(Link_t976230437_0 )))->___Next_1);
V_2 = (int32_t)L_23;
}
IL_009b:
{
int32_t L_24 = V_2;
if ((!(((uint32_t)L_24) == ((uint32_t)(-1)))))
{
goto IL_004a;
}
}
{
int32_t L_25 = (int32_t)(__this->___count_10);
int32_t L_26 = (int32_t)((int32_t)((int32_t)L_25+(int32_t)1));
V_3 = (int32_t)L_26;
__this->___count_10 = L_26;
int32_t L_27 = V_3;
int32_t L_28 = (int32_t)(__this->___threshold_11);
if ((((int32_t)L_27) <= ((int32_t)L_28)))
{
goto IL_00d5;
}
}
{
NullCheck((Dictionary_2_t357803672_0 *)__this);
(( void (*) (Dictionary_2_t357803672_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 30)->method)((Dictionary_2_t357803672_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 30));
int32_t L_29 = V_0;
Int32U5BU5D_t1872284309_0* L_30 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_30);
V_1 = (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_29&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_30)->max_length))))));
}
IL_00d5:
{
int32_t L_31 = (int32_t)(__this->___emptySlot_9);
V_2 = (int32_t)L_31;
int32_t L_32 = V_2;
if ((!(((uint32_t)L_32) == ((uint32_t)(-1)))))
{
goto IL_00fa;
}
}
{
int32_t L_33 = (int32_t)(__this->___touchedSlots_8);
int32_t L_34 = (int32_t)L_33;
V_3 = (int32_t)L_34;
__this->___touchedSlots_8 = ((int32_t)((int32_t)L_34+(int32_t)1));
int32_t L_35 = V_3;
V_2 = (int32_t)L_35;
goto IL_0111;
}
IL_00fa:
{
LinkU5BU5D_t1854582343_0* L_36 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_37 = V_2;
NullCheck(L_36);
IL2CPP_ARRAY_BOUNDS_CHECK(L_36, L_37);
int32_t L_38 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_36, L_37, sizeof(Link_t976230437_0 )))->___Next_1);
__this->___emptySlot_9 = L_38;
}
IL_0111:
{
LinkU5BU5D_t1854582343_0* L_39 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_40 = V_2;
NullCheck(L_39);
IL2CPP_ARRAY_BOUNDS_CHECK(L_39, L_40);
int32_t L_41 = V_0;
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_39, L_40, sizeof(Link_t976230437_0 )))->___HashCode_0 = L_41;
LinkU5BU5D_t1854582343_0* L_42 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_43 = V_2;
NullCheck(L_42);
IL2CPP_ARRAY_BOUNDS_CHECK(L_42, L_43);
Int32U5BU5D_t1872284309_0* L_44 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_45 = V_1;
NullCheck(L_44);
IL2CPP_ARRAY_BOUNDS_CHECK(L_44, L_45);
int32_t L_46 = L_45;
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_42, L_43, sizeof(Link_t976230437_0 )))->___Next_1 = ((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_44, L_46, sizeof(int32_t)))-(int32_t)1));
Int32U5BU5D_t1872284309_0* L_47 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_48 = V_1;
int32_t L_49 = V_2;
NullCheck(L_47);
IL2CPP_ARRAY_BOUNDS_CHECK(L_47, L_48);
*((int32_t*)(int32_t*)SZArrayLdElema(L_47, L_48, sizeof(int32_t))) = (int32_t)((int32_t)((int32_t)L_49+(int32_t)1));
ObjectU5BU5D_t1774424924_0* L_50 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_51 = V_2;
Object_t * L_52 = ___key;
NullCheck(L_50);
IL2CPP_ARRAY_BOUNDS_CHECK(L_50, L_51);
*((Object_t **)(Object_t **)SZArrayLdElema(L_50, L_51, sizeof(Object_t *))) = (Object_t *)L_52;
Int32U5BU5D_t1872284309_0* L_53 = (Int32U5BU5D_t1872284309_0*)(__this->___valueSlots_7);
int32_t L_54 = V_2;
int32_t L_55 = ___value;
NullCheck(L_53);
IL2CPP_ARRAY_BOUNDS_CHECK(L_53, L_54);
*((int32_t*)(int32_t*)SZArrayLdElema(L_53, L_54, sizeof(int32_t))) = (int32_t)L_55;
int32_t L_56 = (int32_t)(__this->___generation_14);
__this->___generation_14 = ((int32_t)((int32_t)L_56+(int32_t)1));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Clear()
extern "C" void Dictionary_2_Clear_m_2102688733_0_gshared (Dictionary_2_t357803672_0 * __this, const MethodInfo* method)
{
{
__this->___count_10 = 0;
Int32U5BU5D_t1872284309_0* L_0 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
Int32U5BU5D_t1872284309_0* L_1 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_1);
Array_Clear_m_1795390263_0(NULL /*static, unused*/, (Array_t *)(Array_t *)L_0, (int32_t)0, (int32_t)(((int32_t)((int32_t)(((Array_t *)L_1)->max_length)))), /*hidden argument*/NULL);
ObjectU5BU5D_t1774424924_0* L_2 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
ObjectU5BU5D_t1774424924_0* L_3 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
NullCheck(L_3);
Array_Clear_m_1795390263_0(NULL /*static, unused*/, (Array_t *)(Array_t *)L_2, (int32_t)0, (int32_t)(((int32_t)((int32_t)(((Array_t *)L_3)->max_length)))), /*hidden argument*/NULL);
Int32U5BU5D_t1872284309_0* L_4 = (Int32U5BU5D_t1872284309_0*)(__this->___valueSlots_7);
Int32U5BU5D_t1872284309_0* L_5 = (Int32U5BU5D_t1872284309_0*)(__this->___valueSlots_7);
NullCheck(L_5);
Array_Clear_m_1795390263_0(NULL /*static, unused*/, (Array_t *)(Array_t *)L_4, (int32_t)0, (int32_t)(((int32_t)((int32_t)(((Array_t *)L_5)->max_length)))), /*hidden argument*/NULL);
LinkU5BU5D_t1854582343_0* L_6 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
LinkU5BU5D_t1854582343_0* L_7 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
NullCheck(L_7);
Array_Clear_m_1795390263_0(NULL /*static, unused*/, (Array_t *)(Array_t *)L_6, (int32_t)0, (int32_t)(((int32_t)((int32_t)(((Array_t *)L_7)->max_length)))), /*hidden argument*/NULL);
__this->___emptySlot_9 = (-1);
__this->___touchedSlots_8 = 0;
int32_t L_8 = (int32_t)(__this->___generation_14);
__this->___generation_14 = ((int32_t)((int32_t)L_8+(int32_t)1));
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::ContainsKey(TKey)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern "C" bool Dictionary_2_ContainsKey_m1452964877_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t * ___key, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0016;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0016:
{
Object_t* L_2 = (Object_t*)(__this->___hcp_12);
Object_t * L_3 = ___key;
NullCheck((Object_t*)L_2);
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(1 /* System.Int32 System.Collections.Generic.IEqualityComparer`1<System.Object>::GetHashCode(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_2, (Object_t *)L_3);
V_0 = (int32_t)((int32_t)((int32_t)L_4|(int32_t)((int32_t)-2147483648LL)));
Int32U5BU5D_t1872284309_0* L_5 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_6 = V_0;
Int32U5BU5D_t1872284309_0* L_7 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_7);
NullCheck(L_5);
IL2CPP_ARRAY_BOUNDS_CHECK(L_5, ((int32_t)((int32_t)((int32_t)((int32_t)L_6&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_7)->max_length)))))));
int32_t L_8 = ((int32_t)((int32_t)((int32_t)((int32_t)L_6&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_7)->max_length))))));
V_1 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_5, L_8, sizeof(int32_t)))-(int32_t)1));
goto IL_0090;
}
IL_0048:
{
LinkU5BU5D_t1854582343_0* L_9 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_10 = V_1;
NullCheck(L_9);
IL2CPP_ARRAY_BOUNDS_CHECK(L_9, L_10);
int32_t L_11 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_9, L_10, sizeof(Link_t976230437_0 )))->___HashCode_0);
int32_t L_12 = V_0;
if ((!(((uint32_t)L_11) == ((uint32_t)L_12))))
{
goto IL_007e;
}
}
{
Object_t* L_13 = (Object_t*)(__this->___hcp_12);
ObjectU5BU5D_t1774424924_0* L_14 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_15 = V_1;
NullCheck(L_14);
IL2CPP_ARRAY_BOUNDS_CHECK(L_14, L_15);
int32_t L_16 = L_15;
Object_t * L_17 = ___key;
NullCheck((Object_t*)L_13);
bool L_18 = (bool)InterfaceFuncInvoker2< bool, Object_t *, Object_t * >::Invoke(0 /* System.Boolean System.Collections.Generic.IEqualityComparer`1<System.Object>::Equals(T,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_13, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_14, L_16, sizeof(Object_t *))), (Object_t *)L_17);
if (!L_18)
{
goto IL_007e;
}
}
{
return (bool)1;
}
IL_007e:
{
LinkU5BU5D_t1854582343_0* L_19 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_20 = V_1;
NullCheck(L_19);
IL2CPP_ARRAY_BOUNDS_CHECK(L_19, L_20);
int32_t L_21 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_19, L_20, sizeof(Link_t976230437_0 )))->___Next_1);
V_1 = (int32_t)L_21;
}
IL_0090:
{
int32_t L_22 = V_1;
if ((!(((uint32_t)L_22) == ((uint32_t)(-1)))))
{
goto IL_0048;
}
}
{
return (bool)0;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::ContainsValue(TValue)
extern "C" bool Dictionary_2_ContainsValue_m1108279693_0_gshared (Dictionary_2_t357803672_0 * __this, int32_t ___value, const MethodInfo* method)
{
Object_t* V_0 = {0};
int32_t V_1 = 0;
int32_t V_2 = 0;
{
IL2CPP_RUNTIME_CLASS_INIT(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 41));
EqualityComparer_1_t164988502_0 * L_0 = (( EqualityComparer_1_t164988502_0 * (*) (Object_t * /* static, unused */, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 40)->method)(NULL /*static, unused*/, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 40));
V_0 = (Object_t*)L_0;
V_1 = (int32_t)0;
goto IL_0054;
}
IL_000d:
{
Int32U5BU5D_t1872284309_0* L_1 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_2 = V_1;
NullCheck(L_1);
IL2CPP_ARRAY_BOUNDS_CHECK(L_1, L_2);
int32_t L_3 = L_2;
V_2 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_1, L_3, sizeof(int32_t)))-(int32_t)1));
goto IL_0049;
}
IL_001d:
{
Object_t* L_4 = V_0;
Int32U5BU5D_t1872284309_0* L_5 = (Int32U5BU5D_t1872284309_0*)(__this->___valueSlots_7);
int32_t L_6 = V_2;
NullCheck(L_5);
IL2CPP_ARRAY_BOUNDS_CHECK(L_5, L_6);
int32_t L_7 = L_6;
int32_t L_8 = ___value;
NullCheck((Object_t*)L_4);
bool L_9 = (bool)InterfaceFuncInvoker2< bool, int32_t, int32_t >::Invoke(0 /* System.Boolean System.Collections.Generic.IEqualityComparer`1<System.Int32>::Equals(T,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 42), (Object_t*)L_4, (int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_5, L_7, sizeof(int32_t))), (int32_t)L_8);
if (!L_9)
{
goto IL_0037;
}
}
{
return (bool)1;
}
IL_0037:
{
LinkU5BU5D_t1854582343_0* L_10 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_11 = V_2;
NullCheck(L_10);
IL2CPP_ARRAY_BOUNDS_CHECK(L_10, L_11);
int32_t L_12 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_10, L_11, sizeof(Link_t976230437_0 )))->___Next_1);
V_2 = (int32_t)L_12;
}
IL_0049:
{
int32_t L_13 = V_2;
if ((!(((uint32_t)L_13) == ((uint32_t)(-1)))))
{
goto IL_001d;
}
}
{
int32_t L_14 = V_1;
V_1 = (int32_t)((int32_t)((int32_t)L_14+(int32_t)1));
}
IL_0054:
{
int32_t L_15 = V_1;
Int32U5BU5D_t1872284309_0* L_16 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_16);
if ((((int32_t)L_15) < ((int32_t)(((int32_t)((int32_t)(((Array_t *)L_16)->max_length)))))))
{
goto IL_000d;
}
}
{
return (bool)0;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral3237038_0;
extern Il2CppCodeGenString* _stringLiteral2016261304_0;
extern Il2CppCodeGenString* _stringLiteral_535116723_0;
extern Il2CppCodeGenString* _stringLiteral212812367_0;
extern Il2CppCodeGenString* _stringLiteral961688967_0;
extern "C" void Dictionary_2_GetObjectData_m_113204330_0_gshared (Dictionary_2_t357803672_0 * __this, SerializationInfo_t526833679_0 * ___info, StreamingContext_t_1216992900_0 ___context, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral3237038_0 = il2cpp_codegen_string_literal_from_index(111);
_stringLiteral2016261304_0 = il2cpp_codegen_string_literal_from_index(498);
_stringLiteral_535116723_0 = il2cpp_codegen_string_literal_from_index(499);
_stringLiteral212812367_0 = il2cpp_codegen_string_literal_from_index(500);
_stringLiteral961688967_0 = il2cpp_codegen_string_literal_from_index(501);
s_Il2CppMethodIntialized = true;
}
KeyValuePair_2U5BU5D_t842258672_0* V_0 = {0};
{
SerializationInfo_t526833679_0 * L_0 = ___info;
if (L_0)
{
goto IL_0011;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral3237038_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0011:
{
SerializationInfo_t526833679_0 * L_2 = ___info;
int32_t L_3 = (int32_t)(__this->___generation_14);
NullCheck((SerializationInfo_t526833679_0 *)L_2);
SerializationInfo_AddValue_m_1946426782_0((SerializationInfo_t526833679_0 *)L_2, (String_t*)_stringLiteral2016261304_0, (int32_t)L_3, /*hidden argument*/NULL);
SerializationInfo_t526833679_0 * L_4 = ___info;
Object_t* L_5 = (Object_t*)(__this->___hcp_12);
NullCheck((SerializationInfo_t526833679_0 *)L_4);
SerializationInfo_AddValue_m469120675_0((SerializationInfo_t526833679_0 *)L_4, (String_t*)_stringLiteral_535116723_0, (Object_t *)L_5, /*hidden argument*/NULL);
V_0 = (KeyValuePair_2U5BU5D_t842258672_0*)NULL;
int32_t L_6 = (int32_t)(__this->___count_10);
if ((((int32_t)L_6) <= ((int32_t)0)))
{
goto IL_0055;
}
}
{
int32_t L_7 = (int32_t)(__this->___count_10);
V_0 = (KeyValuePair_2U5BU5D_t842258672_0*)((KeyValuePair_2U5BU5D_t842258672_0*)SZArrayNew(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 43), (uint32_t)L_7));
KeyValuePair_2U5BU5D_t842258672_0* L_8 = V_0;
NullCheck((Dictionary_2_t357803672_0 *)__this);
(( void (*) (Dictionary_2_t357803672_0 *, KeyValuePair_2U5BU5D_t842258672_0*, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 13)->method)((Dictionary_2_t357803672_0 *)__this, (KeyValuePair_2U5BU5D_t842258672_0*)L_8, (int32_t)0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 13));
}
IL_0055:
{
SerializationInfo_t526833679_0 * L_9 = ___info;
Int32U5BU5D_t1872284309_0* L_10 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_10);
NullCheck((SerializationInfo_t526833679_0 *)L_9);
SerializationInfo_AddValue_m_1946426782_0((SerializationInfo_t526833679_0 *)L_9, (String_t*)_stringLiteral212812367_0, (int32_t)(((int32_t)((int32_t)(((Array_t *)L_10)->max_length)))), /*hidden argument*/NULL);
SerializationInfo_t526833679_0 * L_11 = ___info;
KeyValuePair_2U5BU5D_t842258672_0* L_12 = V_0;
NullCheck((SerializationInfo_t526833679_0 *)L_11);
SerializationInfo_AddValue_m469120675_0((SerializationInfo_t526833679_0 *)L_11, (String_t*)_stringLiteral961688967_0, (Object_t *)(Object_t *)L_12, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::OnDeserialization(System.Object)
extern TypeInfo* Type_t_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2016261304_0;
extern Il2CppCodeGenString* _stringLiteral_535116723_0;
extern Il2CppCodeGenString* _stringLiteral212812367_0;
extern Il2CppCodeGenString* _stringLiteral961688967_0;
extern "C" void Dictionary_2_OnDeserialization_m_1818001266_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t * ___sender, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
Type_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(3);
_stringLiteral2016261304_0 = il2cpp_codegen_string_literal_from_index(498);
_stringLiteral_535116723_0 = il2cpp_codegen_string_literal_from_index(499);
_stringLiteral212812367_0 = il2cpp_codegen_string_literal_from_index(500);
_stringLiteral961688967_0 = il2cpp_codegen_string_literal_from_index(501);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
KeyValuePair_2U5BU5D_t842258672_0* V_1 = {0};
int32_t V_2 = 0;
{
SerializationInfo_t526833679_0 * L_0 = (SerializationInfo_t526833679_0 *)(__this->___serialization_info_13);
if (L_0)
{
goto IL_000c;
}
}
{
return;
}
IL_000c:
{
SerializationInfo_t526833679_0 * L_1 = (SerializationInfo_t526833679_0 *)(__this->___serialization_info_13);
NullCheck((SerializationInfo_t526833679_0 *)L_1);
int32_t L_2 = SerializationInfo_GetInt32_m_246931343_0((SerializationInfo_t526833679_0 *)L_1, (String_t*)_stringLiteral2016261304_0, /*hidden argument*/NULL);
__this->___generation_14 = L_2;
SerializationInfo_t526833679_0 * L_3 = (SerializationInfo_t526833679_0 *)(__this->___serialization_info_13);
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_4 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 44)), /*hidden argument*/NULL);
NullCheck((SerializationInfo_t526833679_0 *)L_3);
Object_t * L_5 = SerializationInfo_GetValue_m_169495960_0((SerializationInfo_t526833679_0 *)L_3, (String_t*)_stringLiteral_535116723_0, (Type_t *)L_4, /*hidden argument*/NULL);
__this->___hcp_12 = ((Object_t*)Castclass(L_5, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29)));
SerializationInfo_t526833679_0 * L_6 = (SerializationInfo_t526833679_0 *)(__this->___serialization_info_13);
NullCheck((SerializationInfo_t526833679_0 *)L_6);
int32_t L_7 = SerializationInfo_GetInt32_m_246931343_0((SerializationInfo_t526833679_0 *)L_6, (String_t*)_stringLiteral212812367_0, /*hidden argument*/NULL);
V_0 = (int32_t)L_7;
SerializationInfo_t526833679_0 * L_8 = (SerializationInfo_t526833679_0 *)(__this->___serialization_info_13);
Type_t * L_9 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 45)), /*hidden argument*/NULL);
NullCheck((SerializationInfo_t526833679_0 *)L_8);
Object_t * L_10 = SerializationInfo_GetValue_m_169495960_0((SerializationInfo_t526833679_0 *)L_8, (String_t*)_stringLiteral961688967_0, (Type_t *)L_9, /*hidden argument*/NULL);
V_1 = (KeyValuePair_2U5BU5D_t842258672_0*)((KeyValuePair_2U5BU5D_t842258672_0*)Castclass(L_10, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 14)));
int32_t L_11 = V_0;
if ((((int32_t)L_11) >= ((int32_t)((int32_t)10))))
{
goto IL_0083;
}
}
{
V_0 = (int32_t)((int32_t)10);
}
IL_0083:
{
int32_t L_12 = V_0;
NullCheck((Dictionary_2_t357803672_0 *)__this);
(( void (*) (Dictionary_2_t357803672_0 *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 33)->method)((Dictionary_2_t357803672_0 *)__this, (int32_t)L_12, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 33));
__this->___count_10 = 0;
KeyValuePair_2U5BU5D_t842258672_0* L_13 = V_1;
if (!L_13)
{
goto IL_00c9;
}
}
{
V_2 = (int32_t)0;
goto IL_00c0;
}
IL_009e:
{
KeyValuePair_2U5BU5D_t842258672_0* L_14 = V_1;
int32_t L_15 = V_2;
NullCheck(L_14);
IL2CPP_ARRAY_BOUNDS_CHECK(L_14, L_15);
Object_t * L_16 = (( Object_t * (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)((KeyValuePair_2_t742775054_0 *)((KeyValuePair_2_t742775054_0 *)(KeyValuePair_2_t742775054_0 *)SZArrayLdElema(L_14, L_15, sizeof(KeyValuePair_2_t742775054_0 ))), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
KeyValuePair_2U5BU5D_t842258672_0* L_17 = V_1;
int32_t L_18 = V_2;
NullCheck(L_17);
IL2CPP_ARRAY_BOUNDS_CHECK(L_17, L_18);
int32_t L_19 = (( int32_t (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11)->method)((KeyValuePair_2_t742775054_0 *)((KeyValuePair_2_t742775054_0 *)(KeyValuePair_2_t742775054_0 *)SZArrayLdElema(L_17, L_18, sizeof(KeyValuePair_2_t742775054_0 ))), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11));
NullCheck((Dictionary_2_t357803672_0 *)__this);
VirtActionInvoker2< Object_t *, int32_t >::Invoke(26 /* System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Add(TKey,TValue) */, (Dictionary_2_t357803672_0 *)__this, (Object_t *)L_16, (int32_t)L_19);
int32_t L_20 = V_2;
V_2 = (int32_t)((int32_t)((int32_t)L_20+(int32_t)1));
}
IL_00c0:
{
int32_t L_21 = V_2;
KeyValuePair_2U5BU5D_t842258672_0* L_22 = V_1;
NullCheck(L_22);
if ((((int32_t)L_21) < ((int32_t)(((int32_t)((int32_t)(((Array_t *)L_22)->max_length)))))))
{
goto IL_009e;
}
}
IL_00c9:
{
int32_t L_23 = (int32_t)(__this->___generation_14);
__this->___generation_14 = ((int32_t)((int32_t)L_23+(int32_t)1));
__this->___serialization_info_13 = (SerializationInfo_t526833679_0 *)NULL;
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::Remove(TKey)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern TypeInfo* Object_t_il2cpp_TypeInfo_var;
extern TypeInfo* Int32_t1628762099_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern "C" bool Dictionary_2_Remove_m778152131_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t * ___key, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
Object_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(0);
Int32_t1628762099_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(8);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
int32_t V_2 = 0;
int32_t V_3 = 0;
Object_t * V_4 = {0};
int32_t V_5 = 0;
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0016;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0016:
{
Object_t* L_2 = (Object_t*)(__this->___hcp_12);
Object_t * L_3 = ___key;
NullCheck((Object_t*)L_2);
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(1 /* System.Int32 System.Collections.Generic.IEqualityComparer`1<System.Object>::GetHashCode(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_2, (Object_t *)L_3);
V_0 = (int32_t)((int32_t)((int32_t)L_4|(int32_t)((int32_t)-2147483648LL)));
int32_t L_5 = V_0;
Int32U5BU5D_t1872284309_0* L_6 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_6);
V_1 = (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_5&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_6)->max_length))))));
Int32U5BU5D_t1872284309_0* L_7 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_8 = V_1;
NullCheck(L_7);
IL2CPP_ARRAY_BOUNDS_CHECK(L_7, L_8);
int32_t L_9 = L_8;
V_2 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_7, L_9, sizeof(int32_t)))-(int32_t)1));
int32_t L_10 = V_2;
if ((!(((uint32_t)L_10) == ((uint32_t)(-1)))))
{
goto IL_004e;
}
}
{
return (bool)0;
}
IL_004e:
{
V_3 = (int32_t)(-1);
}
IL_0050:
{
LinkU5BU5D_t1854582343_0* L_11 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_12 = V_2;
NullCheck(L_11);
IL2CPP_ARRAY_BOUNDS_CHECK(L_11, L_12);
int32_t L_13 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_11, L_12, sizeof(Link_t976230437_0 )))->___HashCode_0);
int32_t L_14 = V_0;
if ((!(((uint32_t)L_13) == ((uint32_t)L_14))))
{
goto IL_0089;
}
}
{
Object_t* L_15 = (Object_t*)(__this->___hcp_12);
ObjectU5BU5D_t1774424924_0* L_16 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_17 = V_2;
NullCheck(L_16);
IL2CPP_ARRAY_BOUNDS_CHECK(L_16, L_17);
int32_t L_18 = L_17;
Object_t * L_19 = ___key;
NullCheck((Object_t*)L_15);
bool L_20 = (bool)InterfaceFuncInvoker2< bool, Object_t *, Object_t * >::Invoke(0 /* System.Boolean System.Collections.Generic.IEqualityComparer`1<System.Object>::Equals(T,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_15, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_16, L_18, sizeof(Object_t *))), (Object_t *)L_19);
if (!L_20)
{
goto IL_0089;
}
}
{
goto IL_00a4;
}
IL_0089:
{
int32_t L_21 = V_2;
V_3 = (int32_t)L_21;
LinkU5BU5D_t1854582343_0* L_22 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_23 = V_2;
NullCheck(L_22);
IL2CPP_ARRAY_BOUNDS_CHECK(L_22, L_23);
int32_t L_24 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_22, L_23, sizeof(Link_t976230437_0 )))->___Next_1);
V_2 = (int32_t)L_24;
int32_t L_25 = V_2;
if ((!(((uint32_t)L_25) == ((uint32_t)(-1)))))
{
goto IL_0050;
}
}
IL_00a4:
{
int32_t L_26 = V_2;
if ((!(((uint32_t)L_26) == ((uint32_t)(-1)))))
{
goto IL_00ad;
}
}
{
return (bool)0;
}
IL_00ad:
{
int32_t L_27 = (int32_t)(__this->___count_10);
__this->___count_10 = ((int32_t)((int32_t)L_27-(int32_t)1));
int32_t L_28 = V_3;
if ((!(((uint32_t)L_28) == ((uint32_t)(-1)))))
{
goto IL_00e2;
}
}
{
Int32U5BU5D_t1872284309_0* L_29 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_30 = V_1;
LinkU5BU5D_t1854582343_0* L_31 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_32 = V_2;
NullCheck(L_31);
IL2CPP_ARRAY_BOUNDS_CHECK(L_31, L_32);
int32_t L_33 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_31, L_32, sizeof(Link_t976230437_0 )))->___Next_1);
NullCheck(L_29);
IL2CPP_ARRAY_BOUNDS_CHECK(L_29, L_30);
*((int32_t*)(int32_t*)SZArrayLdElema(L_29, L_30, sizeof(int32_t))) = (int32_t)((int32_t)((int32_t)L_33+(int32_t)1));
goto IL_0104;
}
IL_00e2:
{
LinkU5BU5D_t1854582343_0* L_34 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_35 = V_3;
NullCheck(L_34);
IL2CPP_ARRAY_BOUNDS_CHECK(L_34, L_35);
LinkU5BU5D_t1854582343_0* L_36 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_37 = V_2;
NullCheck(L_36);
IL2CPP_ARRAY_BOUNDS_CHECK(L_36, L_37);
int32_t L_38 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_36, L_37, sizeof(Link_t976230437_0 )))->___Next_1);
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_34, L_35, sizeof(Link_t976230437_0 )))->___Next_1 = L_38;
}
IL_0104:
{
LinkU5BU5D_t1854582343_0* L_39 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_40 = V_2;
NullCheck(L_39);
IL2CPP_ARRAY_BOUNDS_CHECK(L_39, L_40);
int32_t L_41 = (int32_t)(__this->___emptySlot_9);
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_39, L_40, sizeof(Link_t976230437_0 )))->___Next_1 = L_41;
int32_t L_42 = V_2;
__this->___emptySlot_9 = L_42;
LinkU5BU5D_t1854582343_0* L_43 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_44 = V_2;
NullCheck(L_43);
IL2CPP_ARRAY_BOUNDS_CHECK(L_43, L_44);
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_43, L_44, sizeof(Link_t976230437_0 )))->___HashCode_0 = 0;
ObjectU5BU5D_t1774424924_0* L_45 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_46 = V_2;
Initobj (Object_t_il2cpp_TypeInfo_var, (&V_4));
Object_t * L_47 = V_4;
NullCheck(L_45);
IL2CPP_ARRAY_BOUNDS_CHECK(L_45, L_46);
*((Object_t **)(Object_t **)SZArrayLdElema(L_45, L_46, sizeof(Object_t *))) = (Object_t *)L_47;
Int32U5BU5D_t1872284309_0* L_48 = (Int32U5BU5D_t1872284309_0*)(__this->___valueSlots_7);
int32_t L_49 = V_2;
Initobj (Int32_t1628762099_0_il2cpp_TypeInfo_var, (&V_5));
int32_t L_50 = V_5;
NullCheck(L_48);
IL2CPP_ARRAY_BOUNDS_CHECK(L_48, L_49);
*((int32_t*)(int32_t*)SZArrayLdElema(L_48, L_49, sizeof(int32_t))) = (int32_t)L_50;
int32_t L_51 = (int32_t)(__this->___generation_14);
__this->___generation_14 = ((int32_t)((int32_t)L_51+(int32_t)1));
return (bool)1;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::TryGetValue(TKey,TValue&)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern TypeInfo* Int32_t1628762099_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern "C" bool Dictionary_2_TryGetValue_m_647727258_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t * ___key, int32_t* ___value, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
Int32_t1628762099_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(8);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
int32_t V_2 = 0;
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0016;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0016:
{
Object_t* L_2 = (Object_t*)(__this->___hcp_12);
Object_t * L_3 = ___key;
NullCheck((Object_t*)L_2);
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(1 /* System.Int32 System.Collections.Generic.IEqualityComparer`1<System.Object>::GetHashCode(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_2, (Object_t *)L_3);
V_0 = (int32_t)((int32_t)((int32_t)L_4|(int32_t)((int32_t)-2147483648LL)));
Int32U5BU5D_t1872284309_0* L_5 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_6 = V_0;
Int32U5BU5D_t1872284309_0* L_7 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_7);
NullCheck(L_5);
IL2CPP_ARRAY_BOUNDS_CHECK(L_5, ((int32_t)((int32_t)((int32_t)((int32_t)L_6&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_7)->max_length)))))));
int32_t L_8 = ((int32_t)((int32_t)((int32_t)((int32_t)L_6&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_7)->max_length))))));
V_1 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_5, L_8, sizeof(int32_t)))-(int32_t)1));
goto IL_00a2;
}
IL_0048:
{
LinkU5BU5D_t1854582343_0* L_9 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_10 = V_1;
NullCheck(L_9);
IL2CPP_ARRAY_BOUNDS_CHECK(L_9, L_10);
int32_t L_11 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_9, L_10, sizeof(Link_t976230437_0 )))->___HashCode_0);
int32_t L_12 = V_0;
if ((!(((uint32_t)L_11) == ((uint32_t)L_12))))
{
goto IL_0090;
}
}
{
Object_t* L_13 = (Object_t*)(__this->___hcp_12);
ObjectU5BU5D_t1774424924_0* L_14 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_15 = V_1;
NullCheck(L_14);
IL2CPP_ARRAY_BOUNDS_CHECK(L_14, L_15);
int32_t L_16 = L_15;
Object_t * L_17 = ___key;
NullCheck((Object_t*)L_13);
bool L_18 = (bool)InterfaceFuncInvoker2< bool, Object_t *, Object_t * >::Invoke(0 /* System.Boolean System.Collections.Generic.IEqualityComparer`1<System.Object>::Equals(T,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_13, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_14, L_16, sizeof(Object_t *))), (Object_t *)L_17);
if (!L_18)
{
goto IL_0090;
}
}
{
int32_t* L_19 = ___value;
Int32U5BU5D_t1872284309_0* L_20 = (Int32U5BU5D_t1872284309_0*)(__this->___valueSlots_7);
int32_t L_21 = V_1;
NullCheck(L_20);
IL2CPP_ARRAY_BOUNDS_CHECK(L_20, L_21);
int32_t L_22 = L_21;
(*(int32_t*)L_19) = (*(int32_t*)(int32_t*)SZArrayLdElema(L_20, L_22, sizeof(int32_t)));
return (bool)1;
}
IL_0090:
{
LinkU5BU5D_t1854582343_0* L_23 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_24 = V_1;
NullCheck(L_23);
IL2CPP_ARRAY_BOUNDS_CHECK(L_23, L_24);
int32_t L_25 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_23, L_24, sizeof(Link_t976230437_0 )))->___Next_1);
V_1 = (int32_t)L_25;
}
IL_00a2:
{
int32_t L_26 = V_1;
if ((!(((uint32_t)L_26) == ((uint32_t)(-1)))))
{
goto IL_0048;
}
}
{
int32_t* L_27 = ___value;
Initobj (Int32_t1628762099_0_il2cpp_TypeInfo_var, (&V_2));
int32_t L_28 = V_2;
(*(int32_t*)L_27) = L_28;
return (bool)0;
}
}
// System.Collections.Generic.Dictionary`2/KeyCollection<TKey,TValue> System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::get_Keys()
extern "C" KeyCollection_t_1085388090_0 * Dictionary_2_get_Keys_m1386140917_0_gshared (Dictionary_2_t357803672_0 * __this, const MethodInfo* method)
{
{
KeyCollection_t_1085388090_0 * L_0 = (KeyCollection_t_1085388090_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 46));
(( void (*) (KeyCollection_t_1085388090_0 *, Dictionary_2_t357803672_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 47)->method)(L_0, (Dictionary_2_t357803672_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 47));
return L_0;
}
}
// System.Collections.Generic.Dictionary`2/ValueCollection<TKey,TValue> System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::get_Values()
extern "C" ValueCollection_t1488631640_0 * Dictionary_2_get_Values_m_1885244719_0_gshared (Dictionary_2_t357803672_0 * __this, const MethodInfo* method)
{
{
ValueCollection_t1488631640_0 * L_0 = (ValueCollection_t1488631640_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 48));
(( void (*) (ValueCollection_t1488631640_0 *, Dictionary_2_t357803672_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 49)->method)(L_0, (Dictionary_2_t357803672_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 49));
return L_0;
}
}
// TKey System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::ToTKey(System.Object)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern TypeInfo* Type_t_il2cpp_TypeInfo_var;
extern TypeInfo* String_t_il2cpp_TypeInfo_var;
extern TypeInfo* ArgumentException_t1159624695_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern Il2CppCodeGenString* _stringLiteral_367149764_0;
extern "C" Object_t * Dictionary_2_ToTKey_m1498562210_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t * ___key, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
Type_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(3);
String_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(11);
ArgumentException_t1159624695_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(4);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
_stringLiteral_367149764_0 = il2cpp_codegen_string_literal_from_index(502);
s_Il2CppMethodIntialized = true;
}
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0011;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0011:
{
Object_t * L_2 = ___key;
if (((Object_t *)IsInst(L_2, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1))))
{
goto IL_0040;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_3 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 50)), /*hidden argument*/NULL);
NullCheck((Type_t *)L_3);
String_t* L_4 = (String_t*)VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Type::ToString() */, (Type_t *)L_3);
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_5 = String_Concat_m138640077_0(NULL /*static, unused*/, (String_t*)_stringLiteral_367149764_0, (String_t*)L_4, /*hidden argument*/NULL);
ArgumentException_t1159624695_0 * L_6 = (ArgumentException_t1159624695_0 *)il2cpp_codegen_object_new (ArgumentException_t1159624695_0_il2cpp_TypeInfo_var);
ArgumentException__ctor_m732321503_0(L_6, (String_t*)L_5, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_6);
}
IL_0040:
{
Object_t * L_7 = ___key;
return ((Object_t *)Castclass(L_7, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)));
}
}
// TValue System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::ToTValue(System.Object)
extern TypeInfo* Type_t_il2cpp_TypeInfo_var;
extern TypeInfo* Int32_t1628762099_0_il2cpp_TypeInfo_var;
extern TypeInfo* String_t_il2cpp_TypeInfo_var;
extern TypeInfo* ArgumentException_t1159624695_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_367149764_0;
extern Il2CppCodeGenString* _stringLiteral111972721_0;
extern "C" int32_t Dictionary_2_ToTValue_m975543294_0_gshared (Dictionary_2_t357803672_0 * __this, Object_t * ___value, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
Type_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(3);
Int32_t1628762099_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(8);
String_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(11);
ArgumentException_t1159624695_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(4);
_stringLiteral_367149764_0 = il2cpp_codegen_string_literal_from_index(502);
_stringLiteral111972721_0 = il2cpp_codegen_string_literal_from_index(52);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
{
Object_t * L_0 = ___value;
if (L_0)
{
goto IL_0024;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_1 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 51)), /*hidden argument*/NULL);
NullCheck((Type_t *)L_1);
bool L_2 = (bool)VirtFuncInvoker0< bool >::Invoke(33 /* System.Boolean System.Type::get_IsValueType() */, (Type_t *)L_1);
if (L_2)
{
goto IL_0024;
}
}
{
Initobj (Int32_t1628762099_0_il2cpp_TypeInfo_var, (&V_0));
int32_t L_3 = V_0;
return L_3;
}
IL_0024:
{
Object_t * L_4 = ___value;
if (((Object_t *)IsInst(L_4, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5))))
{
goto IL_0053;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_5 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 51)), /*hidden argument*/NULL);
NullCheck((Type_t *)L_5);
String_t* L_6 = (String_t*)VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Type::ToString() */, (Type_t *)L_5);
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_7 = String_Concat_m138640077_0(NULL /*static, unused*/, (String_t*)_stringLiteral_367149764_0, (String_t*)L_6, /*hidden argument*/NULL);
ArgumentException_t1159624695_0 * L_8 = (ArgumentException_t1159624695_0 *)il2cpp_codegen_object_new (ArgumentException_t1159624695_0_il2cpp_TypeInfo_var);
ArgumentException__ctor_m732321503_0(L_8, (String_t*)L_7, (String_t*)_stringLiteral111972721_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_8);
}
IL_0053:
{
Object_t * L_9 = ___value;
return ((*(int32_t*)((int32_t*)UnBox (L_9, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)))));
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::ContainsKeyValuePair(System.Collections.Generic.KeyValuePair`2<TKey,TValue>)
extern "C" bool Dictionary_2_ContainsKeyValuePair_m_937738586_0_gshared (Dictionary_2_t357803672_0 * __this, KeyValuePair_2_t742775054_0 ___pair, const MethodInfo* method)
{
int32_t V_0 = 0;
{
Object_t * L_0 = (( Object_t * (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)((KeyValuePair_2_t742775054_0 *)(&___pair), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
NullCheck((Dictionary_2_t357803672_0 *)__this);
bool L_1 = (bool)VirtFuncInvoker2< bool, Object_t *, int32_t* >::Invoke(31 /* System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::TryGetValue(TKey,TValue&) */, (Dictionary_2_t357803672_0 *)__this, (Object_t *)L_0, (int32_t*)(&V_0));
if (L_1)
{
goto IL_0016;
}
}
{
return (bool)0;
}
IL_0016:
{
IL2CPP_RUNTIME_CLASS_INIT(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 41));
EqualityComparer_1_t164988502_0 * L_2 = (( EqualityComparer_1_t164988502_0 * (*) (Object_t * /* static, unused */, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 40)->method)(NULL /*static, unused*/, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 40));
int32_t L_3 = (( int32_t (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11)->method)((KeyValuePair_2_t742775054_0 *)(&___pair), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11));
int32_t L_4 = V_0;
NullCheck((EqualityComparer_1_t164988502_0 *)L_2);
bool L_5 = (bool)VirtFuncInvoker2< bool, int32_t, int32_t >::Invoke(9 /* System.Boolean System.Collections.Generic.EqualityComparer`1<System.Int32>::Equals(T,T) */, (EqualityComparer_1_t164988502_0 *)L_2, (int32_t)L_3, (int32_t)L_4);
return L_5;
}
}
// System.Collections.Generic.Dictionary`2/Enumerator<TKey,TValue> System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::GetEnumerator()
extern "C" Enumerator_t_1767787419_0 Dictionary_2_GetEnumerator_m1793528067_0_gshared (Dictionary_2_t357803672_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 L_0 = {0};
(( void (*) (Enumerator_t_1767787419_0 *, Dictionary_2_t357803672_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 26)->method)(&L_0, (Dictionary_2_t357803672_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 26));
return L_0;
}
}
// System.Collections.DictionaryEntry System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::<CopyTo>m__0(TKey,TValue)
extern "C" DictionaryEntry_t_1842557272_0 Dictionary_2_U3CCopyToU3Em__0_m_226182470_0_gshared (Object_t * __this /* static, unused */, Object_t * ___key, int32_t ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___key;
int32_t L_1 = ___value;
int32_t L_2 = L_1;
Object_t * L_3 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5), &L_2);
DictionaryEntry_t_1842557272_0 L_4 = {0};
DictionaryEntry__ctor_m_1694295436_0(&L_4, (Object_t *)L_0, (Object_t *)L_3, /*hidden argument*/NULL);
return L_4;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::.ctor(System.Array)
extern "C" void InternalEnumerator_1__ctor_m_1670059401_0_gshared (InternalEnumerator_1_t585243173_0 * __this, Array_t * ___array, const MethodInfo* method)
{
{
Array_t * L_0 = ___array;
__this->___array_0 = L_0;
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::System.Collections.IEnumerator.Reset()
extern "C" void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m_846745143_0_gshared (InternalEnumerator_1_t585243173_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1348796351_0_gshared (InternalEnumerator_1_t585243173_0 * __this, const MethodInfo* method)
{
{
KeyValuePair_2_t742775054_0 L_0 = (( KeyValuePair_2_t742775054_0 (*) (InternalEnumerator_1_t585243173_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((InternalEnumerator_1_t585243173_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
KeyValuePair_2_t742775054_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::Dispose()
extern "C" void InternalEnumerator_1_Dispose_m1793576206_0_gshared (InternalEnumerator_1_t585243173_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::MoveNext()
extern "C" bool InternalEnumerator_1_MoveNext_m1172054137_0_gshared (InternalEnumerator_1_t585243173_0 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t G_B5_0 = 0;
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001e;
}
}
{
Array_t * L_1 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_1);
int32_t L_2 = Array_get_Length_m1203127607_0((Array_t *)L_1, /*hidden argument*/NULL);
__this->___idx_1 = L_2;
}
IL_001e:
{
int32_t L_3 = (int32_t)(__this->___idx_1);
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_0043;
}
}
{
int32_t L_4 = (int32_t)(__this->___idx_1);
int32_t L_5 = (int32_t)((int32_t)((int32_t)L_4-(int32_t)1));
V_0 = (int32_t)L_5;
__this->___idx_1 = L_5;
int32_t L_6 = V_0;
G_B5_0 = ((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0044;
}
IL_0043:
{
G_B5_0 = 0;
}
IL_0044:
{
return (bool)G_B5_0;
}
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::get_Current()
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_673706721_0;
extern Il2CppCodeGenString* _stringLiteral_2097638381_0;
extern "C" KeyValuePair_2_t742775054_0 InternalEnumerator_1_get_Current_m1033564064_0_gshared (InternalEnumerator_1_t585243173_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral_673706721_0 = il2cpp_codegen_string_literal_from_index(193);
_stringLiteral_2097638381_0 = il2cpp_codegen_string_literal_from_index(194);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0018;
}
}
{
InvalidOperationException_t_523179548_0 * L_1 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_1, (String_t*)_stringLiteral_673706721_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0018:
{
int32_t L_2 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_002f;
}
}
{
InvalidOperationException_t_523179548_0 * L_3 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_3, (String_t*)_stringLiteral_2097638381_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
IL_002f:
{
Array_t * L_4 = (Array_t *)(__this->___array_0);
Array_t * L_5 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_5);
int32_t L_6 = Array_get_Length_m1203127607_0((Array_t *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)(__this->___idx_1);
NullCheck((Array_t *)L_4);
KeyValuePair_2_t742775054_0 L_8 = (( KeyValuePair_2_t742775054_0 (*) (Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((Array_t *)L_4, (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_6-(int32_t)1))-(int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
return L_8;
}
}
// System.Void System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>::.ctor(TKey,TValue)
extern "C" void KeyValuePair_2__ctor_m_1564414318_0_gshared (KeyValuePair_2_t742775054_0 * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___key;
(( void (*) (KeyValuePair_2_t742775054_0 *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((KeyValuePair_2_t742775054_0 *)__this, (Object_t *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
int32_t L_1 = ___value;
(( void (*) (KeyValuePair_2_t742775054_0 *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((KeyValuePair_2_t742775054_0 *)__this, (int32_t)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
return;
}
}
// TKey System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>::get_Key()
extern "C" Object_t * KeyValuePair_2_get_Key_m_9395946_0_gshared (KeyValuePair_2_t742775054_0 * __this, const MethodInfo* method)
{
{
Object_t * L_0 = (Object_t *)(__this->___key_0);
return L_0;
}
}
// System.Void System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>::set_Key(TKey)
extern "C" void KeyValuePair_2_set_Key_m1188304983_0_gshared (KeyValuePair_2_t742775054_0 * __this, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___value;
__this->___key_0 = L_0;
return;
}
}
// TValue System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>::get_Value()
extern "C" int32_t KeyValuePair_2_get_Value_m_1604231722_0_gshared (KeyValuePair_2_t742775054_0 * __this, const MethodInfo* method)
{
{
int32_t L_0 = (int32_t)(__this->___value_1);
return L_0;
}
}
// System.Void System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>::set_Value(TValue)
extern "C" void KeyValuePair_2_set_Value_m137193687_0_gshared (KeyValuePair_2_t742775054_0 * __this, int32_t ___value, const MethodInfo* method)
{
{
int32_t L_0 = ___value;
__this->___value_1 = L_0;
return;
}
}
// System.String System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>::ToString()
extern TypeInfo* StringU5BU5D_t_816028754_0_il2cpp_TypeInfo_var;
extern TypeInfo* String_t_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral91_0;
extern Il2CppCodeGenString* _stringLiteral1396_0;
extern Il2CppCodeGenString* _stringLiteral93_0;
extern "C" String_t* KeyValuePair_2_ToString_m2052282219_0_gshared (KeyValuePair_2_t742775054_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
StringU5BU5D_t_816028754_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(32);
String_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(11);
_stringLiteral91_0 = il2cpp_codegen_string_literal_from_index(230);
_stringLiteral1396_0 = il2cpp_codegen_string_literal_from_index(143);
_stringLiteral93_0 = il2cpp_codegen_string_literal_from_index(232);
s_Il2CppMethodIntialized = true;
}
Object_t * V_0 = {0};
int32_t V_1 = 0;
int32_t G_B2_0 = 0;
StringU5BU5D_t_816028754_0* G_B2_1 = {0};
StringU5BU5D_t_816028754_0* G_B2_2 = {0};
int32_t G_B1_0 = 0;
StringU5BU5D_t_816028754_0* G_B1_1 = {0};
StringU5BU5D_t_816028754_0* G_B1_2 = {0};
String_t* G_B3_0 = {0};
int32_t G_B3_1 = 0;
StringU5BU5D_t_816028754_0* G_B3_2 = {0};
StringU5BU5D_t_816028754_0* G_B3_3 = {0};
int32_t G_B5_0 = 0;
StringU5BU5D_t_816028754_0* G_B5_1 = {0};
StringU5BU5D_t_816028754_0* G_B5_2 = {0};
int32_t G_B4_0 = 0;
StringU5BU5D_t_816028754_0* G_B4_1 = {0};
StringU5BU5D_t_816028754_0* G_B4_2 = {0};
String_t* G_B6_0 = {0};
int32_t G_B6_1 = 0;
StringU5BU5D_t_816028754_0* G_B6_2 = {0};
StringU5BU5D_t_816028754_0* G_B6_3 = {0};
{
StringU5BU5D_t_816028754_0* L_0 = (StringU5BU5D_t_816028754_0*)((StringU5BU5D_t_816028754_0*)SZArrayNew(StringU5BU5D_t_816028754_0_il2cpp_TypeInfo_var, (uint32_t)5));
NullCheck(L_0);
IL2CPP_ARRAY_BOUNDS_CHECK(L_0, 0);
ArrayElementTypeCheck (L_0, _stringLiteral91_0);
*((String_t**)(String_t**)SZArrayLdElema(L_0, 0, sizeof(String_t*))) = (String_t*)_stringLiteral91_0;
StringU5BU5D_t_816028754_0* L_1 = (StringU5BU5D_t_816028754_0*)L_0;
Object_t * L_2 = (( Object_t * (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((KeyValuePair_2_t742775054_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
G_B1_0 = 1;
G_B1_1 = L_1;
G_B1_2 = L_1;
if (!L_2)
{
G_B2_0 = 1;
G_B2_1 = L_1;
G_B2_2 = L_1;
goto IL_0039;
}
}
{
Object_t * L_3 = (( Object_t * (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((KeyValuePair_2_t742775054_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
V_0 = (Object_t *)L_3;
NullCheck((Object_t *)(*(&V_0)));
String_t* L_4 = (String_t*)VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, (Object_t *)(*(&V_0)));
G_B3_0 = L_4;
G_B3_1 = G_B1_0;
G_B3_2 = G_B1_1;
G_B3_3 = G_B1_2;
goto IL_003e;
}
IL_0039:
{
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_5 = ((String_t_StaticFields*)String_t_il2cpp_TypeInfo_var->static_fields)->___Empty_2;
G_B3_0 = L_5;
G_B3_1 = G_B2_0;
G_B3_2 = G_B2_1;
G_B3_3 = G_B2_2;
}
IL_003e:
{
NullCheck(G_B3_2);
IL2CPP_ARRAY_BOUNDS_CHECK(G_B3_2, G_B3_1);
ArrayElementTypeCheck (G_B3_2, G_B3_0);
*((String_t**)(String_t**)SZArrayLdElema(G_B3_2, G_B3_1, sizeof(String_t*))) = (String_t*)G_B3_0;
StringU5BU5D_t_816028754_0* L_6 = (StringU5BU5D_t_816028754_0*)G_B3_3;
NullCheck(L_6);
IL2CPP_ARRAY_BOUNDS_CHECK(L_6, 2);
ArrayElementTypeCheck (L_6, _stringLiteral1396_0);
*((String_t**)(String_t**)SZArrayLdElema(L_6, 2, sizeof(String_t*))) = (String_t*)_stringLiteral1396_0;
StringU5BU5D_t_816028754_0* L_7 = (StringU5BU5D_t_816028754_0*)L_6;
int32_t L_8 = (( int32_t (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)((KeyValuePair_2_t742775054_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
G_B4_0 = 3;
G_B4_1 = L_7;
G_B4_2 = L_7;
}
{
int32_t L_9 = (( int32_t (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)((KeyValuePair_2_t742775054_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
V_1 = (int32_t)L_9;
NullCheck((int32_t*)(&V_1));
String_t* L_10 = Int32_ToString_m1286526384_0((int32_t*)(&V_1), NULL);
G_B6_0 = L_10;
G_B6_1 = G_B4_0;
G_B6_2 = G_B4_1;
G_B6_3 = G_B4_2;
goto IL_0077;
}
IL_0072:
{
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_11 = ((String_t_StaticFields*)String_t_il2cpp_TypeInfo_var->static_fields)->___Empty_2;
G_B6_0 = L_11;
G_B6_1 = G_B5_0;
G_B6_2 = G_B5_1;
G_B6_3 = G_B5_2;
}
IL_0077:
{
NullCheck(G_B6_2);
IL2CPP_ARRAY_BOUNDS_CHECK(G_B6_2, G_B6_1);
ArrayElementTypeCheck (G_B6_2, G_B6_0);
*((String_t**)(String_t**)SZArrayLdElema(G_B6_2, G_B6_1, sizeof(String_t*))) = (String_t*)G_B6_0;
StringU5BU5D_t_816028754_0* L_12 = (StringU5BU5D_t_816028754_0*)G_B6_3;
NullCheck(L_12);
IL2CPP_ARRAY_BOUNDS_CHECK(L_12, 4);
ArrayElementTypeCheck (L_12, _stringLiteral93_0);
*((String_t**)(String_t**)SZArrayLdElema(L_12, 4, sizeof(String_t*))) = (String_t*)_stringLiteral93_0;
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_13 = String_Concat_m21867311_0(NULL /*static, unused*/, (StringU5BU5D_t_816028754_0*)L_12, /*hidden argument*/NULL);
return L_13;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Link>::.ctor(System.Array)
extern "C" void InternalEnumerator_1__ctor_m1865178318_0_gshared (InternalEnumerator_1_t1089936814_0 * __this, Array_t * ___array, const MethodInfo* method)
{
{
Array_t * L_0 = ___array;
__this->___array_0 = L_0;
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Link>::System.Collections.IEnumerator.Reset()
extern "C" void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m_1025058286_0_gshared (InternalEnumerator_1_t1089936814_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.Link>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m2101218568_0_gshared (InternalEnumerator_1_t1089936814_0 * __this, const MethodInfo* method)
{
{
Link_t976230437_0 L_0 = (( Link_t976230437_0 (*) (InternalEnumerator_1_t1089936814_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((InternalEnumerator_1_t1089936814_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
Link_t976230437_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.Link>::Dispose()
extern "C" void InternalEnumerator_1_Dispose_m1986195493_0_gshared (InternalEnumerator_1_t1089936814_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.Link>::MoveNext()
extern "C" bool InternalEnumerator_1_MoveNext_m608833986_0_gshared (InternalEnumerator_1_t1089936814_0 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t G_B5_0 = 0;
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001e;
}
}
{
Array_t * L_1 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_1);
int32_t L_2 = Array_get_Length_m1203127607_0((Array_t *)L_1, /*hidden argument*/NULL);
__this->___idx_1 = L_2;
}
IL_001e:
{
int32_t L_3 = (int32_t)(__this->___idx_1);
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_0043;
}
}
{
int32_t L_4 = (int32_t)(__this->___idx_1);
int32_t L_5 = (int32_t)((int32_t)((int32_t)L_4-(int32_t)1));
V_0 = (int32_t)L_5;
__this->___idx_1 = L_5;
int32_t L_6 = V_0;
G_B5_0 = ((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0044;
}
IL_0043:
{
G_B5_0 = 0;
}
IL_0044:
{
return (bool)G_B5_0;
}
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.Link>::get_Current()
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_673706721_0;
extern Il2CppCodeGenString* _stringLiteral_2097638381_0;
extern "C" Link_t976230437_0 InternalEnumerator_1_get_Current_m1839009783_0_gshared (InternalEnumerator_1_t1089936814_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral_673706721_0 = il2cpp_codegen_string_literal_from_index(193);
_stringLiteral_2097638381_0 = il2cpp_codegen_string_literal_from_index(194);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0018;
}
}
{
InvalidOperationException_t_523179548_0 * L_1 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_1, (String_t*)_stringLiteral_673706721_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0018:
{
int32_t L_2 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_002f;
}
}
{
InvalidOperationException_t_523179548_0 * L_3 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_3, (String_t*)_stringLiteral_2097638381_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
IL_002f:
{
Array_t * L_4 = (Array_t *)(__this->___array_0);
Array_t * L_5 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_5);
int32_t L_6 = Array_get_Length_m1203127607_0((Array_t *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)(__this->___idx_1);
NullCheck((Array_t *)L_4);
Link_t976230437_0 L_8 = (( Link_t976230437_0 (*) (Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((Array_t *)L_4, (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_6-(int32_t)1))-(int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
return L_8;
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Int32>::.ctor(System.Collections.Generic.Dictionary`2<TKey,TValue>)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral447049878_0;
extern "C" void KeyCollection__ctor_m2092569765_0_gshared (KeyCollection_t_1085388090_0 * __this, Dictionary_2_t357803672_0 * ___dictionary, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral447049878_0 = il2cpp_codegen_string_literal_from_index(505);
s_Il2CppMethodIntialized = true;
}
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
Dictionary_2_t357803672_0 * L_0 = ___dictionary;
if (L_0)
{
goto IL_0017;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral447049878_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0017:
{
Dictionary_2_t357803672_0 * L_2 = ___dictionary;
__this->___dictionary_0 = L_2;
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Int32>::System.Collections.Generic.ICollection<TKey>.Add(TKey)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2123164782_0;
extern "C" void KeyCollection_System_Collections_Generic_ICollectionU3CTKeyU3E_Add_m199242129_0_gshared (KeyCollection_t_1085388090_0 * __this, Object_t * ___item, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
_stringLiteral2123164782_0 = il2cpp_codegen_string_literal_from_index(506);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m133757637_0(L_0, (String_t*)_stringLiteral2123164782_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Int32>::System.Collections.Generic.ICollection<TKey>.Clear()
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2123164782_0;
extern "C" void KeyCollection_System_Collections_Generic_ICollectionU3CTKeyU3E_Clear_m_352876728_0_gshared (KeyCollection_t_1085388090_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
_stringLiteral2123164782_0 = il2cpp_codegen_string_literal_from_index(506);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m133757637_0(L_0, (String_t*)_stringLiteral2123164782_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Int32>::System.Collections.Generic.ICollection<TKey>.Contains(TKey)
extern "C" bool KeyCollection_System_Collections_Generic_ICollectionU3CTKeyU3E_Contains_m496617181_0_gshared (KeyCollection_t_1085388090_0 * __this, Object_t * ___item, const MethodInfo* method)
{
{
Dictionary_2_t357803672_0 * L_0 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
Object_t * L_1 = ___item;
NullCheck((Dictionary_2_t357803672_0 *)L_0);
bool L_2 = (bool)VirtFuncInvoker1< bool, Object_t * >::Invoke(27 /* System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::ContainsKey(TKey) */, (Dictionary_2_t357803672_0 *)L_0, (Object_t *)L_1);
return L_2;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Int32>::System.Collections.Generic.ICollection<TKey>.Remove(TKey)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2123164782_0;
extern "C" bool KeyCollection_System_Collections_Generic_ICollectionU3CTKeyU3E_Remove_m175393666_0_gshared (KeyCollection_t_1085388090_0 * __this, Object_t * ___item, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
_stringLiteral2123164782_0 = il2cpp_codegen_string_literal_from_index(506);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m133757637_0(L_0, (String_t*)_stringLiteral2123164782_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Collections.Generic.IEnumerator`1<TKey> System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Int32>::System.Collections.Generic.IEnumerable<TKey>.GetEnumerator()
extern "C" Object_t* KeyCollection_System_Collections_Generic_IEnumerableU3CTKeyU3E_GetEnumerator_m_1828032358_0_gshared (KeyCollection_t_1085388090_0 * __this, const MethodInfo* method)
{
{
NullCheck((KeyCollection_t_1085388090_0 *)__this);
Enumerator_t_62634121_0 L_0 = (( Enumerator_t_62634121_0 (*) (KeyCollection_t_1085388090_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((KeyCollection_t_1085388090_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
Enumerator_t_62634121_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), &L_1);
return (Object_t*)L_2;
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Int32>::System.Collections.ICollection.CopyTo(System.Array,System.Int32)
extern "C" void KeyCollection_System_Collections_ICollection_CopyTo_m505462714_0_gshared (KeyCollection_t_1085388090_0 * __this, Array_t * ___array, int32_t ___index, const MethodInfo* method)
{
ObjectU5BU5D_t1774424924_0* V_0 = {0};
{
Array_t * L_0 = ___array;
V_0 = (ObjectU5BU5D_t1774424924_0*)((ObjectU5BU5D_t1774424924_0*)IsInst(L_0, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)));
ObjectU5BU5D_t1774424924_0* L_1 = V_0;
if (!L_1)
{
goto IL_0016;
}
}
{
ObjectU5BU5D_t1774424924_0* L_2 = V_0;
int32_t L_3 = ___index;
NullCheck((KeyCollection_t_1085388090_0 *)__this);
(( void (*) (KeyCollection_t_1085388090_0 *, ObjectU5BU5D_t1774424924_0*, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)((KeyCollection_t_1085388090_0 *)__this, (ObjectU5BU5D_t1774424924_0*)L_2, (int32_t)L_3, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
return;
}
IL_0016:
{
Dictionary_2_t357803672_0 * L_4 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
Array_t * L_5 = ___array;
int32_t L_6 = ___index;
NullCheck((Dictionary_2_t357803672_0 *)L_4);
(( void (*) (Dictionary_2_t357803672_0 *, Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((Dictionary_2_t357803672_0 *)L_4, (Array_t *)L_5, (int32_t)L_6, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
Dictionary_2_t357803672_0 * L_7 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
Array_t * L_8 = ___array;
int32_t L_9 = ___index;
IntPtr_t L_10 = { (void*)IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6) };
Transform_1_t1692641972_0 * L_11 = (Transform_1_t1692641972_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7));
(( void (*) (Transform_1_t1692641972_0 *, Object_t *, IntPtr_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8)->method)(L_11, (Object_t *)NULL, (IntPtr_t)L_10, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8));
NullCheck((Dictionary_2_t357803672_0 *)L_7);
(( void (*) (Dictionary_2_t357803672_0 *, Array_t *, int32_t, Transform_1_t1692641972_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9)->method)((Dictionary_2_t357803672_0 *)L_7, (Array_t *)L_8, (int32_t)L_9, (Transform_1_t1692641972_0 *)L_11, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9));
return;
}
}
// System.Collections.IEnumerator System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Int32>::System.Collections.IEnumerable.GetEnumerator()
extern "C" Object_t * KeyCollection_System_Collections_IEnumerable_GetEnumerator_m_338974519_0_gshared (KeyCollection_t_1085388090_0 * __this, const MethodInfo* method)
{
{
NullCheck((KeyCollection_t_1085388090_0 *)__this);
Enumerator_t_62634121_0 L_0 = (( Enumerator_t_62634121_0 (*) (KeyCollection_t_1085388090_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((KeyCollection_t_1085388090_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
Enumerator_t_62634121_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), &L_1);
return (Object_t *)L_2;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Int32>::System.Collections.Generic.ICollection<TKey>.get_IsReadOnly()
extern "C" bool KeyCollection_System_Collections_Generic_ICollectionU3CTKeyU3E_get_IsReadOnly_m_906167554_0_gshared (KeyCollection_t_1085388090_0 * __this, const MethodInfo* method)
{
{
return (bool)1;
}
}
// System.Object System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Int32>::System.Collections.ICollection.get_SyncRoot()
extern TypeInfo* ICollection_t592284435_0_il2cpp_TypeInfo_var;
extern "C" Object_t * KeyCollection_System_Collections_ICollection_get_SyncRoot_m281315426_0_gshared (KeyCollection_t_1085388090_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ICollection_t592284435_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(184);
s_Il2CppMethodIntialized = true;
}
{
Dictionary_2_t357803672_0 * L_0 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
NullCheck((Object_t *)L_0);
Object_t * L_1 = (Object_t *)InterfaceFuncInvoker0< Object_t * >::Invoke(1 /* System.Object System.Collections.ICollection::get_SyncRoot() */, ICollection_t592284435_0_il2cpp_TypeInfo_var, (Object_t *)L_0);
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Int32>::CopyTo(TKey[],System.Int32)
extern "C" void KeyCollection_CopyTo_m_1204072614_0_gshared (KeyCollection_t_1085388090_0 * __this, ObjectU5BU5D_t1774424924_0* ___array, int32_t ___index, const MethodInfo* method)
{
{
Dictionary_2_t357803672_0 * L_0 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
ObjectU5BU5D_t1774424924_0* L_1 = ___array;
int32_t L_2 = ___index;
NullCheck((Dictionary_2_t357803672_0 *)L_0);
(( void (*) (Dictionary_2_t357803672_0 *, Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((Dictionary_2_t357803672_0 *)L_0, (Array_t *)(Array_t *)L_1, (int32_t)L_2, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
Dictionary_2_t357803672_0 * L_3 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
ObjectU5BU5D_t1774424924_0* L_4 = ___array;
int32_t L_5 = ___index;
IntPtr_t L_6 = { (void*)IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6) };
Transform_1_t1692641972_0 * L_7 = (Transform_1_t1692641972_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7));
(( void (*) (Transform_1_t1692641972_0 *, Object_t *, IntPtr_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8)->method)(L_7, (Object_t *)NULL, (IntPtr_t)L_6, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8));
NullCheck((Dictionary_2_t357803672_0 *)L_3);
(( void (*) (Dictionary_2_t357803672_0 *, ObjectU5BU5D_t1774424924_0*, int32_t, Transform_1_t1692641972_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)((Dictionary_2_t357803672_0 *)L_3, (ObjectU5BU5D_t1774424924_0*)L_4, (int32_t)L_5, (Transform_1_t1692641972_0 *)L_7, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
return;
}
}
// System.Collections.Generic.Dictionary`2/KeyCollection/Enumerator<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Int32>::GetEnumerator()
extern "C" Enumerator_t_62634121_0 KeyCollection_GetEnumerator_m363545767_0_gshared (KeyCollection_t_1085388090_0 * __this, const MethodInfo* method)
{
{
Dictionary_2_t357803672_0 * L_0 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
Enumerator_t_62634121_0 L_1 = {0};
(( void (*) (Enumerator_t_62634121_0 *, Dictionary_2_t357803672_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11)->method)(&L_1, (Dictionary_2_t357803672_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11));
return L_1;
}
}
// System.Int32 System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Int32>::get_Count()
extern "C" int32_t KeyCollection_get_Count_m264049386_0_gshared (KeyCollection_t_1085388090_0 * __this, const MethodInfo* method)
{
{
Dictionary_2_t357803672_0 * L_0 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
NullCheck((Dictionary_2_t357803672_0 *)L_0);
int32_t L_1 = (int32_t)VirtFuncInvoker0< int32_t >::Invoke(9 /* System.Int32 System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::get_Count() */, (Dictionary_2_t357803672_0 *)L_0);
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection/Enumerator<System.Object,System.Int32>::.ctor(System.Collections.Generic.Dictionary`2<TKey,TValue>)
extern "C" void Enumerator__ctor_m_1257419814_0_gshared (Enumerator_t_62634121_0 * __this, Dictionary_2_t357803672_0 * ___host, const MethodInfo* method)
{
{
Dictionary_2_t357803672_0 * L_0 = ___host;
NullCheck((Dictionary_2_t357803672_0 *)L_0);
Enumerator_t_1767787419_0 L_1 = (( Enumerator_t_1767787419_0 (*) (Dictionary_2_t357803672_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Dictionary_2_t357803672_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
__this->___host_enumerator_0 = L_1;
return;
}
}
// System.Object System.Collections.Generic.Dictionary`2/KeyCollection/Enumerator<System.Object,System.Int32>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * Enumerator_System_Collections_IEnumerator_get_Current_m1756520593_0_gshared (Enumerator_t_62634121_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 * L_0 = (Enumerator_t_1767787419_0 *)&(__this->___host_enumerator_0);
Object_t * L_1 = (( Object_t * (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((Enumerator_t_1767787419_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection/Enumerator<System.Object,System.Int32>::System.Collections.IEnumerator.Reset()
extern "C" void Enumerator_System_Collections_IEnumerator_Reset_m566710427_0_gshared (Enumerator_t_62634121_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 * L_0 = (Enumerator_t_1767787419_0 *)&(__this->___host_enumerator_0);
(( void (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((Enumerator_t_1767787419_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection/Enumerator<System.Object,System.Int32>::Dispose()
extern "C" void Enumerator_Dispose_m1759911164_0_gshared (Enumerator_t_62634121_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 * L_0 = (Enumerator_t_1767787419_0 *)&(__this->___host_enumerator_0);
(( void (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)((Enumerator_t_1767787419_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/KeyCollection/Enumerator<System.Object,System.Int32>::MoveNext()
extern "C" bool Enumerator_MoveNext_m1064386891_0_gshared (Enumerator_t_62634121_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 * L_0 = (Enumerator_t_1767787419_0 *)&(__this->___host_enumerator_0);
bool L_1 = (( bool (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((Enumerator_t_1767787419_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
return L_1;
}
}
// TKey System.Collections.Generic.Dictionary`2/KeyCollection/Enumerator<System.Object,System.Int32>::get_Current()
extern "C" Object_t * Enumerator_get_Current_m_1389582867_0_gshared (Enumerator_t_62634121_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 * L_0 = (Enumerator_t_1767787419_0 *)&(__this->___host_enumerator_0);
KeyValuePair_2_t742775054_0 * L_1 = (KeyValuePair_2_t742775054_0 *)&(L_0->___current_3);
Object_t * L_2 = (( Object_t * (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6)->method)((KeyValuePair_2_t742775054_0 *)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6));
return L_2;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Int32>::.ctor(System.Collections.Generic.Dictionary`2<TKey,TValue>)
extern "C" void Enumerator__ctor_m584315628_0_gshared (Enumerator_t_1767787419_0 * __this, Dictionary_2_t357803672_0 * ___dictionary, const MethodInfo* method)
{
{
Dictionary_2_t357803672_0 * L_0 = ___dictionary;
__this->___dictionary_0 = L_0;
Dictionary_2_t357803672_0 * L_1 = ___dictionary;
NullCheck(L_1);
int32_t L_2 = (int32_t)(L_1->___generation_14);
__this->___stamp_2 = L_2;
return;
}
}
// System.Object System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Int32>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * Enumerator_System_Collections_IEnumerator_get_Current_m945293439_0_gshared (Enumerator_t_1767787419_0 * __this, const MethodInfo* method)
{
{
(( void (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Enumerator_t_1767787419_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
KeyValuePair_2_t742775054_0 L_0 = (KeyValuePair_2_t742775054_0 )(__this->___current_3);
KeyValuePair_2_t742775054_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Int32>::System.Collections.IEnumerator.Reset()
extern "C" void Enumerator_System_Collections_IEnumerator_Reset_m_1467866551_0_gshared (Enumerator_t_1767787419_0 * __this, const MethodInfo* method)
{
{
(( void (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((Enumerator_t_1767787419_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
return;
}
}
// System.Collections.DictionaryEntry System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Int32>::System.Collections.IDictionaryEnumerator.get_Entry()
extern "C" DictionaryEntry_t_1842557272_0 Enumerator_System_Collections_IDictionaryEnumerator_get_Entry_m1888707904_0_gshared (Enumerator_t_1767787419_0 * __this, const MethodInfo* method)
{
{
(( void (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Enumerator_t_1767787419_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
KeyValuePair_2_t742775054_0 * L_0 = (KeyValuePair_2_t742775054_0 *)&(__this->___current_3);
Object_t * L_1 = (( Object_t * (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((KeyValuePair_2_t742775054_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
KeyValuePair_2_t742775054_0 * L_2 = (KeyValuePair_2_t742775054_0 *)&(__this->___current_3);
int32_t L_3 = (( int32_t (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((KeyValuePair_2_t742775054_0 *)L_2, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
int32_t L_4 = L_3;
Object_t * L_5 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6), &L_4);
DictionaryEntry_t_1842557272_0 L_6 = {0};
DictionaryEntry__ctor_m_1694295436_0(&L_6, (Object_t *)L_1, (Object_t *)L_5, /*hidden argument*/NULL);
return L_6;
}
}
// System.Object System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Int32>::System.Collections.IDictionaryEnumerator.get_Key()
extern "C" Object_t * Enumerator_System_Collections_IDictionaryEnumerator_get_Key_m_738678245_0_gshared (Enumerator_t_1767787419_0 * __this, const MethodInfo* method)
{
{
Object_t * L_0 = (( Object_t * (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7)->method)((Enumerator_t_1767787419_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7));
return L_0;
}
}
// System.Object System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Int32>::System.Collections.IDictionaryEnumerator.get_Value()
extern "C" Object_t * Enumerator_System_Collections_IDictionaryEnumerator_get_Value_m_151753235_0_gshared (Enumerator_t_1767787419_0 * __this, const MethodInfo* method)
{
{
int32_t L_0 = (( int32_t (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8)->method)((Enumerator_t_1767787419_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8));
int32_t L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6), &L_1);
return L_2;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Int32>::MoveNext()
extern "C" bool Enumerator_MoveNext_m_1520578695_0_gshared (Enumerator_t_1767787419_0 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t V_1 = 0;
{
(( void (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9)->method)((Enumerator_t_1767787419_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9));
int32_t L_0 = (int32_t)(__this->___next_1);
if ((((int32_t)L_0) >= ((int32_t)0)))
{
goto IL_0014;
}
}
{
return (bool)0;
}
IL_0014:
{
goto IL_007b;
}
IL_0019:
{
int32_t L_1 = (int32_t)(__this->___next_1);
int32_t L_2 = (int32_t)L_1;
V_1 = (int32_t)L_2;
__this->___next_1 = ((int32_t)((int32_t)L_2+(int32_t)1));
int32_t L_3 = V_1;
V_0 = (int32_t)L_3;
Dictionary_2_t357803672_0 * L_4 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
NullCheck(L_4);
LinkU5BU5D_t1854582343_0* L_5 = (LinkU5BU5D_t1854582343_0*)(L_4->___linkSlots_5);
int32_t L_6 = V_0;
NullCheck(L_5);
IL2CPP_ARRAY_BOUNDS_CHECK(L_5, L_6);
int32_t L_7 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_5, L_6, sizeof(Link_t976230437_0 )))->___HashCode_0);
if (!((int32_t)((int32_t)L_7&(int32_t)((int32_t)-2147483648LL))))
{
goto IL_007b;
}
}
{
Dictionary_2_t357803672_0 * L_8 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
NullCheck(L_8);
ObjectU5BU5D_t1774424924_0* L_9 = (ObjectU5BU5D_t1774424924_0*)(L_8->___keySlots_6);
int32_t L_10 = V_0;
NullCheck(L_9);
IL2CPP_ARRAY_BOUNDS_CHECK(L_9, L_10);
int32_t L_11 = L_10;
Dictionary_2_t357803672_0 * L_12 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
NullCheck(L_12);
Int32U5BU5D_t1872284309_0* L_13 = (Int32U5BU5D_t1872284309_0*)(L_12->___valueSlots_7);
int32_t L_14 = V_0;
NullCheck(L_13);
IL2CPP_ARRAY_BOUNDS_CHECK(L_13, L_14);
int32_t L_15 = L_14;
KeyValuePair_2_t742775054_0 L_16 = {0};
(( void (*) (KeyValuePair_2_t742775054_0 *, Object_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)(&L_16, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_9, L_11, sizeof(Object_t *))), (int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_13, L_15, sizeof(int32_t))), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
__this->___current_3 = L_16;
return (bool)1;
}
IL_007b:
{
int32_t L_17 = (int32_t)(__this->___next_1);
Dictionary_2_t357803672_0 * L_18 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
NullCheck(L_18);
int32_t L_19 = (int32_t)(L_18->___touchedSlots_8);
if ((((int32_t)L_17) < ((int32_t)L_19)))
{
goto IL_0019;
}
}
{
__this->___next_1 = (-1);
return (bool)0;
}
}
// System.Collections.Generic.KeyValuePair`2<TKey,TValue> System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Int32>::get_Current()
extern "C" KeyValuePair_2_t742775054_0 Enumerator_get_Current_m_1641248093_0_gshared (Enumerator_t_1767787419_0 * __this, const MethodInfo* method)
{
{
KeyValuePair_2_t742775054_0 L_0 = (KeyValuePair_2_t742775054_0 )(__this->___current_3);
return L_0;
}
}
// TKey System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Int32>::get_CurrentKey()
extern "C" Object_t * Enumerator_get_CurrentKey_m2145646402_0_gshared (Enumerator_t_1767787419_0 * __this, const MethodInfo* method)
{
{
(( void (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Enumerator_t_1767787419_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
KeyValuePair_2_t742775054_0 * L_0 = (KeyValuePair_2_t742775054_0 *)&(__this->___current_3);
Object_t * L_1 = (( Object_t * (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((KeyValuePair_2_t742775054_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
return L_1;
}
}
// TValue System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Int32>::get_CurrentValue()
extern "C" int32_t Enumerator_get_CurrentValue_m1809235202_0_gshared (Enumerator_t_1767787419_0 * __this, const MethodInfo* method)
{
{
(( void (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Enumerator_t_1767787419_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
KeyValuePair_2_t742775054_0 * L_0 = (KeyValuePair_2_t742775054_0 *)&(__this->___current_3);
int32_t L_1 = (( int32_t (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((KeyValuePair_2_t742775054_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Int32>::Reset()
extern "C" void Enumerator_Reset_m_288036034_0_gshared (Enumerator_t_1767787419_0 * __this, const MethodInfo* method)
{
{
(( void (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9)->method)((Enumerator_t_1767787419_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9));
__this->___next_1 = 0;
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Int32>::VerifyState()
extern TypeInfo* ObjectDisposedException_t_1490685872_0_il2cpp_TypeInfo_var;
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_4380558_0;
extern "C" void Enumerator_VerifyState_m_636595001_0_gshared (Enumerator_t_1767787419_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ObjectDisposedException_t_1490685872_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(137);
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral_4380558_0 = il2cpp_codegen_string_literal_from_index(503);
s_Il2CppMethodIntialized = true;
}
{
Dictionary_2_t357803672_0 * L_0 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
if (L_0)
{
goto IL_0012;
}
}
{
ObjectDisposedException_t_1490685872_0 * L_1 = (ObjectDisposedException_t_1490685872_0 *)il2cpp_codegen_object_new (ObjectDisposedException_t_1490685872_0_il2cpp_TypeInfo_var);
ObjectDisposedException__ctor_m1180707260_0(L_1, (String_t*)NULL, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0012:
{
Dictionary_2_t357803672_0 * L_2 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
NullCheck(L_2);
int32_t L_3 = (int32_t)(L_2->___generation_14);
int32_t L_4 = (int32_t)(__this->___stamp_2);
if ((((int32_t)L_3) == ((int32_t)L_4)))
{
goto IL_0033;
}
}
{
InvalidOperationException_t_523179548_0 * L_5 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_5, (String_t*)_stringLiteral_4380558_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_5);
}
IL_0033:
{
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Int32>::VerifyCurrent()
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral1609931872_0;
extern "C" void Enumerator_VerifyCurrent_m862431855_0_gshared (Enumerator_t_1767787419_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral1609931872_0 = il2cpp_codegen_string_literal_from_index(504);
s_Il2CppMethodIntialized = true;
}
{
(( void (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9)->method)((Enumerator_t_1767787419_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9));
int32_t L_0 = (int32_t)(__this->___next_1);
if ((((int32_t)L_0) > ((int32_t)0)))
{
goto IL_001d;
}
}
{
InvalidOperationException_t_523179548_0 * L_1 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_1, (String_t*)_stringLiteral1609931872_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_001d:
{
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Int32>::Dispose()
extern "C" void Enumerator_Dispose_m598707342_0_gshared (Enumerator_t_1767787419_0 * __this, const MethodInfo* method)
{
{
__this->___dictionary_0 = (Dictionary_2_t357803672_0 *)NULL;
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Object>::.ctor(System.Object,System.IntPtr)
extern "C" void Transform_1__ctor_m_691925626_0_gshared (Transform_1_t1692641972_0 * __this, Object_t * ___object, IntPtr_t ___method, const MethodInfo* method)
{
__this->___method_ptr_0 = (methodPointerType)((MethodInfo*)___method.___m_value_0)->method;
__this->___method_3 = ___method;
__this->___m_target_2 = ___object;
}
// TRet System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Object>::Invoke(TKey,TValue)
extern "C" Object_t * Transform_1_Invoke_m631029810_0_gshared (Transform_1_t1692641972_0 * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method)
{
if(__this->___prev_9 != NULL)
{
Transform_1_Invoke_m631029810_0((Transform_1_t1692641972_0 *)__this->___prev_9,___key, ___value, method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->___method_3.___m_value_0));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->___method_3.___m_value_0));
if (__this->___m_target_2 != NULL && ___methodIsStatic)
{
typedef Object_t * (*FunctionPointerType) (Object_t *, Object_t * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(NULL,__this->___m_target_2,___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else if (__this->___m_target_2 != NULL || ___methodIsStatic)
{
typedef Object_t * (*FunctionPointerType) (Object_t * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(__this->___m_target_2,___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else
{
typedef Object_t * (*FunctionPointerType) (Object_t * __this, int32_t ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
}
// System.IAsyncResult System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Object>::BeginInvoke(TKey,TValue,System.AsyncCallback,System.Object)
extern TypeInfo* Int32_t1628762099_0_il2cpp_TypeInfo_var;
extern "C" Object_t * Transform_1_BeginInvoke_m2048389981_0_gshared (Transform_1_t1692641972_0 * __this, Object_t * ___key, int32_t ___value, AsyncCallback_t_266361018_0 * ___callback, Object_t * ___object, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
Int32_t1628762099_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(8);
s_Il2CppMethodIntialized = true;
}
void *__d_args[3] = {0};
__d_args[0] = ___key;
__d_args[1] = Box(Int32_t1628762099_0_il2cpp_TypeInfo_var, &___value);
return (Object_t *)il2cpp_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback, (Il2CppObject*)___object);
}
// TRet System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Object>::EndInvoke(System.IAsyncResult)
extern "C" Object_t * Transform_1_EndInvoke_m1212689688_0_gshared (Transform_1_t1692641972_0 * __this, Object_t * ___result, const MethodInfo* method)
{
Il2CppObject *__result = il2cpp_delegate_end_invoke((Il2CppAsyncResult*) ___result, 0);
return (Object_t *)__result;
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Int32>::.ctor(System.Collections.Generic.Dictionary`2<TKey,TValue>)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral447049878_0;
extern "C" void ValueCollection__ctor_m_1762717165_0_gshared (ValueCollection_t1488631640_0 * __this, Dictionary_2_t357803672_0 * ___dictionary, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral447049878_0 = il2cpp_codegen_string_literal_from_index(505);
s_Il2CppMethodIntialized = true;
}
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
Dictionary_2_t357803672_0 * L_0 = ___dictionary;
if (L_0)
{
goto IL_0017;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral447049878_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0017:
{
Dictionary_2_t357803672_0 * L_2 = ___dictionary;
__this->___dictionary_0 = L_2;
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Int32>::System.Collections.Generic.ICollection<TValue>.Add(TValue)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2123164782_0;
extern "C" void ValueCollection_System_Collections_Generic_ICollectionU3CTValueU3E_Add_m1336613823_0_gshared (ValueCollection_t1488631640_0 * __this, int32_t ___item, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
_stringLiteral2123164782_0 = il2cpp_codegen_string_literal_from_index(506);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m133757637_0(L_0, (String_t*)_stringLiteral2123164782_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Int32>::System.Collections.Generic.ICollection<TValue>.Clear()
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2123164782_0;
extern "C" void ValueCollection_System_Collections_Generic_ICollectionU3CTValueU3E_Clear_m_716521464_0_gshared (ValueCollection_t1488631640_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
_stringLiteral2123164782_0 = il2cpp_codegen_string_literal_from_index(506);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m133757637_0(L_0, (String_t*)_stringLiteral2123164782_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Int32>::System.Collections.Generic.ICollection<TValue>.Contains(TValue)
extern "C" bool ValueCollection_System_Collections_Generic_ICollectionU3CTValueU3E_Contains_m559088523_0_gshared (ValueCollection_t1488631640_0 * __this, int32_t ___item, const MethodInfo* method)
{
{
Dictionary_2_t357803672_0 * L_0 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
int32_t L_1 = ___item;
NullCheck((Dictionary_2_t357803672_0 *)L_0);
bool L_2 = (( bool (*) (Dictionary_2_t357803672_0 *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Dictionary_2_t357803672_0 *)L_0, (int32_t)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
return L_2;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Int32>::System.Collections.Generic.ICollection<TValue>.Remove(TValue)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2123164782_0;
extern "C" bool ValueCollection_System_Collections_Generic_ICollectionU3CTValueU3E_Remove_m_878869776_0_gshared (ValueCollection_t1488631640_0 * __this, int32_t ___item, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
_stringLiteral2123164782_0 = il2cpp_codegen_string_literal_from_index(506);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m133757637_0(L_0, (String_t*)_stringLiteral2123164782_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Collections.Generic.IEnumerator`1<TValue> System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Int32>::System.Collections.Generic.IEnumerable<TValue>.GetEnumerator()
extern "C" Object_t* ValueCollection_System_Collections_Generic_IEnumerableU3CTValueU3E_GetEnumerator_m_1616881976_0_gshared (ValueCollection_t1488631640_0 * __this, const MethodInfo* method)
{
{
NullCheck((ValueCollection_t1488631640_0 *)__this);
Enumerator_t_596857947_0 L_0 = (( Enumerator_t_596857947_0 (*) (ValueCollection_t1488631640_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((ValueCollection_t1488631640_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
Enumerator_t_596857947_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), &L_1);
return (Object_t*)L_2;
}
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Int32>::System.Collections.ICollection.CopyTo(System.Array,System.Int32)
extern "C" void ValueCollection_System_Collections_ICollection_CopyTo_m_1170802932_0_gshared (ValueCollection_t1488631640_0 * __this, Array_t * ___array, int32_t ___index, const MethodInfo* method)
{
Int32U5BU5D_t1872284309_0* V_0 = {0};
{
Array_t * L_0 = ___array;
V_0 = (Int32U5BU5D_t1872284309_0*)((Int32U5BU5D_t1872284309_0*)IsInst(L_0, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)));
Int32U5BU5D_t1872284309_0* L_1 = V_0;
if (!L_1)
{
goto IL_0016;
}
}
{
Int32U5BU5D_t1872284309_0* L_2 = V_0;
int32_t L_3 = ___index;
NullCheck((ValueCollection_t1488631640_0 *)__this);
(( void (*) (ValueCollection_t1488631640_0 *, Int32U5BU5D_t1872284309_0*, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)((ValueCollection_t1488631640_0 *)__this, (Int32U5BU5D_t1872284309_0*)L_2, (int32_t)L_3, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
return;
}
IL_0016:
{
Dictionary_2_t357803672_0 * L_4 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
Array_t * L_5 = ___array;
int32_t L_6 = ___index;
NullCheck((Dictionary_2_t357803672_0 *)L_4);
(( void (*) (Dictionary_2_t357803672_0 *, Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((Dictionary_2_t357803672_0 *)L_4, (Array_t *)L_5, (int32_t)L_6, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
Dictionary_2_t357803672_0 * L_7 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
Array_t * L_8 = ___array;
int32_t L_9 = ___index;
IntPtr_t L_10 = { (void*)IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6) };
Transform_1_t2110914299_0 * L_11 = (Transform_1_t2110914299_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7));
(( void (*) (Transform_1_t2110914299_0 *, Object_t *, IntPtr_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8)->method)(L_11, (Object_t *)NULL, (IntPtr_t)L_10, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8));
NullCheck((Dictionary_2_t357803672_0 *)L_7);
(( void (*) (Dictionary_2_t357803672_0 *, Array_t *, int32_t, Transform_1_t2110914299_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9)->method)((Dictionary_2_t357803672_0 *)L_7, (Array_t *)L_8, (int32_t)L_9, (Transform_1_t2110914299_0 *)L_11, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9));
return;
}
}
// System.Collections.IEnumerator System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Int32>::System.Collections.IEnumerable.GetEnumerator()
extern "C" Object_t * ValueCollection_System_Collections_IEnumerable_GetEnumerator_m207982107_0_gshared (ValueCollection_t1488631640_0 * __this, const MethodInfo* method)
{
{
NullCheck((ValueCollection_t1488631640_0 *)__this);
Enumerator_t_596857947_0 L_0 = (( Enumerator_t_596857947_0 (*) (ValueCollection_t1488631640_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((ValueCollection_t1488631640_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
Enumerator_t_596857947_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), &L_1);
return (Object_t *)L_2;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Int32>::System.Collections.Generic.ICollection<TValue>.get_IsReadOnly()
extern "C" bool ValueCollection_System_Collections_Generic_ICollectionU3CTValueU3E_get_IsReadOnly_m_1165735618_0_gshared (ValueCollection_t1488631640_0 * __this, const MethodInfo* method)
{
{
return (bool)1;
}
}
// System.Object System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Int32>::System.Collections.ICollection.get_SyncRoot()
extern TypeInfo* ICollection_t592284435_0_il2cpp_TypeInfo_var;
extern "C" Object_t * ValueCollection_System_Collections_ICollection_get_SyncRoot_m1611904272_0_gshared (ValueCollection_t1488631640_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ICollection_t592284435_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(184);
s_Il2CppMethodIntialized = true;
}
{
Dictionary_2_t357803672_0 * L_0 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
NullCheck((Object_t *)L_0);
Object_t * L_1 = (Object_t *)InterfaceFuncInvoker0< Object_t * >::Invoke(1 /* System.Object System.Collections.ICollection::get_SyncRoot() */, ICollection_t592284435_0_il2cpp_TypeInfo_var, (Object_t *)L_0);
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Int32>::CopyTo(TValue[],System.Int32)
extern "C" void ValueCollection_CopyTo_m_770463334_0_gshared (ValueCollection_t1488631640_0 * __this, Int32U5BU5D_t1872284309_0* ___array, int32_t ___index, const MethodInfo* method)
{
{
Dictionary_2_t357803672_0 * L_0 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
Int32U5BU5D_t1872284309_0* L_1 = ___array;
int32_t L_2 = ___index;
NullCheck((Dictionary_2_t357803672_0 *)L_0);
(( void (*) (Dictionary_2_t357803672_0 *, Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((Dictionary_2_t357803672_0 *)L_0, (Array_t *)(Array_t *)L_1, (int32_t)L_2, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
Dictionary_2_t357803672_0 * L_3 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
Int32U5BU5D_t1872284309_0* L_4 = ___array;
int32_t L_5 = ___index;
IntPtr_t L_6 = { (void*)IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6) };
Transform_1_t2110914299_0 * L_7 = (Transform_1_t2110914299_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7));
(( void (*) (Transform_1_t2110914299_0 *, Object_t *, IntPtr_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8)->method)(L_7, (Object_t *)NULL, (IntPtr_t)L_6, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8));
NullCheck((Dictionary_2_t357803672_0 *)L_3);
(( void (*) (Dictionary_2_t357803672_0 *, Int32U5BU5D_t1872284309_0*, int32_t, Transform_1_t2110914299_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)((Dictionary_2_t357803672_0 *)L_3, (Int32U5BU5D_t1872284309_0*)L_4, (int32_t)L_5, (Transform_1_t2110914299_0 *)L_7, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
return;
}
}
// System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Int32>::GetEnumerator()
extern "C" Enumerator_t_596857947_0 ValueCollection_GetEnumerator_m_1079238781_0_gshared (ValueCollection_t1488631640_0 * __this, const MethodInfo* method)
{
{
Dictionary_2_t357803672_0 * L_0 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
Enumerator_t_596857947_0 L_1 = {0};
(( void (*) (Enumerator_t_596857947_0 *, Dictionary_2_t357803672_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11)->method)(&L_1, (Dictionary_2_t357803672_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11));
return L_1;
}
}
// System.Int32 System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Int32>::get_Count()
extern "C" int32_t ValueCollection_get_Count_m_939815592_0_gshared (ValueCollection_t1488631640_0 * __this, const MethodInfo* method)
{
{
Dictionary_2_t357803672_0 * L_0 = (Dictionary_2_t357803672_0 *)(__this->___dictionary_0);
NullCheck((Dictionary_2_t357803672_0 *)L_0);
int32_t L_1 = (int32_t)VirtFuncInvoker0< int32_t >::Invoke(9 /* System.Int32 System.Collections.Generic.Dictionary`2<System.Object,System.Int32>::get_Count() */, (Dictionary_2_t357803672_0 *)L_0);
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<System.Object,System.Int32>::.ctor(System.Collections.Generic.Dictionary`2<TKey,TValue>)
extern "C" void Enumerator__ctor_m_786612820_0_gshared (Enumerator_t_596857947_0 * __this, Dictionary_2_t357803672_0 * ___host, const MethodInfo* method)
{
{
Dictionary_2_t357803672_0 * L_0 = ___host;
NullCheck((Dictionary_2_t357803672_0 *)L_0);
Enumerator_t_1767787419_0 L_1 = (( Enumerator_t_1767787419_0 (*) (Dictionary_2_t357803672_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Dictionary_2_t357803672_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
__this->___host_enumerator_0 = L_1;
return;
}
}
// System.Object System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<System.Object,System.Int32>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * Enumerator_System_Collections_IEnumerator_get_Current_m_1553200193_0_gshared (Enumerator_t_596857947_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 * L_0 = (Enumerator_t_1767787419_0 *)&(__this->___host_enumerator_0);
int32_t L_1 = (( int32_t (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((Enumerator_t_1767787419_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
int32_t L_2 = L_1;
Object_t * L_3 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), &L_2);
return L_3;
}
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<System.Object,System.Int32>::System.Collections.IEnumerator.Reset()
extern "C" void Enumerator_System_Collections_IEnumerator_Reset_m_1998086263_0_gshared (Enumerator_t_596857947_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 * L_0 = (Enumerator_t_1767787419_0 *)&(__this->___host_enumerator_0);
(( void (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((Enumerator_t_1767787419_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<System.Object,System.Int32>::Dispose()
extern "C" void Enumerator_Dispose_m_2001402034_0_gshared (Enumerator_t_596857947_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 * L_0 = (Enumerator_t_1767787419_0 *)&(__this->___host_enumerator_0);
(( void (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)((Enumerator_t_1767787419_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<System.Object,System.Int32>::MoveNext()
extern "C" bool Enumerator_MoveNext_m803891385_0_gshared (Enumerator_t_596857947_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 * L_0 = (Enumerator_t_1767787419_0 *)&(__this->___host_enumerator_0);
bool L_1 = (( bool (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((Enumerator_t_1767787419_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
return L_1;
}
}
// TValue System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<System.Object,System.Int32>::get_Current()
extern "C" int32_t Enumerator_get_Current_m_88310063_0_gshared (Enumerator_t_596857947_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 * L_0 = (Enumerator_t_1767787419_0 *)&(__this->___host_enumerator_0);
KeyValuePair_2_t742775054_0 * L_1 = (KeyValuePair_2_t742775054_0 *)&(L_0->___current_3);
int32_t L_2 = (( int32_t (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6)->method)((KeyValuePair_2_t742775054_0 *)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6));
return L_2;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Int32>::.ctor(System.Object,System.IntPtr)
extern "C" void Transform_1__ctor_m1991062983_0_gshared (Transform_1_t2110914299_0 * __this, Object_t * ___object, IntPtr_t ___method, const MethodInfo* method)
{
__this->___method_ptr_0 = (methodPointerType)((MethodInfo*)___method.___m_value_0)->method;
__this->___method_3 = ___method;
__this->___m_target_2 = ___object;
}
// TRet System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Int32>::Invoke(TKey,TValue)
extern "C" int32_t Transform_1_Invoke_m_1206064939_0_gshared (Transform_1_t2110914299_0 * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method)
{
if(__this->___prev_9 != NULL)
{
Transform_1_Invoke_m_1206064939_0((Transform_1_t2110914299_0 *)__this->___prev_9,___key, ___value, method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->___method_3.___m_value_0));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->___method_3.___m_value_0));
if (__this->___m_target_2 != NULL && ___methodIsStatic)
{
typedef int32_t (*FunctionPointerType) (Object_t *, Object_t * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(NULL,__this->___m_target_2,___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else if (__this->___m_target_2 != NULL || ___methodIsStatic)
{
typedef int32_t (*FunctionPointerType) (Object_t * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(__this->___m_target_2,___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else
{
typedef int32_t (*FunctionPointerType) (Object_t * __this, int32_t ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
}
// System.IAsyncResult System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Int32>::BeginInvoke(TKey,TValue,System.AsyncCallback,System.Object)
extern TypeInfo* Int32_t1628762099_0_il2cpp_TypeInfo_var;
extern "C" Object_t * Transform_1_BeginInvoke_m573338292_0_gshared (Transform_1_t2110914299_0 * __this, Object_t * ___key, int32_t ___value, AsyncCallback_t_266361018_0 * ___callback, Object_t * ___object, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
Int32_t1628762099_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(8);
s_Il2CppMethodIntialized = true;
}
void *__d_args[3] = {0};
__d_args[0] = ___key;
__d_args[1] = Box(Int32_t1628762099_0_il2cpp_TypeInfo_var, &___value);
return (Object_t *)il2cpp_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback, (Il2CppObject*)___object);
}
// TRet System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Int32>::EndInvoke(System.IAsyncResult)
extern "C" int32_t Transform_1_EndInvoke_m_843362155_0_gshared (Transform_1_t2110914299_0 * __this, Object_t * ___result, const MethodInfo* method)
{
Il2CppObject *__result = il2cpp_delegate_end_invoke((Il2CppAsyncResult*) ___result, 0);
return *(int32_t*)UnBox ((Il2CppCodeGenObject*)__result);
}
// System.Void System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Collections.DictionaryEntry>::.ctor(System.Object,System.IntPtr)
extern "C" void Transform_1__ctor_m641310834_0_gshared (Transform_1_t954325734_0 * __this, Object_t * ___object, IntPtr_t ___method, const MethodInfo* method)
{
__this->___method_ptr_0 = (methodPointerType)((MethodInfo*)___method.___m_value_0)->method;
__this->___method_3 = ___method;
__this->___m_target_2 = ___object;
}
// TRet System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Collections.DictionaryEntry>::Invoke(TKey,TValue)
extern "C" DictionaryEntry_t_1842557272_0 Transform_1_Invoke_m_372510710_0_gshared (Transform_1_t954325734_0 * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method)
{
if(__this->___prev_9 != NULL)
{
Transform_1_Invoke_m_372510710_0((Transform_1_t954325734_0 *)__this->___prev_9,___key, ___value, method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->___method_3.___m_value_0));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->___method_3.___m_value_0));
if (__this->___m_target_2 != NULL && ___methodIsStatic)
{
typedef DictionaryEntry_t_1842557272_0 (*FunctionPointerType) (Object_t *, Object_t * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(NULL,__this->___m_target_2,___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else if (__this->___m_target_2 != NULL || ___methodIsStatic)
{
typedef DictionaryEntry_t_1842557272_0 (*FunctionPointerType) (Object_t * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(__this->___m_target_2,___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else
{
typedef DictionaryEntry_t_1842557272_0 (*FunctionPointerType) (Object_t * __this, int32_t ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
}
// System.IAsyncResult System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Collections.DictionaryEntry>::BeginInvoke(TKey,TValue,System.AsyncCallback,System.Object)
extern TypeInfo* Int32_t1628762099_0_il2cpp_TypeInfo_var;
extern "C" Object_t * Transform_1_BeginInvoke_m_2041648791_0_gshared (Transform_1_t954325734_0 * __this, Object_t * ___key, int32_t ___value, AsyncCallback_t_266361018_0 * ___callback, Object_t * ___object, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
Int32_t1628762099_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(8);
s_Il2CppMethodIntialized = true;
}
void *__d_args[3] = {0};
__d_args[0] = ___key;
__d_args[1] = Box(Int32_t1628762099_0_il2cpp_TypeInfo_var, &___value);
return (Object_t *)il2cpp_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback, (Il2CppObject*)___object);
}
// TRet System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Collections.DictionaryEntry>::EndInvoke(System.IAsyncResult)
extern "C" DictionaryEntry_t_1842557272_0 Transform_1_EndInvoke_m2079925824_0_gshared (Transform_1_t954325734_0 * __this, Object_t * ___result, const MethodInfo* method)
{
Il2CppObject *__result = il2cpp_delegate_end_invoke((Il2CppAsyncResult*) ___result, 0);
return *(DictionaryEntry_t_1842557272_0 *)UnBox ((Il2CppCodeGenObject*)__result);
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::.ctor(System.Array)
extern "C" void InternalEnumerator_1__ctor_m263261269_0_gshared (InternalEnumerator_1_t_771082879_0 * __this, Array_t * ___array, const MethodInfo* method)
{
{
Array_t * L_0 = ___array;
__this->___array_0 = L_0;
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::System.Collections.IEnumerator.Reset()
extern "C" void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m1942345515_0_gshared (InternalEnumerator_1_t_771082879_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m_1466527145_0_gshared (InternalEnumerator_1_t_771082879_0 * __this, const MethodInfo* method)
{
{
DictionaryEntry_t_1842557272_0 L_0 = (( DictionaryEntry_t_1842557272_0 (*) (InternalEnumerator_1_t_771082879_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((InternalEnumerator_1_t_771082879_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
DictionaryEntry_t_1842557272_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::Dispose()
extern "C" void InternalEnumerator_1_Dispose_m1282215020_0_gshared (InternalEnumerator_1_t_771082879_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::MoveNext()
extern "C" bool InternalEnumerator_1_MoveNext_m_264769513_0_gshared (InternalEnumerator_1_t_771082879_0 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t G_B5_0 = 0;
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001e;
}
}
{
Array_t * L_1 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_1);
int32_t L_2 = Array_get_Length_m1203127607_0((Array_t *)L_1, /*hidden argument*/NULL);
__this->___idx_1 = L_2;
}
IL_001e:
{
int32_t L_3 = (int32_t)(__this->___idx_1);
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_0043;
}
}
{
int32_t L_4 = (int32_t)(__this->___idx_1);
int32_t L_5 = (int32_t)((int32_t)((int32_t)L_4-(int32_t)1));
V_0 = (int32_t)L_5;
__this->___idx_1 = L_5;
int32_t L_6 = V_0;
G_B5_0 = ((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0044;
}
IL_0043:
{
G_B5_0 = 0;
}
IL_0044:
{
return (bool)G_B5_0;
}
}
// T System.Array/InternalEnumerator`1<System.Collections.DictionaryEntry>::get_Current()
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_673706721_0;
extern Il2CppCodeGenString* _stringLiteral_2097638381_0;
extern "C" DictionaryEntry_t_1842557272_0 InternalEnumerator_1_get_Current_m_1379624228_0_gshared (InternalEnumerator_1_t_771082879_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral_673706721_0 = il2cpp_codegen_string_literal_from_index(193);
_stringLiteral_2097638381_0 = il2cpp_codegen_string_literal_from_index(194);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0018;
}
}
{
InvalidOperationException_t_523179548_0 * L_1 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_1, (String_t*)_stringLiteral_673706721_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0018:
{
int32_t L_2 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_002f;
}
}
{
InvalidOperationException_t_523179548_0 * L_3 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_3, (String_t*)_stringLiteral_2097638381_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
IL_002f:
{
Array_t * L_4 = (Array_t *)(__this->___array_0);
Array_t * L_5 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_5);
int32_t L_6 = Array_get_Length_m1203127607_0((Array_t *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)(__this->___idx_1);
NullCheck((Array_t *)L_4);
DictionaryEntry_t_1842557272_0 L_8 = (( DictionaryEntry_t_1842557272_0 (*) (Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((Array_t *)L_4, (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_6-(int32_t)1))-(int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
return L_8;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::.ctor(System.Object,System.IntPtr)
extern "C" void Transform_1__ctor_m1506220658_0_gshared (Transform_1_t_252603744_0 * __this, Object_t * ___object, IntPtr_t ___method, const MethodInfo* method)
{
__this->___method_ptr_0 = (methodPointerType)((MethodInfo*)___method.___m_value_0)->method;
__this->___method_3 = ___method;
__this->___m_target_2 = ___object;
}
// TRet System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::Invoke(TKey,TValue)
extern "C" KeyValuePair_2_t742775054_0 Transform_1_Invoke_m417703622_0_gshared (Transform_1_t_252603744_0 * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method)
{
if(__this->___prev_9 != NULL)
{
Transform_1_Invoke_m417703622_0((Transform_1_t_252603744_0 *)__this->___prev_9,___key, ___value, method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->___method_3.___m_value_0));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->___method_3.___m_value_0));
if (__this->___m_target_2 != NULL && ___methodIsStatic)
{
typedef KeyValuePair_2_t742775054_0 (*FunctionPointerType) (Object_t *, Object_t * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(NULL,__this->___m_target_2,___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else if (__this->___m_target_2 != NULL || ___methodIsStatic)
{
typedef KeyValuePair_2_t742775054_0 (*FunctionPointerType) (Object_t * __this, Object_t * ___key, int32_t ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(__this->___m_target_2,___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else
{
typedef KeyValuePair_2_t742775054_0 (*FunctionPointerType) (Object_t * __this, int32_t ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
}
// System.IAsyncResult System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::BeginInvoke(TKey,TValue,System.AsyncCallback,System.Object)
extern TypeInfo* Int32_t1628762099_0_il2cpp_TypeInfo_var;
extern "C" Object_t * Transform_1_BeginInvoke_m1076276209_0_gshared (Transform_1_t_252603744_0 * __this, Object_t * ___key, int32_t ___value, AsyncCallback_t_266361018_0 * ___callback, Object_t * ___object, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
Int32_t1628762099_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(8);
s_Il2CppMethodIntialized = true;
}
void *__d_args[3] = {0};
__d_args[0] = ___key;
__d_args[1] = Box(Int32_t1628762099_0_il2cpp_TypeInfo_var, &___value);
return (Object_t *)il2cpp_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback, (Il2CppObject*)___object);
}
// TRet System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Int32,System.Collections.Generic.KeyValuePair`2<System.Object,System.Int32>>::EndInvoke(System.IAsyncResult)
extern "C" KeyValuePair_2_t742775054_0 Transform_1_EndInvoke_m88547844_0_gshared (Transform_1_t_252603744_0 * __this, Object_t * ___result, const MethodInfo* method)
{
Il2CppObject *__result = il2cpp_delegate_end_invoke((Il2CppAsyncResult*) ___result, 0);
return *(KeyValuePair_2_t742775054_0 *)UnBox ((Il2CppCodeGenObject*)__result);
}
// System.Void System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Int32>::.ctor(System.Collections.Generic.Dictionary`2<TKey,TValue>)
extern "C" void ShimEnumerator__ctor_m1741374067_0_gshared (ShimEnumerator_t375085566_0 * __this, Dictionary_2_t357803672_0 * ___host, const MethodInfo* method)
{
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
Dictionary_2_t357803672_0 * L_0 = ___host;
NullCheck((Dictionary_2_t357803672_0 *)L_0);
Enumerator_t_1767787419_0 L_1 = (( Enumerator_t_1767787419_0 (*) (Dictionary_2_t357803672_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Dictionary_2_t357803672_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
__this->___host_enumerator_0 = L_1;
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Int32>::MoveNext()
extern "C" bool ShimEnumerator_MoveNext_m_871114734_0_gshared (ShimEnumerator_t375085566_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 * L_0 = (Enumerator_t_1767787419_0 *)&(__this->___host_enumerator_0);
bool L_1 = (( bool (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((Enumerator_t_1767787419_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
return L_1;
}
}
// System.Collections.DictionaryEntry System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Int32>::get_Entry()
extern TypeInfo* IDictionaryEnumerator_t_855216337_0_il2cpp_TypeInfo_var;
extern "C" DictionaryEntry_t_1842557272_0 ShimEnumerator_get_Entry_m1072463704_0_gshared (ShimEnumerator_t375085566_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
IDictionaryEnumerator_t_855216337_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(163);
s_Il2CppMethodIntialized = true;
}
{
Enumerator_t_1767787419_0 L_0 = (Enumerator_t_1767787419_0 )(__this->___host_enumerator_0);
Enumerator_t_1767787419_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), &L_1);
NullCheck((Object_t *)L_2);
DictionaryEntry_t_1842557272_0 L_3 = (DictionaryEntry_t_1842557272_0 )InterfaceFuncInvoker0< DictionaryEntry_t_1842557272_0 >::Invoke(0 /* System.Collections.DictionaryEntry System.Collections.IDictionaryEnumerator::get_Entry() */, IDictionaryEnumerator_t_855216337_0_il2cpp_TypeInfo_var, (Object_t *)L_2);
return L_3;
}
}
// System.Object System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Int32>::get_Key()
extern "C" Object_t * ShimEnumerator_get_Key_m_933329001_0_gshared (ShimEnumerator_t375085566_0 * __this, const MethodInfo* method)
{
KeyValuePair_2_t742775054_0 V_0 = {0};
{
Enumerator_t_1767787419_0 * L_0 = (Enumerator_t_1767787419_0 *)&(__this->___host_enumerator_0);
KeyValuePair_2_t742775054_0 L_1 = (( KeyValuePair_2_t742775054_0 (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((Enumerator_t_1767787419_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
V_0 = (KeyValuePair_2_t742775054_0 )L_1;
Object_t * L_2 = (( Object_t * (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)((KeyValuePair_2_t742775054_0 *)(&V_0), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
return L_2;
}
}
// System.Object System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Int32>::get_Value()
extern "C" Object_t * ShimEnumerator_get_Value_m1767431273_0_gshared (ShimEnumerator_t375085566_0 * __this, const MethodInfo* method)
{
KeyValuePair_2_t742775054_0 V_0 = {0};
{
Enumerator_t_1767787419_0 * L_0 = (Enumerator_t_1767787419_0 *)&(__this->___host_enumerator_0);
KeyValuePair_2_t742775054_0 L_1 = (( KeyValuePair_2_t742775054_0 (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((Enumerator_t_1767787419_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
V_0 = (KeyValuePair_2_t742775054_0 )L_1;
int32_t L_2 = (( int32_t (*) (KeyValuePair_2_t742775054_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6)->method)((KeyValuePair_2_t742775054_0 *)(&V_0), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6));
int32_t L_3 = L_2;
Object_t * L_4 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7), &L_3);
return L_4;
}
}
// System.Object System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Int32>::get_Current()
extern TypeInfo* DictionaryEntry_t_1842557272_0_il2cpp_TypeInfo_var;
extern "C" Object_t * ShimEnumerator_get_Current_m_880905039_0_gshared (ShimEnumerator_t375085566_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
DictionaryEntry_t_1842557272_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(195);
s_Il2CppMethodIntialized = true;
}
{
NullCheck((ShimEnumerator_t375085566_0 *)__this);
DictionaryEntry_t_1842557272_0 L_0 = (DictionaryEntry_t_1842557272_0 )VirtFuncInvoker0< DictionaryEntry_t_1842557272_0 >::Invoke(7 /* System.Collections.DictionaryEntry System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Int32>::get_Entry() */, (ShimEnumerator_t375085566_0 *)__this);
DictionaryEntry_t_1842557272_0 L_1 = L_0;
Object_t * L_2 = Box(DictionaryEntry_t_1842557272_0_il2cpp_TypeInfo_var, &L_1);
return L_2;
}
}
// System.Void System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Int32>::Reset()
extern "C" void ShimEnumerator_Reset_m827449413_0_gshared (ShimEnumerator_t375085566_0 * __this, const MethodInfo* method)
{
{
Enumerator_t_1767787419_0 * L_0 = (Enumerator_t_1767787419_0 *)&(__this->___host_enumerator_0);
(( void (*) (Enumerator_t_1767787419_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9)->method)((Enumerator_t_1767787419_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9));
return;
}
}
// System.Void System.Collections.Generic.EqualityComparer`1<System.Int32>::.ctor()
extern "C" void EqualityComparer_1__ctor_m_1672471814_0_gshared (EqualityComparer_1_t164988502_0 * __this, const MethodInfo* method)
{
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Collections.Generic.EqualityComparer`1<System.Int32>::.cctor()
extern const Il2CppType* GenericEqualityComparer_1_t1902543940_0_0_0_0_var;
extern TypeInfo* Type_t_il2cpp_TypeInfo_var;
extern TypeInfo* TypeU5BU5D_t_722972841_0_il2cpp_TypeInfo_var;
extern "C" void EqualityComparer_1__cctor_m_789114893_0_gshared (Object_t * __this /* static, unused */, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
GenericEqualityComparer_1_t1902543940_0_0_0_0_var = il2cpp_codegen_type_from_index(2801);
Type_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(3);
TypeU5BU5D_t_722972841_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(57);
s_Il2CppMethodIntialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_0 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)), /*hidden argument*/NULL);
Type_t * L_1 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)), /*hidden argument*/NULL);
NullCheck((Type_t *)L_0);
bool L_2 = (bool)VirtFuncInvoker1< bool, Type_t * >::Invoke(40 /* System.Boolean System.Type::IsAssignableFrom(System.Type) */, (Type_t *)L_0, (Type_t *)L_1);
if (!L_2)
{
goto IL_0054;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_3 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(GenericEqualityComparer_1_t1902543940_0_0_0_0_var), /*hidden argument*/NULL);
TypeU5BU5D_t_722972841_0* L_4 = (TypeU5BU5D_t_722972841_0*)((TypeU5BU5D_t_722972841_0*)SZArrayNew(TypeU5BU5D_t_722972841_0_il2cpp_TypeInfo_var, (uint32_t)1));
Type_t * L_5 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)), /*hidden argument*/NULL);
NullCheck(L_4);
IL2CPP_ARRAY_BOUNDS_CHECK(L_4, 0);
ArrayElementTypeCheck (L_4, L_5);
*((Type_t **)(Type_t **)SZArrayLdElema(L_4, 0, sizeof(Type_t *))) = (Type_t *)L_5;
NullCheck((Type_t *)L_3);
Type_t * L_6 = (Type_t *)VirtFuncInvoker1< Type_t *, TypeU5BU5D_t_722972841_0* >::Invoke(77 /* System.Type System.Type::MakeGenericType(System.Type[]) */, (Type_t *)L_3, (TypeU5BU5D_t_722972841_0*)L_4);
Object_t * L_7 = Activator_CreateInstance_m1399154923_0(NULL /*static, unused*/, (Type_t *)L_6, /*hidden argument*/NULL);
((EqualityComparer_1_t164988502_0_StaticFields*)IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->static_fields)->____default_0 = ((EqualityComparer_1_t164988502_0 *)Castclass(L_7, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)));
goto IL_005e;
}
IL_0054:
{
DefaultComparer_t1230637941_0 * L_8 = (DefaultComparer_t1230637941_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
(( void (*) (DefaultComparer_t1230637941_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)(L_8, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
((EqualityComparer_1_t164988502_0_StaticFields*)IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->static_fields)->____default_0 = L_8;
}
IL_005e:
{
return;
}
}
// System.Int32 System.Collections.Generic.EqualityComparer`1<System.Int32>::System.Collections.IEqualityComparer.GetHashCode(System.Object)
extern "C" int32_t EqualityComparer_1_System_Collections_IEqualityComparer_GetHashCode_m323315339_0_gshared (EqualityComparer_1_t164988502_0 * __this, Object_t * ___obj, const MethodInfo* method)
{
{
Object_t * L_0 = ___obj;
NullCheck((EqualityComparer_1_t164988502_0 *)__this);
int32_t L_1 = (int32_t)VirtFuncInvoker1< int32_t, int32_t >::Invoke(8 /* System.Int32 System.Collections.Generic.EqualityComparer`1<System.Int32>::GetHashCode(T) */, (EqualityComparer_1_t164988502_0 *)__this, (int32_t)((*(int32_t*)((int32_t*)UnBox (L_0, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6))))));
return L_1;
}
}
// System.Boolean System.Collections.Generic.EqualityComparer`1<System.Int32>::System.Collections.IEqualityComparer.Equals(System.Object,System.Object)
extern "C" bool EqualityComparer_1_System_Collections_IEqualityComparer_Equals_m1837670739_0_gshared (EqualityComparer_1_t164988502_0 * __this, Object_t * ___x, Object_t * ___y, const MethodInfo* method)
{
{
Object_t * L_0 = ___x;
Object_t * L_1 = ___y;
NullCheck((EqualityComparer_1_t164988502_0 *)__this);
bool L_2 = (bool)VirtFuncInvoker2< bool, int32_t, int32_t >::Invoke(9 /* System.Boolean System.Collections.Generic.EqualityComparer`1<System.Int32>::Equals(T,T) */, (EqualityComparer_1_t164988502_0 *)__this, (int32_t)((*(int32_t*)((int32_t*)UnBox (L_0, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6))))), (int32_t)((*(int32_t*)((int32_t*)UnBox (L_1, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6))))));
return L_2;
}
}
// System.Collections.Generic.EqualityComparer`1<T> System.Collections.Generic.EqualityComparer`1<System.Int32>::get_Default()
extern "C" EqualityComparer_1_t164988502_0 * EqualityComparer_1_get_Default_m757577660_0_gshared (Object_t * __this /* static, unused */, const MethodInfo* method)
{
{
IL2CPP_RUNTIME_CLASS_INIT(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
EqualityComparer_1_t164988502_0 * L_0 = ((EqualityComparer_1_t164988502_0_StaticFields*)IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->static_fields)->____default_0;
return L_0;
}
}
// System.Void System.Collections.Generic.GenericEqualityComparer`1<System.Int32>::.ctor()
extern "C" void GenericEqualityComparer_1__ctor_m542716703_0_gshared (GenericEqualityComparer_1_t1098694295_0 * __this, const MethodInfo* method)
{
{
NullCheck((EqualityComparer_1_t164988502_0 *)__this);
IL2CPP_RUNTIME_CLASS_INIT(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
(( void (*) (EqualityComparer_1_t164988502_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((EqualityComparer_1_t164988502_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
return;
}
}
// System.Int32 System.Collections.Generic.GenericEqualityComparer`1<System.Int32>::GetHashCode(T)
extern "C" int32_t GenericEqualityComparer_1_GetHashCode_m_595722324_0_gshared (GenericEqualityComparer_1_t1098694295_0 * __this, int32_t ___obj, const MethodInfo* method)
{
{
int32_t L_0 = ___obj;
goto IL_000d;
}
{
return 0;
}
IL_000d:
{
NullCheck((int32_t*)(&___obj));
int32_t L_1 = Int32_GetHashCode_m_898023850_0((int32_t*)(&___obj), NULL);
return L_1;
}
}
// System.Boolean System.Collections.Generic.GenericEqualityComparer`1<System.Int32>::Equals(T,T)
extern "C" bool GenericEqualityComparer_1_Equals_m_1451217808_0_gshared (GenericEqualityComparer_1_t1098694295_0 * __this, int32_t ___x, int32_t ___y, const MethodInfo* method)
{
{
int32_t L_0 = ___x;
goto IL_0015;
}
{
int32_t L_1 = ___y;
int32_t L_2 = L_1;
Object_t * L_3 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), &L_2);
return (bool)((((Object_t*)(Object_t *)L_3) == ((Object_t*)(Object_t *)NULL))? 1 : 0);
}
IL_0015:
{
int32_t L_4 = ___y;
NullCheck((int32_t*)(&___x));
bool L_5 = Int32_Equals_m_445082829_0((int32_t*)(&___x), (int32_t)L_4, NULL);
return L_5;
}
}
// System.Void System.Collections.Generic.EqualityComparer`1/DefaultComparer<System.Int32>::.ctor()
extern "C" void DefaultComparer__ctor_m1525034683_0_gshared (DefaultComparer_t1230637941_0 * __this, const MethodInfo* method)
{
{
NullCheck((EqualityComparer_1_t164988502_0 *)__this);
IL2CPP_RUNTIME_CLASS_INIT(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
(( void (*) (EqualityComparer_1_t164988502_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((EqualityComparer_1_t164988502_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
return;
}
}
// System.Int32 System.Collections.Generic.EqualityComparer`1/DefaultComparer<System.Int32>::GetHashCode(T)
extern "C" int32_t DefaultComparer_GetHashCode_m_1610079784_0_gshared (DefaultComparer_t1230637941_0 * __this, int32_t ___obj, const MethodInfo* method)
{
{
int32_t L_0 = ___obj;
goto IL_000d;
}
{
return 0;
}
IL_000d:
{
NullCheck((int32_t*)(&___obj));
int32_t L_1 = Int32_GetHashCode_m_898023850_0((int32_t*)(&___obj), NULL);
return L_1;
}
}
// System.Boolean System.Collections.Generic.EqualityComparer`1/DefaultComparer<System.Int32>::Equals(T,T)
extern "C" bool DefaultComparer_Equals_m_773040560_0_gshared (DefaultComparer_t1230637941_0 * __this, int32_t ___x, int32_t ___y, const MethodInfo* method)
{
{
int32_t L_0 = ___x;
goto IL_0015;
}
{
int32_t L_1 = ___y;
int32_t L_2 = L_1;
Object_t * L_3 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), &L_2);
return (bool)((((Object_t*)(Object_t *)L_3) == ((Object_t*)(Object_t *)NULL))? 1 : 0);
}
IL_0015:
{
int32_t L_4 = ___y;
int32_t L_5 = L_4;
Object_t * L_6 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), &L_5);
NullCheck((int32_t*)(&___x));
bool L_7 = Int32_Equals_m_233857038_0((int32_t*)(&___x), (Object_t *)L_6, NULL);
return L_7;
}
}
// System.Void System.Collections.Generic.GenericComparer`1<System.Object>::.ctor()
extern "C" void GenericComparer_1__ctor_m_1396087202_0_gshared (GenericComparer_1_t2120948338_0 * __this, const MethodInfo* method)
{
{
NullCheck((Comparer_1_t_1127613549_0 *)__this);
IL2CPP_RUNTIME_CLASS_INIT(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
(( void (*) (Comparer_1_t_1127613549_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Comparer_1_t_1127613549_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
return;
}
}
// System.Int32 System.Collections.Generic.GenericComparer`1<System.Object>::Compare(T,T)
extern "C" int32_t GenericComparer_1_Compare_m392152793_0_gshared (GenericComparer_1_t2120948338_0 * __this, Object_t * ___x, Object_t * ___y, const MethodInfo* method)
{
int32_t G_B4_0 = 0;
{
Object_t * L_0 = ___x;
if (L_0)
{
goto IL_001e;
}
}
{
Object_t * L_1 = ___y;
if (L_1)
{
goto IL_001c;
}
}
{
G_B4_0 = 0;
goto IL_001d;
}
IL_001c:
{
G_B4_0 = (-1);
}
IL_001d:
{
return G_B4_0;
}
IL_001e:
{
Object_t * L_2 = ___y;
if (L_2)
{
goto IL_002b;
}
}
{
return 1;
}
IL_002b:
{
Object_t * L_3 = ___y;
NullCheck((Object_t*)(*(&___x)));
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(0 /* System.Int32 System.IComparable`1<System.Object>::CompareTo(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3), (Object_t*)(*(&___x)), (Object_t *)L_3);
return L_4;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::.ctor()
extern "C" void Dictionary_2__ctor_m_500328897_0_gshared (Dictionary_2_t_1114179913_0 * __this, const MethodInfo* method)
{
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
(( void (*) (Dictionary_2_t_1114179913_0 *, int32_t, Object_t*, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Dictionary_2_t_1114179913_0 *)__this, (int32_t)((int32_t)10), (Object_t*)NULL, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::.ctor(System.Collections.Generic.IEqualityComparer`1<TKey>)
extern "C" void Dictionary_2__ctor_m273898294_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t* ___comparer, const MethodInfo* method)
{
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
Object_t* L_0 = ___comparer;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
(( void (*) (Dictionary_2_t_1114179913_0 *, int32_t, Object_t*, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Dictionary_2_t_1114179913_0 *)__this, (int32_t)((int32_t)10), (Object_t*)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::.ctor(System.Int32)
extern "C" void Dictionary_2__ctor_m_1790384880_0_gshared (Dictionary_2_t_1114179913_0 * __this, int32_t ___capacity, const MethodInfo* method)
{
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
int32_t L_0 = ___capacity;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
(( void (*) (Dictionary_2_t_1114179913_0 *, int32_t, Object_t*, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Dictionary_2_t_1114179913_0 *)__this, (int32_t)L_0, (Object_t*)NULL, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::.ctor(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
extern "C" void Dictionary_2__ctor_m_132900096_0_gshared (Dictionary_2_t_1114179913_0 * __this, SerializationInfo_t526833679_0 * ___info, StreamingContext_t_1216992900_0 ___context, const MethodInfo* method)
{
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
SerializationInfo_t526833679_0 * L_0 = ___info;
__this->___serialization_info_13 = L_0;
return;
}
}
// System.Object System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.IDictionary.get_Item(System.Object)
extern "C" Object_t * Dictionary_2_System_Collections_IDictionary_get_Item_m1551250025_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___key, const MethodInfo* method)
{
{
Object_t * L_0 = ___key;
if (!((Object_t *)IsInst(L_0, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1))))
{
goto IL_002f;
}
}
{
Object_t * L_1 = ___key;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
bool L_2 = (bool)VirtFuncInvoker1< bool, Object_t * >::Invoke(27 /* System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::ContainsKey(TKey) */, (Dictionary_2_t_1114179913_0 *)__this, (Object_t *)((Object_t *)Castclass(L_1, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1))));
if (!L_2)
{
goto IL_002f;
}
}
{
Object_t * L_3 = ___key;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
Object_t * L_4 = (( Object_t * (*) (Dictionary_2_t_1114179913_0 *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((Dictionary_2_t_1114179913_0 *)__this, (Object_t *)L_3, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
Object_t * L_5 = (Object_t *)VirtFuncInvoker1< Object_t *, Object_t * >::Invoke(24 /* TValue System.Collections.Generic.Dictionary`2<System.Object,System.Object>::get_Item(TKey) */, (Dictionary_2_t_1114179913_0 *)__this, (Object_t *)L_4);
return L_5;
}
IL_002f:
{
return NULL;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.IDictionary.set_Item(System.Object,System.Object)
extern "C" void Dictionary_2_System_Collections_IDictionary_set_Item_m1049066318_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___key;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
Object_t * L_1 = (( Object_t * (*) (Dictionary_2_t_1114179913_0 *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((Dictionary_2_t_1114179913_0 *)__this, (Object_t *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
Object_t * L_2 = ___value;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
Object_t * L_3 = (( Object_t * (*) (Dictionary_2_t_1114179913_0 *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6)->method)((Dictionary_2_t_1114179913_0 *)__this, (Object_t *)L_2, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6));
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
VirtActionInvoker2< Object_t *, Object_t * >::Invoke(25 /* System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::set_Item(TKey,TValue) */, (Dictionary_2_t_1114179913_0 *)__this, (Object_t *)L_1, (Object_t *)L_3);
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.IDictionary.Add(System.Object,System.Object)
extern "C" void Dictionary_2_System_Collections_IDictionary_Add_m781609539_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___key;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
Object_t * L_1 = (( Object_t * (*) (Dictionary_2_t_1114179913_0 *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((Dictionary_2_t_1114179913_0 *)__this, (Object_t *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
Object_t * L_2 = ___value;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
Object_t * L_3 = (( Object_t * (*) (Dictionary_2_t_1114179913_0 *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6)->method)((Dictionary_2_t_1114179913_0 *)__this, (Object_t *)L_2, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6));
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
VirtActionInvoker2< Object_t *, Object_t * >::Invoke(26 /* System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Add(TKey,TValue) */, (Dictionary_2_t_1114179913_0 *)__this, (Object_t *)L_1, (Object_t *)L_3);
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.IDictionary.Contains(System.Object)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern "C" bool Dictionary_2_System_Collections_IDictionary_Contains_m1783363411_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___key, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
s_Il2CppMethodIntialized = true;
}
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0011;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0011:
{
Object_t * L_2 = ___key;
if (!((Object_t *)IsInst(L_2, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1))))
{
goto IL_0029;
}
}
{
Object_t * L_3 = ___key;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
bool L_4 = (bool)VirtFuncInvoker1< bool, Object_t * >::Invoke(27 /* System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::ContainsKey(TKey) */, (Dictionary_2_t_1114179913_0 *)__this, (Object_t *)((Object_t *)Castclass(L_3, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1))));
return L_4;
}
IL_0029:
{
return (bool)0;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.IDictionary.Remove(System.Object)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern "C" void Dictionary_2_System_Collections_IDictionary_Remove_m_2079960692_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___key, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
s_Il2CppMethodIntialized = true;
}
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0011;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0011:
{
Object_t * L_2 = ___key;
if (!((Object_t *)IsInst(L_2, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1))))
{
goto IL_0029;
}
}
{
Object_t * L_3 = ___key;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
VirtFuncInvoker1< bool, Object_t * >::Invoke(30 /* System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Remove(TKey) */, (Dictionary_2_t_1114179913_0 *)__this, (Object_t *)((Object_t *)Castclass(L_3, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1))));
}
IL_0029:
{
return;
}
}
// System.Object System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.ICollection.get_SyncRoot()
extern "C" Object_t * Dictionary_2_System_Collections_ICollection_get_SyncRoot_m2075478797_0_gshared (Dictionary_2_t_1114179913_0 * __this, const MethodInfo* method)
{
{
return __this;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.get_IsReadOnly()
extern "C" bool Dictionary_2_System_Collections_Generic_ICollectionU3CSystem_Collections_Generic_KeyValuePairU3CTKeyU2CTValueU3EU3E_get_IsReadOnly_m1433083365_0_gshared (Dictionary_2_t_1114179913_0 * __this, const MethodInfo* method)
{
{
return (bool)0;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Add(System.Collections.Generic.KeyValuePair`2<TKey,TValue>)
extern "C" void Dictionary_2_System_Collections_Generic_ICollectionU3CSystem_Collections_Generic_KeyValuePairU3CTKeyU2CTValueU3EU3E_Add_m_1037907934_0_gshared (Dictionary_2_t_1114179913_0 * __this, KeyValuePair_2_t_2064968959_0 ___keyValuePair, const MethodInfo* method)
{
{
Object_t * L_0 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)((KeyValuePair_2_t_2064968959_0 *)(&___keyValuePair), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
Object_t * L_1 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11)->method)((KeyValuePair_2_t_2064968959_0 *)(&___keyValuePair), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11));
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
VirtActionInvoker2< Object_t *, Object_t * >::Invoke(26 /* System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Add(TKey,TValue) */, (Dictionary_2_t_1114179913_0 *)__this, (Object_t *)L_0, (Object_t *)L_1);
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Contains(System.Collections.Generic.KeyValuePair`2<TKey,TValue>)
extern "C" bool Dictionary_2_System_Collections_Generic_ICollectionU3CSystem_Collections_Generic_KeyValuePairU3CTKeyU2CTValueU3EU3E_Contains_m_1550917536_0_gshared (Dictionary_2_t_1114179913_0 * __this, KeyValuePair_2_t_2064968959_0 ___keyValuePair, const MethodInfo* method)
{
{
KeyValuePair_2_t_2064968959_0 L_0 = ___keyValuePair;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
bool L_1 = (( bool (*) (Dictionary_2_t_1114179913_0 *, KeyValuePair_2_t_2064968959_0 , const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 12)->method)((Dictionary_2_t_1114179913_0 *)__this, (KeyValuePair_2_t_2064968959_0 )L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 12));
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.CopyTo(System.Collections.Generic.KeyValuePair`2<TKey,TValue>[],System.Int32)
extern "C" void Dictionary_2_System_Collections_Generic_ICollectionU3CSystem_Collections_Generic_KeyValuePairU3CTKeyU2CTValueU3EU3E_CopyTo_m2008986502_0_gshared (Dictionary_2_t_1114179913_0 * __this, KeyValuePair_2U5BU5D_t_160275933_0* ___array, int32_t ___index, const MethodInfo* method)
{
{
KeyValuePair_2U5BU5D_t_160275933_0* L_0 = ___array;
int32_t L_1 = ___index;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
(( void (*) (Dictionary_2_t_1114179913_0 *, KeyValuePair_2U5BU5D_t_160275933_0*, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 13)->method)((Dictionary_2_t_1114179913_0 *)__this, (KeyValuePair_2U5BU5D_t_160275933_0*)L_0, (int32_t)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 13));
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.Generic.ICollection<System.Collections.Generic.KeyValuePair<TKey,TValue>>.Remove(System.Collections.Generic.KeyValuePair`2<TKey,TValue>)
extern "C" bool Dictionary_2_System_Collections_Generic_ICollectionU3CSystem_Collections_Generic_KeyValuePairU3CTKeyU2CTValueU3EU3E_Remove_m_1944477819_0_gshared (Dictionary_2_t_1114179913_0 * __this, KeyValuePair_2_t_2064968959_0 ___keyValuePair, const MethodInfo* method)
{
{
KeyValuePair_2_t_2064968959_0 L_0 = ___keyValuePair;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
bool L_1 = (( bool (*) (Dictionary_2_t_1114179913_0 *, KeyValuePair_2_t_2064968959_0 , const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 12)->method)((Dictionary_2_t_1114179913_0 *)__this, (KeyValuePair_2_t_2064968959_0 )L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 12));
if (L_1)
{
goto IL_000e;
}
}
{
return (bool)0;
}
IL_000e:
{
Object_t * L_2 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)((KeyValuePair_2_t_2064968959_0 *)(&___keyValuePair), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
bool L_3 = (bool)VirtFuncInvoker1< bool, Object_t * >::Invoke(30 /* System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Remove(TKey) */, (Dictionary_2_t_1114179913_0 *)__this, (Object_t *)L_2);
return L_3;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.ICollection.CopyTo(System.Array,System.Int32)
extern TypeInfo* DictionaryEntryU5BU5D_t_1171009526_0_il2cpp_TypeInfo_var;
extern "C" void Dictionary_2_System_Collections_ICollection_CopyTo_m_744163355_0_gshared (Dictionary_2_t_1114179913_0 * __this, Array_t * ___array, int32_t ___index, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
DictionaryEntryU5BU5D_t_1171009526_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2803);
s_Il2CppMethodIntialized = true;
}
KeyValuePair_2U5BU5D_t_160275933_0* V_0 = {0};
DictionaryEntryU5BU5D_t_1171009526_0* V_1 = {0};
int32_t G_B5_0 = 0;
DictionaryEntryU5BU5D_t_1171009526_0* G_B5_1 = {0};
Dictionary_2_t_1114179913_0 * G_B5_2 = {0};
int32_t G_B4_0 = 0;
DictionaryEntryU5BU5D_t_1171009526_0* G_B4_1 = {0};
Dictionary_2_t_1114179913_0 * G_B4_2 = {0};
{
Array_t * L_0 = ___array;
V_0 = (KeyValuePair_2U5BU5D_t_160275933_0*)((KeyValuePair_2U5BU5D_t_160275933_0*)IsInst(L_0, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 14)));
KeyValuePair_2U5BU5D_t_160275933_0* L_1 = V_0;
if (!L_1)
{
goto IL_0016;
}
}
{
KeyValuePair_2U5BU5D_t_160275933_0* L_2 = V_0;
int32_t L_3 = ___index;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
(( void (*) (Dictionary_2_t_1114179913_0 *, KeyValuePair_2U5BU5D_t_160275933_0*, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 13)->method)((Dictionary_2_t_1114179913_0 *)__this, (KeyValuePair_2U5BU5D_t_160275933_0*)L_2, (int32_t)L_3, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 13));
return;
}
IL_0016:
{
Array_t * L_4 = ___array;
int32_t L_5 = ___index;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
(( void (*) (Dictionary_2_t_1114179913_0 *, Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 15)->method)((Dictionary_2_t_1114179913_0 *)__this, (Array_t *)L_4, (int32_t)L_5, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 15));
Array_t * L_6 = ___array;
V_1 = (DictionaryEntryU5BU5D_t_1171009526_0*)((DictionaryEntryU5BU5D_t_1171009526_0*)IsInst(L_6, DictionaryEntryU5BU5D_t_1171009526_0_il2cpp_TypeInfo_var));
DictionaryEntryU5BU5D_t_1171009526_0* L_7 = V_1;
if (!L_7)
{
goto IL_0051;
}
}
{
DictionaryEntryU5BU5D_t_1171009526_0* L_8 = V_1;
int32_t L_9 = ___index;
Transform_1_t1095225411_0 * L_10 = ((Dictionary_2_t_1114179913_0_StaticFields*)IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 16)->static_fields)->___U3CU3Ef__amU24cacheB_15;
G_B4_0 = L_9;
G_B4_1 = L_8;
G_B4_2 = ((Dictionary_2_t_1114179913_0 *)(__this));
if (L_10)
{
G_B5_0 = L_9;
G_B5_1 = L_8;
G_B5_2 = ((Dictionary_2_t_1114179913_0 *)(__this));
goto IL_0046;
}
}
{
IntPtr_t L_11 = { (void*)IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 17) };
Transform_1_t1095225411_0 * L_12 = (Transform_1_t1095225411_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 18));
(( void (*) (Transform_1_t1095225411_0 *, Object_t *, IntPtr_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 19)->method)(L_12, (Object_t *)NULL, (IntPtr_t)L_11, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 19));
((Dictionary_2_t_1114179913_0_StaticFields*)IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 16)->static_fields)->___U3CU3Ef__amU24cacheB_15 = L_12;
G_B5_0 = G_B4_0;
G_B5_1 = G_B4_1;
G_B5_2 = ((Dictionary_2_t_1114179913_0 *)(G_B4_2));
}
IL_0046:
{
Transform_1_t1095225411_0 * L_13 = ((Dictionary_2_t_1114179913_0_StaticFields*)IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 16)->static_fields)->___U3CU3Ef__amU24cacheB_15;
NullCheck((Dictionary_2_t_1114179913_0 *)G_B5_2);
(( void (*) (Dictionary_2_t_1114179913_0 *, DictionaryEntryU5BU5D_t_1171009526_0*, int32_t, Transform_1_t1095225411_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 20)->method)((Dictionary_2_t_1114179913_0 *)G_B5_2, (DictionaryEntryU5BU5D_t_1171009526_0*)G_B5_1, (int32_t)G_B5_0, (Transform_1_t1095225411_0 *)L_13, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 20));
return;
}
IL_0051:
{
Array_t * L_14 = ___array;
int32_t L_15 = ___index;
IntPtr_t L_16 = { (void*)IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 21) };
Transform_1_t1321960586_0 * L_17 = (Transform_1_t1321960586_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 22));
(( void (*) (Transform_1_t1321960586_0 *, Object_t *, IntPtr_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 23)->method)(L_17, (Object_t *)NULL, (IntPtr_t)L_16, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 23));
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
(( void (*) (Dictionary_2_t_1114179913_0 *, Array_t *, int32_t, Transform_1_t1321960586_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 24)->method)((Dictionary_2_t_1114179913_0 *)__this, (Array_t *)L_14, (int32_t)L_15, (Transform_1_t1321960586_0 *)L_17, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 24));
return;
}
}
// System.Collections.IEnumerator System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.IEnumerable.GetEnumerator()
extern "C" Object_t * Dictionary_2_System_Collections_IEnumerable_GetEnumerator_m_179256032_0_gshared (Dictionary_2_t_1114179913_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 L_0 = {0};
(( void (*) (Enumerator_t1711973002_0 *, Dictionary_2_t_1114179913_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 26)->method)(&L_0, (Dictionary_2_t_1114179913_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 26));
Enumerator_t1711973002_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 25), &L_1);
return (Object_t *)L_2;
}
}
// System.Collections.Generic.IEnumerator`1<System.Collections.Generic.KeyValuePair`2<TKey,TValue>> System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.Generic.IEnumerable<System.Collections.Generic.KeyValuePair<TKey,TValue>>.GetEnumerator()
extern "C" Object_t* Dictionary_2_System_Collections_Generic_IEnumerableU3CSystem_Collections_Generic_KeyValuePairU3CTKeyU2CTValueU3EU3E_GetEnumerator_m52259357_0_gshared (Dictionary_2_t_1114179913_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 L_0 = {0};
(( void (*) (Enumerator_t1711973002_0 *, Dictionary_2_t_1114179913_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 26)->method)(&L_0, (Dictionary_2_t_1114179913_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 26));
Enumerator_t1711973002_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 25), &L_1);
return (Object_t*)L_2;
}
}
// System.Collections.IDictionaryEnumerator System.Collections.Generic.Dictionary`2<System.Object,System.Object>::System.Collections.IDictionary.GetEnumerator()
extern "C" Object_t * Dictionary_2_System_Collections_IDictionary_GetEnumerator_m1395730616_0_gshared (Dictionary_2_t_1114179913_0 * __this, const MethodInfo* method)
{
{
ShimEnumerator_t_578441199_0 * L_0 = (ShimEnumerator_t_578441199_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 27));
(( void (*) (ShimEnumerator_t_578441199_0 *, Dictionary_2_t_1114179913_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 28)->method)(L_0, (Dictionary_2_t_1114179913_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 28));
return L_0;
}
}
// System.Int32 System.Collections.Generic.Dictionary`2<System.Object,System.Object>::get_Count()
extern "C" int32_t Dictionary_2_get_Count_m1232250407_0_gshared (Dictionary_2_t_1114179913_0 * __this, const MethodInfo* method)
{
{
int32_t L_0 = (int32_t)(__this->___count_10);
return L_0;
}
}
// TValue System.Collections.Generic.Dictionary`2<System.Object,System.Object>::get_Item(TKey)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern TypeInfo* KeyNotFoundException_t240136748_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern "C" Object_t * Dictionary_2_get_Item_m_2009610012_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___key, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
KeyNotFoundException_t240136748_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2804);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0016;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0016:
{
Object_t* L_2 = (Object_t*)(__this->___hcp_12);
Object_t * L_3 = ___key;
NullCheck((Object_t*)L_2);
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(1 /* System.Int32 System.Collections.Generic.IEqualityComparer`1<System.Object>::GetHashCode(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_2, (Object_t *)L_3);
V_0 = (int32_t)((int32_t)((int32_t)L_4|(int32_t)((int32_t)-2147483648LL)));
Int32U5BU5D_t1872284309_0* L_5 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_6 = V_0;
Int32U5BU5D_t1872284309_0* L_7 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_7);
NullCheck(L_5);
IL2CPP_ARRAY_BOUNDS_CHECK(L_5, ((int32_t)((int32_t)((int32_t)((int32_t)L_6&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_7)->max_length)))))));
int32_t L_8 = ((int32_t)((int32_t)((int32_t)((int32_t)L_6&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_7)->max_length))))));
V_1 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_5, L_8, sizeof(int32_t)))-(int32_t)1));
goto IL_009b;
}
IL_0048:
{
LinkU5BU5D_t1854582343_0* L_9 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_10 = V_1;
NullCheck(L_9);
IL2CPP_ARRAY_BOUNDS_CHECK(L_9, L_10);
int32_t L_11 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_9, L_10, sizeof(Link_t976230437_0 )))->___HashCode_0);
int32_t L_12 = V_0;
if ((!(((uint32_t)L_11) == ((uint32_t)L_12))))
{
goto IL_0089;
}
}
{
Object_t* L_13 = (Object_t*)(__this->___hcp_12);
ObjectU5BU5D_t1774424924_0* L_14 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_15 = V_1;
NullCheck(L_14);
IL2CPP_ARRAY_BOUNDS_CHECK(L_14, L_15);
int32_t L_16 = L_15;
Object_t * L_17 = ___key;
NullCheck((Object_t*)L_13);
bool L_18 = (bool)InterfaceFuncInvoker2< bool, Object_t *, Object_t * >::Invoke(0 /* System.Boolean System.Collections.Generic.IEqualityComparer`1<System.Object>::Equals(T,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_13, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_14, L_16, sizeof(Object_t *))), (Object_t *)L_17);
if (!L_18)
{
goto IL_0089;
}
}
{
ObjectU5BU5D_t1774424924_0* L_19 = (ObjectU5BU5D_t1774424924_0*)(__this->___valueSlots_7);
int32_t L_20 = V_1;
NullCheck(L_19);
IL2CPP_ARRAY_BOUNDS_CHECK(L_19, L_20);
int32_t L_21 = L_20;
return (*(Object_t **)(Object_t **)SZArrayLdElema(L_19, L_21, sizeof(Object_t *)));
}
IL_0089:
{
LinkU5BU5D_t1854582343_0* L_22 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_23 = V_1;
NullCheck(L_22);
IL2CPP_ARRAY_BOUNDS_CHECK(L_22, L_23);
int32_t L_24 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_22, L_23, sizeof(Link_t976230437_0 )))->___Next_1);
V_1 = (int32_t)L_24;
}
IL_009b:
{
int32_t L_25 = V_1;
if ((!(((uint32_t)L_25) == ((uint32_t)(-1)))))
{
goto IL_0048;
}
}
{
KeyNotFoundException_t240136748_0 * L_26 = (KeyNotFoundException_t240136748_0 *)il2cpp_codegen_object_new (KeyNotFoundException_t240136748_0_il2cpp_TypeInfo_var);
KeyNotFoundException__ctor_m_752071836_0(L_26, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_26);
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::set_Item(TKey,TValue)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern "C" void Dictionary_2_set_Item_m_1667075649_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
int32_t V_2 = 0;
int32_t V_3 = 0;
int32_t V_4 = 0;
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0016;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0016:
{
Object_t* L_2 = (Object_t*)(__this->___hcp_12);
Object_t * L_3 = ___key;
NullCheck((Object_t*)L_2);
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(1 /* System.Int32 System.Collections.Generic.IEqualityComparer`1<System.Object>::GetHashCode(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_2, (Object_t *)L_3);
V_0 = (int32_t)((int32_t)((int32_t)L_4|(int32_t)((int32_t)-2147483648LL)));
int32_t L_5 = V_0;
Int32U5BU5D_t1872284309_0* L_6 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_6);
V_1 = (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_5&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_6)->max_length))))));
Int32U5BU5D_t1872284309_0* L_7 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_8 = V_1;
NullCheck(L_7);
IL2CPP_ARRAY_BOUNDS_CHECK(L_7, L_8);
int32_t L_9 = L_8;
V_2 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_7, L_9, sizeof(int32_t)))-(int32_t)1));
V_3 = (int32_t)(-1);
int32_t L_10 = V_2;
if ((((int32_t)L_10) == ((int32_t)(-1))))
{
goto IL_00a2;
}
}
IL_004e:
{
LinkU5BU5D_t1854582343_0* L_11 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_12 = V_2;
NullCheck(L_11);
IL2CPP_ARRAY_BOUNDS_CHECK(L_11, L_12);
int32_t L_13 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_11, L_12, sizeof(Link_t976230437_0 )))->___HashCode_0);
int32_t L_14 = V_0;
if ((!(((uint32_t)L_13) == ((uint32_t)L_14))))
{
goto IL_0087;
}
}
{
Object_t* L_15 = (Object_t*)(__this->___hcp_12);
ObjectU5BU5D_t1774424924_0* L_16 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_17 = V_2;
NullCheck(L_16);
IL2CPP_ARRAY_BOUNDS_CHECK(L_16, L_17);
int32_t L_18 = L_17;
Object_t * L_19 = ___key;
NullCheck((Object_t*)L_15);
bool L_20 = (bool)InterfaceFuncInvoker2< bool, Object_t *, Object_t * >::Invoke(0 /* System.Boolean System.Collections.Generic.IEqualityComparer`1<System.Object>::Equals(T,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_15, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_16, L_18, sizeof(Object_t *))), (Object_t *)L_19);
if (!L_20)
{
goto IL_0087;
}
}
{
goto IL_00a2;
}
IL_0087:
{
int32_t L_21 = V_2;
V_3 = (int32_t)L_21;
LinkU5BU5D_t1854582343_0* L_22 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_23 = V_2;
NullCheck(L_22);
IL2CPP_ARRAY_BOUNDS_CHECK(L_22, L_23);
int32_t L_24 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_22, L_23, sizeof(Link_t976230437_0 )))->___Next_1);
V_2 = (int32_t)L_24;
int32_t L_25 = V_2;
if ((!(((uint32_t)L_25) == ((uint32_t)(-1)))))
{
goto IL_004e;
}
}
IL_00a2:
{
int32_t L_26 = V_2;
if ((!(((uint32_t)L_26) == ((uint32_t)(-1)))))
{
goto IL_0166;
}
}
{
int32_t L_27 = (int32_t)(__this->___count_10);
int32_t L_28 = (int32_t)((int32_t)((int32_t)L_27+(int32_t)1));
V_4 = (int32_t)L_28;
__this->___count_10 = L_28;
int32_t L_29 = V_4;
int32_t L_30 = (int32_t)(__this->___threshold_11);
if ((((int32_t)L_29) <= ((int32_t)L_30)))
{
goto IL_00de;
}
}
{
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
(( void (*) (Dictionary_2_t_1114179913_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 30)->method)((Dictionary_2_t_1114179913_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 30));
int32_t L_31 = V_0;
Int32U5BU5D_t1872284309_0* L_32 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_32);
V_1 = (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_31&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_32)->max_length))))));
}
IL_00de:
{
int32_t L_33 = (int32_t)(__this->___emptySlot_9);
V_2 = (int32_t)L_33;
int32_t L_34 = V_2;
if ((!(((uint32_t)L_34) == ((uint32_t)(-1)))))
{
goto IL_0105;
}
}
{
int32_t L_35 = (int32_t)(__this->___touchedSlots_8);
int32_t L_36 = (int32_t)L_35;
V_4 = (int32_t)L_36;
__this->___touchedSlots_8 = ((int32_t)((int32_t)L_36+(int32_t)1));
int32_t L_37 = V_4;
V_2 = (int32_t)L_37;
goto IL_011c;
}
IL_0105:
{
LinkU5BU5D_t1854582343_0* L_38 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_39 = V_2;
NullCheck(L_38);
IL2CPP_ARRAY_BOUNDS_CHECK(L_38, L_39);
int32_t L_40 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_38, L_39, sizeof(Link_t976230437_0 )))->___Next_1);
__this->___emptySlot_9 = L_40;
}
IL_011c:
{
LinkU5BU5D_t1854582343_0* L_41 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_42 = V_2;
NullCheck(L_41);
IL2CPP_ARRAY_BOUNDS_CHECK(L_41, L_42);
Int32U5BU5D_t1872284309_0* L_43 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_44 = V_1;
NullCheck(L_43);
IL2CPP_ARRAY_BOUNDS_CHECK(L_43, L_44);
int32_t L_45 = L_44;
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_41, L_42, sizeof(Link_t976230437_0 )))->___Next_1 = ((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_43, L_45, sizeof(int32_t)))-(int32_t)1));
Int32U5BU5D_t1872284309_0* L_46 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_47 = V_1;
int32_t L_48 = V_2;
NullCheck(L_46);
IL2CPP_ARRAY_BOUNDS_CHECK(L_46, L_47);
*((int32_t*)(int32_t*)SZArrayLdElema(L_46, L_47, sizeof(int32_t))) = (int32_t)((int32_t)((int32_t)L_48+(int32_t)1));
LinkU5BU5D_t1854582343_0* L_49 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_50 = V_2;
NullCheck(L_49);
IL2CPP_ARRAY_BOUNDS_CHECK(L_49, L_50);
int32_t L_51 = V_0;
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_49, L_50, sizeof(Link_t976230437_0 )))->___HashCode_0 = L_51;
ObjectU5BU5D_t1774424924_0* L_52 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_53 = V_2;
Object_t * L_54 = ___key;
NullCheck(L_52);
IL2CPP_ARRAY_BOUNDS_CHECK(L_52, L_53);
*((Object_t **)(Object_t **)SZArrayLdElema(L_52, L_53, sizeof(Object_t *))) = (Object_t *)L_54;
goto IL_01b5;
}
IL_0166:
{
int32_t L_55 = V_3;
if ((((int32_t)L_55) == ((int32_t)(-1))))
{
goto IL_01b5;
}
}
{
LinkU5BU5D_t1854582343_0* L_56 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_57 = V_3;
NullCheck(L_56);
IL2CPP_ARRAY_BOUNDS_CHECK(L_56, L_57);
LinkU5BU5D_t1854582343_0* L_58 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_59 = V_2;
NullCheck(L_58);
IL2CPP_ARRAY_BOUNDS_CHECK(L_58, L_59);
int32_t L_60 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_58, L_59, sizeof(Link_t976230437_0 )))->___Next_1);
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_56, L_57, sizeof(Link_t976230437_0 )))->___Next_1 = L_60;
LinkU5BU5D_t1854582343_0* L_61 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_62 = V_2;
NullCheck(L_61);
IL2CPP_ARRAY_BOUNDS_CHECK(L_61, L_62);
Int32U5BU5D_t1872284309_0* L_63 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_64 = V_1;
NullCheck(L_63);
IL2CPP_ARRAY_BOUNDS_CHECK(L_63, L_64);
int32_t L_65 = L_64;
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_61, L_62, sizeof(Link_t976230437_0 )))->___Next_1 = ((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_63, L_65, sizeof(int32_t)))-(int32_t)1));
Int32U5BU5D_t1872284309_0* L_66 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_67 = V_1;
int32_t L_68 = V_2;
NullCheck(L_66);
IL2CPP_ARRAY_BOUNDS_CHECK(L_66, L_67);
*((int32_t*)(int32_t*)SZArrayLdElema(L_66, L_67, sizeof(int32_t))) = (int32_t)((int32_t)((int32_t)L_68+(int32_t)1));
}
IL_01b5:
{
ObjectU5BU5D_t1774424924_0* L_69 = (ObjectU5BU5D_t1774424924_0*)(__this->___valueSlots_7);
int32_t L_70 = V_2;
Object_t * L_71 = ___value;
NullCheck(L_69);
IL2CPP_ARRAY_BOUNDS_CHECK(L_69, L_70);
*((Object_t **)(Object_t **)SZArrayLdElema(L_69, L_70, sizeof(Object_t *))) = (Object_t *)L_71;
int32_t L_72 = (int32_t)(__this->___generation_14);
__this->___generation_14 = ((int32_t)((int32_t)L_72+(int32_t)1));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Init(System.Int32,System.Collections.Generic.IEqualityComparer`1<TKey>)
extern TypeInfo* ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_67824454_0;
extern "C" void Dictionary_2_Init_m_1328482889_0_gshared (Dictionary_2_t_1114179913_0 * __this, int32_t ___capacity, Object_t* ___hcp, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(27);
_stringLiteral_67824454_0 = il2cpp_codegen_string_literal_from_index(493);
s_Il2CppMethodIntialized = true;
}
Object_t* V_0 = {0};
Dictionary_2_t_1114179913_0 * G_B4_0 = {0};
Dictionary_2_t_1114179913_0 * G_B3_0 = {0};
Object_t* G_B5_0 = {0};
Dictionary_2_t_1114179913_0 * G_B5_1 = {0};
{
int32_t L_0 = ___capacity;
if ((((int32_t)L_0) >= ((int32_t)0)))
{
goto IL_0012;
}
}
{
ArgumentOutOfRangeException_t_1011290529_0 * L_1 = (ArgumentOutOfRangeException_t_1011290529_0 *)il2cpp_codegen_object_new (ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m2026296331_0(L_1, (String_t*)_stringLiteral_67824454_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0012:
{
Object_t* L_2 = ___hcp;
G_B3_0 = ((Dictionary_2_t_1114179913_0 *)(__this));
if (!L_2)
{
G_B4_0 = ((Dictionary_2_t_1114179913_0 *)(__this));
goto IL_0021;
}
}
{
Object_t* L_3 = ___hcp;
V_0 = (Object_t*)L_3;
Object_t* L_4 = V_0;
G_B5_0 = L_4;
G_B5_1 = ((Dictionary_2_t_1114179913_0 *)(G_B3_0));
goto IL_0026;
}
IL_0021:
{
IL2CPP_RUNTIME_CLASS_INIT(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 32));
EqualityComparer_1_t1498484409_0 * L_5 = (( EqualityComparer_1_t1498484409_0 * (*) (Object_t * /* static, unused */, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 31)->method)(NULL /*static, unused*/, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 31));
G_B5_0 = ((Object_t*)(L_5));
G_B5_1 = ((Dictionary_2_t_1114179913_0 *)(G_B4_0));
}
IL_0026:
{
NullCheck(G_B5_1);
G_B5_1->___hcp_12 = G_B5_0;
int32_t L_6 = ___capacity;
if (L_6)
{
goto IL_0035;
}
}
{
___capacity = (int32_t)((int32_t)10);
}
IL_0035:
{
int32_t L_7 = ___capacity;
___capacity = (int32_t)((int32_t)((int32_t)(((int32_t)((int32_t)((float)((float)(((float)((float)L_7)))/(float)(0.9f))))))+(int32_t)1));
int32_t L_8 = ___capacity;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
(( void (*) (Dictionary_2_t_1114179913_0 *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 33)->method)((Dictionary_2_t_1114179913_0 *)__this, (int32_t)L_8, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 33));
__this->___generation_14 = 0;
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::InitArrays(System.Int32)
extern TypeInfo* Int32U5BU5D_t1872284309_0_il2cpp_TypeInfo_var;
extern TypeInfo* LinkU5BU5D_t1854582343_0_il2cpp_TypeInfo_var;
extern "C" void Dictionary_2_InitArrays_m2119297760_0_gshared (Dictionary_2_t_1114179913_0 * __this, int32_t ___size, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
Int32U5BU5D_t1872284309_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(47);
LinkU5BU5D_t1854582343_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2805);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = ___size;
__this->___table_4 = ((Int32U5BU5D_t1872284309_0*)SZArrayNew(Int32U5BU5D_t1872284309_0_il2cpp_TypeInfo_var, (uint32_t)L_0));
int32_t L_1 = ___size;
__this->___linkSlots_5 = ((LinkU5BU5D_t1854582343_0*)SZArrayNew(LinkU5BU5D_t1854582343_0_il2cpp_TypeInfo_var, (uint32_t)L_1));
__this->___emptySlot_9 = (-1);
int32_t L_2 = ___size;
__this->___keySlots_6 = ((ObjectU5BU5D_t1774424924_0*)SZArrayNew(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 34), (uint32_t)L_2));
int32_t L_3 = ___size;
__this->___valueSlots_7 = ((ObjectU5BU5D_t1774424924_0*)SZArrayNew(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 35), (uint32_t)L_3));
__this->___touchedSlots_8 = 0;
Int32U5BU5D_t1872284309_0* L_4 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_4);
__this->___threshold_11 = (((int32_t)((int32_t)((float)((float)(((float)((float)(((int32_t)((int32_t)(((Array_t *)L_4)->max_length)))))))*(float)(0.9f))))));
int32_t L_5 = (int32_t)(__this->___threshold_11);
if (L_5)
{
goto IL_0074;
}
}
{
Int32U5BU5D_t1872284309_0* L_6 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_6);
if ((((int32_t)(((int32_t)((int32_t)(((Array_t *)L_6)->max_length))))) <= ((int32_t)0)))
{
goto IL_0074;
}
}
{
__this->___threshold_11 = 1;
}
IL_0074:
{
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::CopyToCheck(System.Array,System.Int32)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern TypeInfo* ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var;
extern TypeInfo* ArgumentException_t1159624695_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral93090393_0;
extern Il2CppCodeGenString* _stringLiteral100346066_0;
extern Il2CppCodeGenString* _stringLiteral1142730282_0;
extern Il2CppCodeGenString* _stringLiteral_1492452532_0;
extern "C" void Dictionary_2_CopyToCheck_m_1758445860_0_gshared (Dictionary_2_t_1114179913_0 * __this, Array_t * ___array, int32_t ___index, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(27);
ArgumentException_t1159624695_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(4);
_stringLiteral93090393_0 = il2cpp_codegen_string_literal_from_index(149);
_stringLiteral100346066_0 = il2cpp_codegen_string_literal_from_index(146);
_stringLiteral1142730282_0 = il2cpp_codegen_string_literal_from_index(494);
_stringLiteral_1492452532_0 = il2cpp_codegen_string_literal_from_index(495);
s_Il2CppMethodIntialized = true;
}
{
Array_t * L_0 = ___array;
if (L_0)
{
goto IL_0011;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral93090393_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0011:
{
int32_t L_2 = ___index;
if ((((int32_t)L_2) >= ((int32_t)0)))
{
goto IL_0023;
}
}
{
ArgumentOutOfRangeException_t_1011290529_0 * L_3 = (ArgumentOutOfRangeException_t_1011290529_0 *)il2cpp_codegen_object_new (ArgumentOutOfRangeException_t_1011290529_0_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m2026296331_0(L_3, (String_t*)_stringLiteral100346066_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
IL_0023:
{
int32_t L_4 = ___index;
Array_t * L_5 = ___array;
NullCheck((Array_t *)L_5);
int32_t L_6 = Array_get_Length_m1203127607_0((Array_t *)L_5, /*hidden argument*/NULL);
if ((((int32_t)L_4) <= ((int32_t)L_6)))
{
goto IL_003a;
}
}
{
ArgumentException_t1159624695_0 * L_7 = (ArgumentException_t1159624695_0 *)il2cpp_codegen_object_new (ArgumentException_t1159624695_0_il2cpp_TypeInfo_var);
ArgumentException__ctor_m_750110749_0(L_7, (String_t*)_stringLiteral1142730282_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_7);
}
IL_003a:
{
Array_t * L_8 = ___array;
NullCheck((Array_t *)L_8);
int32_t L_9 = Array_get_Length_m1203127607_0((Array_t *)L_8, /*hidden argument*/NULL);
int32_t L_10 = ___index;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
int32_t L_11 = (int32_t)VirtFuncInvoker0< int32_t >::Invoke(9 /* System.Int32 System.Collections.Generic.Dictionary`2<System.Object,System.Object>::get_Count() */, (Dictionary_2_t_1114179913_0 *)__this);
if ((((int32_t)((int32_t)((int32_t)L_9-(int32_t)L_10))) >= ((int32_t)L_11)))
{
goto IL_0058;
}
}
{
ArgumentException_t1159624695_0 * L_12 = (ArgumentException_t1159624695_0 *)il2cpp_codegen_object_new (ArgumentException_t1159624695_0_il2cpp_TypeInfo_var);
ArgumentException__ctor_m_750110749_0(L_12, (String_t*)_stringLiteral_1492452532_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_12);
}
IL_0058:
{
return;
}
}
// System.Collections.Generic.KeyValuePair`2<TKey,TValue> System.Collections.Generic.Dictionary`2<System.Object,System.Object>::make_pair(TKey,TValue)
extern "C" KeyValuePair_2_t_2064968959_0 Dictionary_2_make_pair_m2083407400_0_gshared (Object_t * __this /* static, unused */, Object_t * ___key, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___key;
Object_t * L_1 = ___value;
KeyValuePair_2_t_2064968959_0 L_2 = {0};
(( void (*) (KeyValuePair_2_t_2064968959_0 *, Object_t *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 38)->method)(&L_2, (Object_t *)L_0, (Object_t *)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 38));
return L_2;
}
}
// TKey System.Collections.Generic.Dictionary`2<System.Object,System.Object>::pick_key(TKey,TValue)
extern "C" Object_t * Dictionary_2_pick_key_m_385873714_0_gshared (Object_t * __this /* static, unused */, Object_t * ___key, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___key;
return L_0;
}
}
// TValue System.Collections.Generic.Dictionary`2<System.Object,System.Object>::pick_value(TKey,TValue)
extern "C" Object_t * Dictionary_2_pick_value_m_817373170_0_gshared (Object_t * __this /* static, unused */, Object_t * ___key, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___value;
return L_0;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::CopyTo(System.Collections.Generic.KeyValuePair`2<TKey,TValue>[],System.Int32)
extern "C" void Dictionary_2_CopyTo_m_893725325_0_gshared (Dictionary_2_t_1114179913_0 * __this, KeyValuePair_2U5BU5D_t_160275933_0* ___array, int32_t ___index, const MethodInfo* method)
{
{
KeyValuePair_2U5BU5D_t_160275933_0* L_0 = ___array;
int32_t L_1 = ___index;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
(( void (*) (Dictionary_2_t_1114179913_0 *, Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 15)->method)((Dictionary_2_t_1114179913_0 *)__this, (Array_t *)(Array_t *)L_0, (int32_t)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 15));
KeyValuePair_2U5BU5D_t_160275933_0* L_2 = ___array;
int32_t L_3 = ___index;
IntPtr_t L_4 = { (void*)IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 21) };
Transform_1_t1321960586_0 * L_5 = (Transform_1_t1321960586_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 22));
(( void (*) (Transform_1_t1321960586_0 *, Object_t *, IntPtr_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 23)->method)(L_5, (Object_t *)NULL, (IntPtr_t)L_4, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 23));
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
(( void (*) (Dictionary_2_t_1114179913_0 *, KeyValuePair_2U5BU5D_t_160275933_0*, int32_t, Transform_1_t1321960586_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 39)->method)((Dictionary_2_t_1114179913_0 *)__this, (KeyValuePair_2U5BU5D_t_160275933_0*)L_2, (int32_t)L_3, (Transform_1_t1321960586_0 *)L_5, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 39));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Resize()
extern TypeInfo* Hashtable_t_2004451924_0_il2cpp_TypeInfo_var;
extern TypeInfo* Int32U5BU5D_t1872284309_0_il2cpp_TypeInfo_var;
extern TypeInfo* LinkU5BU5D_t1854582343_0_il2cpp_TypeInfo_var;
extern "C" void Dictionary_2_Resize_m1727470041_0_gshared (Dictionary_2_t_1114179913_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
Hashtable_t_2004451924_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(196);
Int32U5BU5D_t1872284309_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(47);
LinkU5BU5D_t1854582343_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2805);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
Int32U5BU5D_t1872284309_0* V_1 = {0};
LinkU5BU5D_t1854582343_0* V_2 = {0};
int32_t V_3 = 0;
int32_t V_4 = 0;
int32_t V_5 = 0;
int32_t V_6 = 0;
ObjectU5BU5D_t1774424924_0* V_7 = {0};
ObjectU5BU5D_t1774424924_0* V_8 = {0};
int32_t V_9 = 0;
{
Int32U5BU5D_t1872284309_0* L_0 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_0);
IL2CPP_RUNTIME_CLASS_INIT(Hashtable_t_2004451924_0_il2cpp_TypeInfo_var);
int32_t L_1 = Hashtable_ToPrime_m840372929_0(NULL /*static, unused*/, (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)(((int32_t)((int32_t)(((Array_t *)L_0)->max_length))))<<(int32_t)1))|(int32_t)1)), /*hidden argument*/NULL);
V_0 = (int32_t)L_1;
int32_t L_2 = V_0;
V_1 = (Int32U5BU5D_t1872284309_0*)((Int32U5BU5D_t1872284309_0*)SZArrayNew(Int32U5BU5D_t1872284309_0_il2cpp_TypeInfo_var, (uint32_t)L_2));
int32_t L_3 = V_0;
V_2 = (LinkU5BU5D_t1854582343_0*)((LinkU5BU5D_t1854582343_0*)SZArrayNew(LinkU5BU5D_t1854582343_0_il2cpp_TypeInfo_var, (uint32_t)L_3));
V_3 = (int32_t)0;
goto IL_00b1;
}
IL_0027:
{
Int32U5BU5D_t1872284309_0* L_4 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_5 = V_3;
NullCheck(L_4);
IL2CPP_ARRAY_BOUNDS_CHECK(L_4, L_5);
int32_t L_6 = L_5;
V_4 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_4, L_6, sizeof(int32_t)))-(int32_t)1));
goto IL_00a5;
}
IL_0038:
{
LinkU5BU5D_t1854582343_0* L_7 = V_2;
int32_t L_8 = V_4;
NullCheck(L_7);
IL2CPP_ARRAY_BOUNDS_CHECK(L_7, L_8);
Object_t* L_9 = (Object_t*)(__this->___hcp_12);
ObjectU5BU5D_t1774424924_0* L_10 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_11 = V_4;
NullCheck(L_10);
IL2CPP_ARRAY_BOUNDS_CHECK(L_10, L_11);
int32_t L_12 = L_11;
NullCheck((Object_t*)L_9);
int32_t L_13 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(1 /* System.Int32 System.Collections.Generic.IEqualityComparer`1<System.Object>::GetHashCode(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_9, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_10, L_12, sizeof(Object_t *))));
int32_t L_14 = (int32_t)((int32_t)((int32_t)L_13|(int32_t)((int32_t)-2147483648LL)));
V_9 = (int32_t)L_14;
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_7, L_8, sizeof(Link_t976230437_0 )))->___HashCode_0 = L_14;
int32_t L_15 = V_9;
V_5 = (int32_t)L_15;
int32_t L_16 = V_5;
int32_t L_17 = V_0;
V_6 = (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_16&(int32_t)((int32_t)2147483647LL)))%(int32_t)L_17));
LinkU5BU5D_t1854582343_0* L_18 = V_2;
int32_t L_19 = V_4;
NullCheck(L_18);
IL2CPP_ARRAY_BOUNDS_CHECK(L_18, L_19);
Int32U5BU5D_t1872284309_0* L_20 = V_1;
int32_t L_21 = V_6;
NullCheck(L_20);
IL2CPP_ARRAY_BOUNDS_CHECK(L_20, L_21);
int32_t L_22 = L_21;
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_18, L_19, sizeof(Link_t976230437_0 )))->___Next_1 = ((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_20, L_22, sizeof(int32_t)))-(int32_t)1));
Int32U5BU5D_t1872284309_0* L_23 = V_1;
int32_t L_24 = V_6;
int32_t L_25 = V_4;
NullCheck(L_23);
IL2CPP_ARRAY_BOUNDS_CHECK(L_23, L_24);
*((int32_t*)(int32_t*)SZArrayLdElema(L_23, L_24, sizeof(int32_t))) = (int32_t)((int32_t)((int32_t)L_25+(int32_t)1));
LinkU5BU5D_t1854582343_0* L_26 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_27 = V_4;
NullCheck(L_26);
IL2CPP_ARRAY_BOUNDS_CHECK(L_26, L_27);
int32_t L_28 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_26, L_27, sizeof(Link_t976230437_0 )))->___Next_1);
V_4 = (int32_t)L_28;
}
IL_00a5:
{
int32_t L_29 = V_4;
if ((!(((uint32_t)L_29) == ((uint32_t)(-1)))))
{
goto IL_0038;
}
}
{
int32_t L_30 = V_3;
V_3 = (int32_t)((int32_t)((int32_t)L_30+(int32_t)1));
}
IL_00b1:
{
int32_t L_31 = V_3;
Int32U5BU5D_t1872284309_0* L_32 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_32);
if ((((int32_t)L_31) < ((int32_t)(((int32_t)((int32_t)(((Array_t *)L_32)->max_length)))))))
{
goto IL_0027;
}
}
{
Int32U5BU5D_t1872284309_0* L_33 = V_1;
__this->___table_4 = L_33;
LinkU5BU5D_t1854582343_0* L_34 = V_2;
__this->___linkSlots_5 = L_34;
int32_t L_35 = V_0;
V_7 = (ObjectU5BU5D_t1774424924_0*)((ObjectU5BU5D_t1774424924_0*)SZArrayNew(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 34), (uint32_t)L_35));
int32_t L_36 = V_0;
V_8 = (ObjectU5BU5D_t1774424924_0*)((ObjectU5BU5D_t1774424924_0*)SZArrayNew(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 35), (uint32_t)L_36));
ObjectU5BU5D_t1774424924_0* L_37 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
ObjectU5BU5D_t1774424924_0* L_38 = V_7;
int32_t L_39 = (int32_t)(__this->___touchedSlots_8);
Array_Copy_m_1696350628_0(NULL /*static, unused*/, (Array_t *)(Array_t *)L_37, (int32_t)0, (Array_t *)(Array_t *)L_38, (int32_t)0, (int32_t)L_39, /*hidden argument*/NULL);
ObjectU5BU5D_t1774424924_0* L_40 = (ObjectU5BU5D_t1774424924_0*)(__this->___valueSlots_7);
ObjectU5BU5D_t1774424924_0* L_41 = V_8;
int32_t L_42 = (int32_t)(__this->___touchedSlots_8);
Array_Copy_m_1696350628_0(NULL /*static, unused*/, (Array_t *)(Array_t *)L_40, (int32_t)0, (Array_t *)(Array_t *)L_41, (int32_t)0, (int32_t)L_42, /*hidden argument*/NULL);
ObjectU5BU5D_t1774424924_0* L_43 = V_7;
__this->___keySlots_6 = L_43;
ObjectU5BU5D_t1774424924_0* L_44 = V_8;
__this->___valueSlots_7 = L_44;
int32_t L_45 = V_0;
__this->___threshold_11 = (((int32_t)((int32_t)((float)((float)(((float)((float)L_45)))*(float)(0.9f))))));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Add(TKey,TValue)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern TypeInfo* ArgumentException_t1159624695_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern Il2CppCodeGenString* _stringLiteral628480033_0;
extern "C" void Dictionary_2_Add_m_757779114_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
ArgumentException_t1159624695_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(4);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
_stringLiteral628480033_0 = il2cpp_codegen_string_literal_from_index(497);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
int32_t V_2 = 0;
int32_t V_3 = 0;
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0016;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0016:
{
Object_t* L_2 = (Object_t*)(__this->___hcp_12);
Object_t * L_3 = ___key;
NullCheck((Object_t*)L_2);
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(1 /* System.Int32 System.Collections.Generic.IEqualityComparer`1<System.Object>::GetHashCode(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_2, (Object_t *)L_3);
V_0 = (int32_t)((int32_t)((int32_t)L_4|(int32_t)((int32_t)-2147483648LL)));
int32_t L_5 = V_0;
Int32U5BU5D_t1872284309_0* L_6 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_6);
V_1 = (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_5&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_6)->max_length))))));
Int32U5BU5D_t1872284309_0* L_7 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_8 = V_1;
NullCheck(L_7);
IL2CPP_ARRAY_BOUNDS_CHECK(L_7, L_8);
int32_t L_9 = L_8;
V_2 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_7, L_9, sizeof(int32_t)))-(int32_t)1));
goto IL_009b;
}
IL_004a:
{
LinkU5BU5D_t1854582343_0* L_10 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_11 = V_2;
NullCheck(L_10);
IL2CPP_ARRAY_BOUNDS_CHECK(L_10, L_11);
int32_t L_12 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_10, L_11, sizeof(Link_t976230437_0 )))->___HashCode_0);
int32_t L_13 = V_0;
if ((!(((uint32_t)L_12) == ((uint32_t)L_13))))
{
goto IL_0089;
}
}
{
Object_t* L_14 = (Object_t*)(__this->___hcp_12);
ObjectU5BU5D_t1774424924_0* L_15 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_16 = V_2;
NullCheck(L_15);
IL2CPP_ARRAY_BOUNDS_CHECK(L_15, L_16);
int32_t L_17 = L_16;
Object_t * L_18 = ___key;
NullCheck((Object_t*)L_14);
bool L_19 = (bool)InterfaceFuncInvoker2< bool, Object_t *, Object_t * >::Invoke(0 /* System.Boolean System.Collections.Generic.IEqualityComparer`1<System.Object>::Equals(T,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_14, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_15, L_17, sizeof(Object_t *))), (Object_t *)L_18);
if (!L_19)
{
goto IL_0089;
}
}
{
ArgumentException_t1159624695_0 * L_20 = (ArgumentException_t1159624695_0 *)il2cpp_codegen_object_new (ArgumentException_t1159624695_0_il2cpp_TypeInfo_var);
ArgumentException__ctor_m_750110749_0(L_20, (String_t*)_stringLiteral628480033_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_20);
}
IL_0089:
{
LinkU5BU5D_t1854582343_0* L_21 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_22 = V_2;
NullCheck(L_21);
IL2CPP_ARRAY_BOUNDS_CHECK(L_21, L_22);
int32_t L_23 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_21, L_22, sizeof(Link_t976230437_0 )))->___Next_1);
V_2 = (int32_t)L_23;
}
IL_009b:
{
int32_t L_24 = V_2;
if ((!(((uint32_t)L_24) == ((uint32_t)(-1)))))
{
goto IL_004a;
}
}
{
int32_t L_25 = (int32_t)(__this->___count_10);
int32_t L_26 = (int32_t)((int32_t)((int32_t)L_25+(int32_t)1));
V_3 = (int32_t)L_26;
__this->___count_10 = L_26;
int32_t L_27 = V_3;
int32_t L_28 = (int32_t)(__this->___threshold_11);
if ((((int32_t)L_27) <= ((int32_t)L_28)))
{
goto IL_00d5;
}
}
{
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
(( void (*) (Dictionary_2_t_1114179913_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 30)->method)((Dictionary_2_t_1114179913_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 30));
int32_t L_29 = V_0;
Int32U5BU5D_t1872284309_0* L_30 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_30);
V_1 = (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_29&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_30)->max_length))))));
}
IL_00d5:
{
int32_t L_31 = (int32_t)(__this->___emptySlot_9);
V_2 = (int32_t)L_31;
int32_t L_32 = V_2;
if ((!(((uint32_t)L_32) == ((uint32_t)(-1)))))
{
goto IL_00fa;
}
}
{
int32_t L_33 = (int32_t)(__this->___touchedSlots_8);
int32_t L_34 = (int32_t)L_33;
V_3 = (int32_t)L_34;
__this->___touchedSlots_8 = ((int32_t)((int32_t)L_34+(int32_t)1));
int32_t L_35 = V_3;
V_2 = (int32_t)L_35;
goto IL_0111;
}
IL_00fa:
{
LinkU5BU5D_t1854582343_0* L_36 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_37 = V_2;
NullCheck(L_36);
IL2CPP_ARRAY_BOUNDS_CHECK(L_36, L_37);
int32_t L_38 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_36, L_37, sizeof(Link_t976230437_0 )))->___Next_1);
__this->___emptySlot_9 = L_38;
}
IL_0111:
{
LinkU5BU5D_t1854582343_0* L_39 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_40 = V_2;
NullCheck(L_39);
IL2CPP_ARRAY_BOUNDS_CHECK(L_39, L_40);
int32_t L_41 = V_0;
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_39, L_40, sizeof(Link_t976230437_0 )))->___HashCode_0 = L_41;
LinkU5BU5D_t1854582343_0* L_42 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_43 = V_2;
NullCheck(L_42);
IL2CPP_ARRAY_BOUNDS_CHECK(L_42, L_43);
Int32U5BU5D_t1872284309_0* L_44 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_45 = V_1;
NullCheck(L_44);
IL2CPP_ARRAY_BOUNDS_CHECK(L_44, L_45);
int32_t L_46 = L_45;
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_42, L_43, sizeof(Link_t976230437_0 )))->___Next_1 = ((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_44, L_46, sizeof(int32_t)))-(int32_t)1));
Int32U5BU5D_t1872284309_0* L_47 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_48 = V_1;
int32_t L_49 = V_2;
NullCheck(L_47);
IL2CPP_ARRAY_BOUNDS_CHECK(L_47, L_48);
*((int32_t*)(int32_t*)SZArrayLdElema(L_47, L_48, sizeof(int32_t))) = (int32_t)((int32_t)((int32_t)L_49+(int32_t)1));
ObjectU5BU5D_t1774424924_0* L_50 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_51 = V_2;
Object_t * L_52 = ___key;
NullCheck(L_50);
IL2CPP_ARRAY_BOUNDS_CHECK(L_50, L_51);
*((Object_t **)(Object_t **)SZArrayLdElema(L_50, L_51, sizeof(Object_t *))) = (Object_t *)L_52;
ObjectU5BU5D_t1774424924_0* L_53 = (ObjectU5BU5D_t1774424924_0*)(__this->___valueSlots_7);
int32_t L_54 = V_2;
Object_t * L_55 = ___value;
NullCheck(L_53);
IL2CPP_ARRAY_BOUNDS_CHECK(L_53, L_54);
*((Object_t **)(Object_t **)SZArrayLdElema(L_53, L_54, sizeof(Object_t *))) = (Object_t *)L_55;
int32_t L_56 = (int32_t)(__this->___generation_14);
__this->___generation_14 = ((int32_t)((int32_t)L_56+(int32_t)1));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Clear()
extern "C" void Dictionary_2_Clear_m1200771690_0_gshared (Dictionary_2_t_1114179913_0 * __this, const MethodInfo* method)
{
{
__this->___count_10 = 0;
Int32U5BU5D_t1872284309_0* L_0 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
Int32U5BU5D_t1872284309_0* L_1 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_1);
Array_Clear_m_1795390263_0(NULL /*static, unused*/, (Array_t *)(Array_t *)L_0, (int32_t)0, (int32_t)(((int32_t)((int32_t)(((Array_t *)L_1)->max_length)))), /*hidden argument*/NULL);
ObjectU5BU5D_t1774424924_0* L_2 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
ObjectU5BU5D_t1774424924_0* L_3 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
NullCheck(L_3);
Array_Clear_m_1795390263_0(NULL /*static, unused*/, (Array_t *)(Array_t *)L_2, (int32_t)0, (int32_t)(((int32_t)((int32_t)(((Array_t *)L_3)->max_length)))), /*hidden argument*/NULL);
ObjectU5BU5D_t1774424924_0* L_4 = (ObjectU5BU5D_t1774424924_0*)(__this->___valueSlots_7);
ObjectU5BU5D_t1774424924_0* L_5 = (ObjectU5BU5D_t1774424924_0*)(__this->___valueSlots_7);
NullCheck(L_5);
Array_Clear_m_1795390263_0(NULL /*static, unused*/, (Array_t *)(Array_t *)L_4, (int32_t)0, (int32_t)(((int32_t)((int32_t)(((Array_t *)L_5)->max_length)))), /*hidden argument*/NULL);
LinkU5BU5D_t1854582343_0* L_6 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
LinkU5BU5D_t1854582343_0* L_7 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
NullCheck(L_7);
Array_Clear_m_1795390263_0(NULL /*static, unused*/, (Array_t *)(Array_t *)L_6, (int32_t)0, (int32_t)(((int32_t)((int32_t)(((Array_t *)L_7)->max_length)))), /*hidden argument*/NULL);
__this->___emptySlot_9 = (-1);
__this->___touchedSlots_8 = 0;
int32_t L_8 = (int32_t)(__this->___generation_14);
__this->___generation_14 = ((int32_t)((int32_t)L_8+(int32_t)1));
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::ContainsKey(TKey)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern "C" bool Dictionary_2_ContainsKey_m_1287976240_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___key, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0016;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0016:
{
Object_t* L_2 = (Object_t*)(__this->___hcp_12);
Object_t * L_3 = ___key;
NullCheck((Object_t*)L_2);
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(1 /* System.Int32 System.Collections.Generic.IEqualityComparer`1<System.Object>::GetHashCode(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_2, (Object_t *)L_3);
V_0 = (int32_t)((int32_t)((int32_t)L_4|(int32_t)((int32_t)-2147483648LL)));
Int32U5BU5D_t1872284309_0* L_5 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_6 = V_0;
Int32U5BU5D_t1872284309_0* L_7 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_7);
NullCheck(L_5);
IL2CPP_ARRAY_BOUNDS_CHECK(L_5, ((int32_t)((int32_t)((int32_t)((int32_t)L_6&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_7)->max_length)))))));
int32_t L_8 = ((int32_t)((int32_t)((int32_t)((int32_t)L_6&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_7)->max_length))))));
V_1 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_5, L_8, sizeof(int32_t)))-(int32_t)1));
goto IL_0090;
}
IL_0048:
{
LinkU5BU5D_t1854582343_0* L_9 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_10 = V_1;
NullCheck(L_9);
IL2CPP_ARRAY_BOUNDS_CHECK(L_9, L_10);
int32_t L_11 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_9, L_10, sizeof(Link_t976230437_0 )))->___HashCode_0);
int32_t L_12 = V_0;
if ((!(((uint32_t)L_11) == ((uint32_t)L_12))))
{
goto IL_007e;
}
}
{
Object_t* L_13 = (Object_t*)(__this->___hcp_12);
ObjectU5BU5D_t1774424924_0* L_14 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_15 = V_1;
NullCheck(L_14);
IL2CPP_ARRAY_BOUNDS_CHECK(L_14, L_15);
int32_t L_16 = L_15;
Object_t * L_17 = ___key;
NullCheck((Object_t*)L_13);
bool L_18 = (bool)InterfaceFuncInvoker2< bool, Object_t *, Object_t * >::Invoke(0 /* System.Boolean System.Collections.Generic.IEqualityComparer`1<System.Object>::Equals(T,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_13, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_14, L_16, sizeof(Object_t *))), (Object_t *)L_17);
if (!L_18)
{
goto IL_007e;
}
}
{
return (bool)1;
}
IL_007e:
{
LinkU5BU5D_t1854582343_0* L_19 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_20 = V_1;
NullCheck(L_19);
IL2CPP_ARRAY_BOUNDS_CHECK(L_19, L_20);
int32_t L_21 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_19, L_20, sizeof(Link_t976230437_0 )))->___Next_1);
V_1 = (int32_t)L_21;
}
IL_0090:
{
int32_t L_22 = V_1;
if ((!(((uint32_t)L_22) == ((uint32_t)(-1)))))
{
goto IL_0048;
}
}
{
return (bool)0;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::ContainsValue(TValue)
extern "C" bool Dictionary_2_ContainsValue_m712275664_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___value, const MethodInfo* method)
{
Object_t* V_0 = {0};
int32_t V_1 = 0;
int32_t V_2 = 0;
{
IL2CPP_RUNTIME_CLASS_INIT(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 41));
EqualityComparer_1_t1498484409_0 * L_0 = (( EqualityComparer_1_t1498484409_0 * (*) (Object_t * /* static, unused */, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 40)->method)(NULL /*static, unused*/, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 40));
V_0 = (Object_t*)L_0;
V_1 = (int32_t)0;
goto IL_0054;
}
IL_000d:
{
Int32U5BU5D_t1872284309_0* L_1 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_2 = V_1;
NullCheck(L_1);
IL2CPP_ARRAY_BOUNDS_CHECK(L_1, L_2);
int32_t L_3 = L_2;
V_2 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_1, L_3, sizeof(int32_t)))-(int32_t)1));
goto IL_0049;
}
IL_001d:
{
Object_t* L_4 = V_0;
ObjectU5BU5D_t1774424924_0* L_5 = (ObjectU5BU5D_t1774424924_0*)(__this->___valueSlots_7);
int32_t L_6 = V_2;
NullCheck(L_5);
IL2CPP_ARRAY_BOUNDS_CHECK(L_5, L_6);
int32_t L_7 = L_6;
Object_t * L_8 = ___value;
NullCheck((Object_t*)L_4);
bool L_9 = (bool)InterfaceFuncInvoker2< bool, Object_t *, Object_t * >::Invoke(0 /* System.Boolean System.Collections.Generic.IEqualityComparer`1<System.Object>::Equals(T,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 42), (Object_t*)L_4, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_5, L_7, sizeof(Object_t *))), (Object_t *)L_8);
if (!L_9)
{
goto IL_0037;
}
}
{
return (bool)1;
}
IL_0037:
{
LinkU5BU5D_t1854582343_0* L_10 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_11 = V_2;
NullCheck(L_10);
IL2CPP_ARRAY_BOUNDS_CHECK(L_10, L_11);
int32_t L_12 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_10, L_11, sizeof(Link_t976230437_0 )))->___Next_1);
V_2 = (int32_t)L_12;
}
IL_0049:
{
int32_t L_13 = V_2;
if ((!(((uint32_t)L_13) == ((uint32_t)(-1)))))
{
goto IL_001d;
}
}
{
int32_t L_14 = V_1;
V_1 = (int32_t)((int32_t)((int32_t)L_14+(int32_t)1));
}
IL_0054:
{
int32_t L_15 = V_1;
Int32U5BU5D_t1872284309_0* L_16 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_16);
if ((((int32_t)L_15) < ((int32_t)(((int32_t)((int32_t)(((Array_t *)L_16)->max_length)))))))
{
goto IL_000d;
}
}
{
return (bool)0;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::GetObjectData(System.Runtime.Serialization.SerializationInfo,System.Runtime.Serialization.StreamingContext)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral3237038_0;
extern Il2CppCodeGenString* _stringLiteral2016261304_0;
extern Il2CppCodeGenString* _stringLiteral_535116723_0;
extern Il2CppCodeGenString* _stringLiteral212812367_0;
extern Il2CppCodeGenString* _stringLiteral961688967_0;
extern "C" void Dictionary_2_GetObjectData_m1544184413_0_gshared (Dictionary_2_t_1114179913_0 * __this, SerializationInfo_t526833679_0 * ___info, StreamingContext_t_1216992900_0 ___context, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral3237038_0 = il2cpp_codegen_string_literal_from_index(111);
_stringLiteral2016261304_0 = il2cpp_codegen_string_literal_from_index(498);
_stringLiteral_535116723_0 = il2cpp_codegen_string_literal_from_index(499);
_stringLiteral212812367_0 = il2cpp_codegen_string_literal_from_index(500);
_stringLiteral961688967_0 = il2cpp_codegen_string_literal_from_index(501);
s_Il2CppMethodIntialized = true;
}
KeyValuePair_2U5BU5D_t_160275933_0* V_0 = {0};
{
SerializationInfo_t526833679_0 * L_0 = ___info;
if (L_0)
{
goto IL_0011;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral3237038_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0011:
{
SerializationInfo_t526833679_0 * L_2 = ___info;
int32_t L_3 = (int32_t)(__this->___generation_14);
NullCheck((SerializationInfo_t526833679_0 *)L_2);
SerializationInfo_AddValue_m_1946426782_0((SerializationInfo_t526833679_0 *)L_2, (String_t*)_stringLiteral2016261304_0, (int32_t)L_3, /*hidden argument*/NULL);
SerializationInfo_t526833679_0 * L_4 = ___info;
Object_t* L_5 = (Object_t*)(__this->___hcp_12);
NullCheck((SerializationInfo_t526833679_0 *)L_4);
SerializationInfo_AddValue_m469120675_0((SerializationInfo_t526833679_0 *)L_4, (String_t*)_stringLiteral_535116723_0, (Object_t *)L_5, /*hidden argument*/NULL);
V_0 = (KeyValuePair_2U5BU5D_t_160275933_0*)NULL;
int32_t L_6 = (int32_t)(__this->___count_10);
if ((((int32_t)L_6) <= ((int32_t)0)))
{
goto IL_0055;
}
}
{
int32_t L_7 = (int32_t)(__this->___count_10);
V_0 = (KeyValuePair_2U5BU5D_t_160275933_0*)((KeyValuePair_2U5BU5D_t_160275933_0*)SZArrayNew(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 43), (uint32_t)L_7));
KeyValuePair_2U5BU5D_t_160275933_0* L_8 = V_0;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
(( void (*) (Dictionary_2_t_1114179913_0 *, KeyValuePair_2U5BU5D_t_160275933_0*, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 13)->method)((Dictionary_2_t_1114179913_0 *)__this, (KeyValuePair_2U5BU5D_t_160275933_0*)L_8, (int32_t)0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 13));
}
IL_0055:
{
SerializationInfo_t526833679_0 * L_9 = ___info;
Int32U5BU5D_t1872284309_0* L_10 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_10);
NullCheck((SerializationInfo_t526833679_0 *)L_9);
SerializationInfo_AddValue_m_1946426782_0((SerializationInfo_t526833679_0 *)L_9, (String_t*)_stringLiteral212812367_0, (int32_t)(((int32_t)((int32_t)(((Array_t *)L_10)->max_length)))), /*hidden argument*/NULL);
SerializationInfo_t526833679_0 * L_11 = ___info;
KeyValuePair_2U5BU5D_t_160275933_0* L_12 = V_0;
NullCheck((SerializationInfo_t526833679_0 *)L_11);
SerializationInfo_AddValue_m469120675_0((SerializationInfo_t526833679_0 *)L_11, (String_t*)_stringLiteral961688967_0, (Object_t *)(Object_t *)L_12, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::OnDeserialization(System.Object)
extern TypeInfo* Type_t_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2016261304_0;
extern Il2CppCodeGenString* _stringLiteral_535116723_0;
extern Il2CppCodeGenString* _stringLiteral212812367_0;
extern Il2CppCodeGenString* _stringLiteral961688967_0;
extern "C" void Dictionary_2_OnDeserialization_m1638301735_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___sender, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
Type_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(3);
_stringLiteral2016261304_0 = il2cpp_codegen_string_literal_from_index(498);
_stringLiteral_535116723_0 = il2cpp_codegen_string_literal_from_index(499);
_stringLiteral212812367_0 = il2cpp_codegen_string_literal_from_index(500);
_stringLiteral961688967_0 = il2cpp_codegen_string_literal_from_index(501);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
KeyValuePair_2U5BU5D_t_160275933_0* V_1 = {0};
int32_t V_2 = 0;
{
SerializationInfo_t526833679_0 * L_0 = (SerializationInfo_t526833679_0 *)(__this->___serialization_info_13);
if (L_0)
{
goto IL_000c;
}
}
{
return;
}
IL_000c:
{
SerializationInfo_t526833679_0 * L_1 = (SerializationInfo_t526833679_0 *)(__this->___serialization_info_13);
NullCheck((SerializationInfo_t526833679_0 *)L_1);
int32_t L_2 = SerializationInfo_GetInt32_m_246931343_0((SerializationInfo_t526833679_0 *)L_1, (String_t*)_stringLiteral2016261304_0, /*hidden argument*/NULL);
__this->___generation_14 = L_2;
SerializationInfo_t526833679_0 * L_3 = (SerializationInfo_t526833679_0 *)(__this->___serialization_info_13);
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_4 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 44)), /*hidden argument*/NULL);
NullCheck((SerializationInfo_t526833679_0 *)L_3);
Object_t * L_5 = SerializationInfo_GetValue_m_169495960_0((SerializationInfo_t526833679_0 *)L_3, (String_t*)_stringLiteral_535116723_0, (Type_t *)L_4, /*hidden argument*/NULL);
__this->___hcp_12 = ((Object_t*)Castclass(L_5, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29)));
SerializationInfo_t526833679_0 * L_6 = (SerializationInfo_t526833679_0 *)(__this->___serialization_info_13);
NullCheck((SerializationInfo_t526833679_0 *)L_6);
int32_t L_7 = SerializationInfo_GetInt32_m_246931343_0((SerializationInfo_t526833679_0 *)L_6, (String_t*)_stringLiteral212812367_0, /*hidden argument*/NULL);
V_0 = (int32_t)L_7;
SerializationInfo_t526833679_0 * L_8 = (SerializationInfo_t526833679_0 *)(__this->___serialization_info_13);
Type_t * L_9 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 45)), /*hidden argument*/NULL);
NullCheck((SerializationInfo_t526833679_0 *)L_8);
Object_t * L_10 = SerializationInfo_GetValue_m_169495960_0((SerializationInfo_t526833679_0 *)L_8, (String_t*)_stringLiteral961688967_0, (Type_t *)L_9, /*hidden argument*/NULL);
V_1 = (KeyValuePair_2U5BU5D_t_160275933_0*)((KeyValuePair_2U5BU5D_t_160275933_0*)Castclass(L_10, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 14)));
int32_t L_11 = V_0;
if ((((int32_t)L_11) >= ((int32_t)((int32_t)10))))
{
goto IL_0083;
}
}
{
V_0 = (int32_t)((int32_t)10);
}
IL_0083:
{
int32_t L_12 = V_0;
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
(( void (*) (Dictionary_2_t_1114179913_0 *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 33)->method)((Dictionary_2_t_1114179913_0 *)__this, (int32_t)L_12, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 33));
__this->___count_10 = 0;
KeyValuePair_2U5BU5D_t_160275933_0* L_13 = V_1;
if (!L_13)
{
goto IL_00c9;
}
}
{
V_2 = (int32_t)0;
goto IL_00c0;
}
IL_009e:
{
KeyValuePair_2U5BU5D_t_160275933_0* L_14 = V_1;
int32_t L_15 = V_2;
NullCheck(L_14);
IL2CPP_ARRAY_BOUNDS_CHECK(L_14, L_15);
Object_t * L_16 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)((KeyValuePair_2_t_2064968959_0 *)((KeyValuePair_2_t_2064968959_0 *)(KeyValuePair_2_t_2064968959_0 *)SZArrayLdElema(L_14, L_15, sizeof(KeyValuePair_2_t_2064968959_0 ))), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
KeyValuePair_2U5BU5D_t_160275933_0* L_17 = V_1;
int32_t L_18 = V_2;
NullCheck(L_17);
IL2CPP_ARRAY_BOUNDS_CHECK(L_17, L_18);
Object_t * L_19 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11)->method)((KeyValuePair_2_t_2064968959_0 *)((KeyValuePair_2_t_2064968959_0 *)(KeyValuePair_2_t_2064968959_0 *)SZArrayLdElema(L_17, L_18, sizeof(KeyValuePair_2_t_2064968959_0 ))), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11));
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
VirtActionInvoker2< Object_t *, Object_t * >::Invoke(26 /* System.Void System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Add(TKey,TValue) */, (Dictionary_2_t_1114179913_0 *)__this, (Object_t *)L_16, (Object_t *)L_19);
int32_t L_20 = V_2;
V_2 = (int32_t)((int32_t)((int32_t)L_20+(int32_t)1));
}
IL_00c0:
{
int32_t L_21 = V_2;
KeyValuePair_2U5BU5D_t_160275933_0* L_22 = V_1;
NullCheck(L_22);
if ((((int32_t)L_21) < ((int32_t)(((int32_t)((int32_t)(((Array_t *)L_22)->max_length)))))))
{
goto IL_009e;
}
}
IL_00c9:
{
int32_t L_23 = (int32_t)(__this->___generation_14);
__this->___generation_14 = ((int32_t)((int32_t)L_23+(int32_t)1));
__this->___serialization_info_13 = (SerializationInfo_t526833679_0 *)NULL;
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::Remove(TKey)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern TypeInfo* Object_t_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern "C" bool Dictionary_2_Remove_m_2139247584_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___key, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
Object_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(0);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
int32_t V_2 = 0;
int32_t V_3 = 0;
Object_t * V_4 = {0};
Object_t * V_5 = {0};
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0016;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0016:
{
Object_t* L_2 = (Object_t*)(__this->___hcp_12);
Object_t * L_3 = ___key;
NullCheck((Object_t*)L_2);
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(1 /* System.Int32 System.Collections.Generic.IEqualityComparer`1<System.Object>::GetHashCode(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_2, (Object_t *)L_3);
V_0 = (int32_t)((int32_t)((int32_t)L_4|(int32_t)((int32_t)-2147483648LL)));
int32_t L_5 = V_0;
Int32U5BU5D_t1872284309_0* L_6 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_6);
V_1 = (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_5&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_6)->max_length))))));
Int32U5BU5D_t1872284309_0* L_7 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_8 = V_1;
NullCheck(L_7);
IL2CPP_ARRAY_BOUNDS_CHECK(L_7, L_8);
int32_t L_9 = L_8;
V_2 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_7, L_9, sizeof(int32_t)))-(int32_t)1));
int32_t L_10 = V_2;
if ((!(((uint32_t)L_10) == ((uint32_t)(-1)))))
{
goto IL_004e;
}
}
{
return (bool)0;
}
IL_004e:
{
V_3 = (int32_t)(-1);
}
IL_0050:
{
LinkU5BU5D_t1854582343_0* L_11 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_12 = V_2;
NullCheck(L_11);
IL2CPP_ARRAY_BOUNDS_CHECK(L_11, L_12);
int32_t L_13 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_11, L_12, sizeof(Link_t976230437_0 )))->___HashCode_0);
int32_t L_14 = V_0;
if ((!(((uint32_t)L_13) == ((uint32_t)L_14))))
{
goto IL_0089;
}
}
{
Object_t* L_15 = (Object_t*)(__this->___hcp_12);
ObjectU5BU5D_t1774424924_0* L_16 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_17 = V_2;
NullCheck(L_16);
IL2CPP_ARRAY_BOUNDS_CHECK(L_16, L_17);
int32_t L_18 = L_17;
Object_t * L_19 = ___key;
NullCheck((Object_t*)L_15);
bool L_20 = (bool)InterfaceFuncInvoker2< bool, Object_t *, Object_t * >::Invoke(0 /* System.Boolean System.Collections.Generic.IEqualityComparer`1<System.Object>::Equals(T,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_15, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_16, L_18, sizeof(Object_t *))), (Object_t *)L_19);
if (!L_20)
{
goto IL_0089;
}
}
{
goto IL_00a4;
}
IL_0089:
{
int32_t L_21 = V_2;
V_3 = (int32_t)L_21;
LinkU5BU5D_t1854582343_0* L_22 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_23 = V_2;
NullCheck(L_22);
IL2CPP_ARRAY_BOUNDS_CHECK(L_22, L_23);
int32_t L_24 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_22, L_23, sizeof(Link_t976230437_0 )))->___Next_1);
V_2 = (int32_t)L_24;
int32_t L_25 = V_2;
if ((!(((uint32_t)L_25) == ((uint32_t)(-1)))))
{
goto IL_0050;
}
}
IL_00a4:
{
int32_t L_26 = V_2;
if ((!(((uint32_t)L_26) == ((uint32_t)(-1)))))
{
goto IL_00ad;
}
}
{
return (bool)0;
}
IL_00ad:
{
int32_t L_27 = (int32_t)(__this->___count_10);
__this->___count_10 = ((int32_t)((int32_t)L_27-(int32_t)1));
int32_t L_28 = V_3;
if ((!(((uint32_t)L_28) == ((uint32_t)(-1)))))
{
goto IL_00e2;
}
}
{
Int32U5BU5D_t1872284309_0* L_29 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_30 = V_1;
LinkU5BU5D_t1854582343_0* L_31 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_32 = V_2;
NullCheck(L_31);
IL2CPP_ARRAY_BOUNDS_CHECK(L_31, L_32);
int32_t L_33 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_31, L_32, sizeof(Link_t976230437_0 )))->___Next_1);
NullCheck(L_29);
IL2CPP_ARRAY_BOUNDS_CHECK(L_29, L_30);
*((int32_t*)(int32_t*)SZArrayLdElema(L_29, L_30, sizeof(int32_t))) = (int32_t)((int32_t)((int32_t)L_33+(int32_t)1));
goto IL_0104;
}
IL_00e2:
{
LinkU5BU5D_t1854582343_0* L_34 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_35 = V_3;
NullCheck(L_34);
IL2CPP_ARRAY_BOUNDS_CHECK(L_34, L_35);
LinkU5BU5D_t1854582343_0* L_36 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_37 = V_2;
NullCheck(L_36);
IL2CPP_ARRAY_BOUNDS_CHECK(L_36, L_37);
int32_t L_38 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_36, L_37, sizeof(Link_t976230437_0 )))->___Next_1);
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_34, L_35, sizeof(Link_t976230437_0 )))->___Next_1 = L_38;
}
IL_0104:
{
LinkU5BU5D_t1854582343_0* L_39 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_40 = V_2;
NullCheck(L_39);
IL2CPP_ARRAY_BOUNDS_CHECK(L_39, L_40);
int32_t L_41 = (int32_t)(__this->___emptySlot_9);
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_39, L_40, sizeof(Link_t976230437_0 )))->___Next_1 = L_41;
int32_t L_42 = V_2;
__this->___emptySlot_9 = L_42;
LinkU5BU5D_t1854582343_0* L_43 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_44 = V_2;
NullCheck(L_43);
IL2CPP_ARRAY_BOUNDS_CHECK(L_43, L_44);
((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_43, L_44, sizeof(Link_t976230437_0 )))->___HashCode_0 = 0;
ObjectU5BU5D_t1774424924_0* L_45 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_46 = V_2;
Initobj (Object_t_il2cpp_TypeInfo_var, (&V_4));
Object_t * L_47 = V_4;
NullCheck(L_45);
IL2CPP_ARRAY_BOUNDS_CHECK(L_45, L_46);
*((Object_t **)(Object_t **)SZArrayLdElema(L_45, L_46, sizeof(Object_t *))) = (Object_t *)L_47;
ObjectU5BU5D_t1774424924_0* L_48 = (ObjectU5BU5D_t1774424924_0*)(__this->___valueSlots_7);
int32_t L_49 = V_2;
Initobj (Object_t_il2cpp_TypeInfo_var, (&V_5));
Object_t * L_50 = V_5;
NullCheck(L_48);
IL2CPP_ARRAY_BOUNDS_CHECK(L_48, L_49);
*((Object_t **)(Object_t **)SZArrayLdElema(L_48, L_49, sizeof(Object_t *))) = (Object_t *)L_50;
int32_t L_51 = (int32_t)(__this->___generation_14);
__this->___generation_14 = ((int32_t)((int32_t)L_51+(int32_t)1));
return (bool)1;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::TryGetValue(TKey,TValue&)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern TypeInfo* Object_t_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern "C" bool Dictionary_2_TryGetValue_m2075628329_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___key, Object_t ** ___value, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
Object_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(0);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
s_Il2CppMethodIntialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
Object_t * V_2 = {0};
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0016;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0016:
{
Object_t* L_2 = (Object_t*)(__this->___hcp_12);
Object_t * L_3 = ___key;
NullCheck((Object_t*)L_2);
int32_t L_4 = (int32_t)InterfaceFuncInvoker1< int32_t, Object_t * >::Invoke(1 /* System.Int32 System.Collections.Generic.IEqualityComparer`1<System.Object>::GetHashCode(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_2, (Object_t *)L_3);
V_0 = (int32_t)((int32_t)((int32_t)L_4|(int32_t)((int32_t)-2147483648LL)));
Int32U5BU5D_t1872284309_0* L_5 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
int32_t L_6 = V_0;
Int32U5BU5D_t1872284309_0* L_7 = (Int32U5BU5D_t1872284309_0*)(__this->___table_4);
NullCheck(L_7);
NullCheck(L_5);
IL2CPP_ARRAY_BOUNDS_CHECK(L_5, ((int32_t)((int32_t)((int32_t)((int32_t)L_6&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_7)->max_length)))))));
int32_t L_8 = ((int32_t)((int32_t)((int32_t)((int32_t)L_6&(int32_t)((int32_t)2147483647LL)))%(int32_t)(((int32_t)((int32_t)(((Array_t *)L_7)->max_length))))));
V_1 = (int32_t)((int32_t)((int32_t)(*(int32_t*)(int32_t*)SZArrayLdElema(L_5, L_8, sizeof(int32_t)))-(int32_t)1));
goto IL_00a2;
}
IL_0048:
{
LinkU5BU5D_t1854582343_0* L_9 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_10 = V_1;
NullCheck(L_9);
IL2CPP_ARRAY_BOUNDS_CHECK(L_9, L_10);
int32_t L_11 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_9, L_10, sizeof(Link_t976230437_0 )))->___HashCode_0);
int32_t L_12 = V_0;
if ((!(((uint32_t)L_11) == ((uint32_t)L_12))))
{
goto IL_0090;
}
}
{
Object_t* L_13 = (Object_t*)(__this->___hcp_12);
ObjectU5BU5D_t1774424924_0* L_14 = (ObjectU5BU5D_t1774424924_0*)(__this->___keySlots_6);
int32_t L_15 = V_1;
NullCheck(L_14);
IL2CPP_ARRAY_BOUNDS_CHECK(L_14, L_15);
int32_t L_16 = L_15;
Object_t * L_17 = ___key;
NullCheck((Object_t*)L_13);
bool L_18 = (bool)InterfaceFuncInvoker2< bool, Object_t *, Object_t * >::Invoke(0 /* System.Boolean System.Collections.Generic.IEqualityComparer`1<System.Object>::Equals(T,T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 29), (Object_t*)L_13, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_14, L_16, sizeof(Object_t *))), (Object_t *)L_17);
if (!L_18)
{
goto IL_0090;
}
}
{
Object_t ** L_19 = ___value;
ObjectU5BU5D_t1774424924_0* L_20 = (ObjectU5BU5D_t1774424924_0*)(__this->___valueSlots_7);
int32_t L_21 = V_1;
NullCheck(L_20);
IL2CPP_ARRAY_BOUNDS_CHECK(L_20, L_21);
int32_t L_22 = L_21;
(*(Object_t **)L_19) = (*(Object_t **)(Object_t **)SZArrayLdElema(L_20, L_22, sizeof(Object_t *)));
return (bool)1;
}
IL_0090:
{
LinkU5BU5D_t1854582343_0* L_23 = (LinkU5BU5D_t1854582343_0*)(__this->___linkSlots_5);
int32_t L_24 = V_1;
NullCheck(L_23);
IL2CPP_ARRAY_BOUNDS_CHECK(L_23, L_24);
int32_t L_25 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_23, L_24, sizeof(Link_t976230437_0 )))->___Next_1);
V_1 = (int32_t)L_25;
}
IL_00a2:
{
int32_t L_26 = V_1;
if ((!(((uint32_t)L_26) == ((uint32_t)(-1)))))
{
goto IL_0048;
}
}
{
Object_t ** L_27 = ___value;
Initobj (Object_t_il2cpp_TypeInfo_var, (&V_2));
Object_t * L_28 = V_2;
(*(Object_t **)L_27) = L_28;
return (bool)0;
}
}
// System.Collections.Generic.Dictionary`2/KeyCollection<TKey,TValue> System.Collections.Generic.Dictionary`2<System.Object,System.Object>::get_Keys()
extern "C" KeyCollection_t1391515721_0 * Dictionary_2_get_Keys_m_1670357386_0_gshared (Dictionary_2_t_1114179913_0 * __this, const MethodInfo* method)
{
{
KeyCollection_t1391515721_0 * L_0 = (KeyCollection_t1391515721_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 46));
(( void (*) (KeyCollection_t1391515721_0 *, Dictionary_2_t_1114179913_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 47)->method)(L_0, (Dictionary_2_t_1114179913_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 47));
return L_0;
}
}
// System.Collections.Generic.Dictionary`2/ValueCollection<TKey,TValue> System.Collections.Generic.Dictionary`2<System.Object,System.Object>::get_Values()
extern "C" ValueCollection_t_418251273_0 * Dictionary_2_get_Values_m2070602102_0_gshared (Dictionary_2_t_1114179913_0 * __this, const MethodInfo* method)
{
{
ValueCollection_t_418251273_0 * L_0 = (ValueCollection_t_418251273_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 48));
(( void (*) (ValueCollection_t_418251273_0 *, Dictionary_2_t_1114179913_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 49)->method)(L_0, (Dictionary_2_t_1114179913_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 49));
return L_0;
}
}
// TKey System.Collections.Generic.Dictionary`2<System.Object,System.Object>::ToTKey(System.Object)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern TypeInfo* Type_t_il2cpp_TypeInfo_var;
extern TypeInfo* String_t_il2cpp_TypeInfo_var;
extern TypeInfo* ArgumentException_t1159624695_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral106079_0;
extern Il2CppCodeGenString* _stringLiteral_367149764_0;
extern "C" Object_t * Dictionary_2_ToTKey_m_936014807_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___key, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
Type_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(3);
String_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(11);
ArgumentException_t1159624695_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(4);
_stringLiteral106079_0 = il2cpp_codegen_string_literal_from_index(492);
_stringLiteral_367149764_0 = il2cpp_codegen_string_literal_from_index(502);
s_Il2CppMethodIntialized = true;
}
{
Object_t * L_0 = ___key;
if (L_0)
{
goto IL_0011;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0011:
{
Object_t * L_2 = ___key;
if (((Object_t *)IsInst(L_2, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1))))
{
goto IL_0040;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_3 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 50)), /*hidden argument*/NULL);
NullCheck((Type_t *)L_3);
String_t* L_4 = (String_t*)VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Type::ToString() */, (Type_t *)L_3);
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_5 = String_Concat_m138640077_0(NULL /*static, unused*/, (String_t*)_stringLiteral_367149764_0, (String_t*)L_4, /*hidden argument*/NULL);
ArgumentException_t1159624695_0 * L_6 = (ArgumentException_t1159624695_0 *)il2cpp_codegen_object_new (ArgumentException_t1159624695_0_il2cpp_TypeInfo_var);
ArgumentException__ctor_m732321503_0(L_6, (String_t*)L_5, (String_t*)_stringLiteral106079_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_6);
}
IL_0040:
{
Object_t * L_7 = ___key;
return ((Object_t *)Castclass(L_7, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)));
}
}
// TValue System.Collections.Generic.Dictionary`2<System.Object,System.Object>::ToTValue(System.Object)
extern TypeInfo* Type_t_il2cpp_TypeInfo_var;
extern TypeInfo* Object_t_il2cpp_TypeInfo_var;
extern TypeInfo* String_t_il2cpp_TypeInfo_var;
extern TypeInfo* ArgumentException_t1159624695_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_367149764_0;
extern Il2CppCodeGenString* _stringLiteral111972721_0;
extern "C" Object_t * Dictionary_2_ToTValue_m1789908265_0_gshared (Dictionary_2_t_1114179913_0 * __this, Object_t * ___value, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
Type_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(3);
Object_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(0);
String_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(11);
ArgumentException_t1159624695_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(4);
_stringLiteral_367149764_0 = il2cpp_codegen_string_literal_from_index(502);
_stringLiteral111972721_0 = il2cpp_codegen_string_literal_from_index(52);
s_Il2CppMethodIntialized = true;
}
Object_t * V_0 = {0};
{
Object_t * L_0 = ___value;
if (L_0)
{
goto IL_0024;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_1 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 51)), /*hidden argument*/NULL);
NullCheck((Type_t *)L_1);
bool L_2 = (bool)VirtFuncInvoker0< bool >::Invoke(33 /* System.Boolean System.Type::get_IsValueType() */, (Type_t *)L_1);
if (L_2)
{
goto IL_0024;
}
}
{
Initobj (Object_t_il2cpp_TypeInfo_var, (&V_0));
Object_t * L_3 = V_0;
return L_3;
}
IL_0024:
{
Object_t * L_4 = ___value;
if (((Object_t *)IsInst(L_4, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5))))
{
goto IL_0053;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(Type_t_il2cpp_TypeInfo_var);
Type_t * L_5 = Type_GetTypeFromHandle_m_488061862_0(NULL /*static, unused*/, (RuntimeTypeHandle_t_1394772513_0 )LoadTypeToken(IL2CPP_RGCTX_TYPE(InitializedTypeInfo(method->declaring_type)->rgctx_data, 51)), /*hidden argument*/NULL);
NullCheck((Type_t *)L_5);
String_t* L_6 = (String_t*)VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Type::ToString() */, (Type_t *)L_5);
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_7 = String_Concat_m138640077_0(NULL /*static, unused*/, (String_t*)_stringLiteral_367149764_0, (String_t*)L_6, /*hidden argument*/NULL);
ArgumentException_t1159624695_0 * L_8 = (ArgumentException_t1159624695_0 *)il2cpp_codegen_object_new (ArgumentException_t1159624695_0_il2cpp_TypeInfo_var);
ArgumentException__ctor_m732321503_0(L_8, (String_t*)L_7, (String_t*)_stringLiteral111972721_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_8);
}
IL_0053:
{
Object_t * L_9 = ___value;
return ((Object_t *)Castclass(L_9, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)));
}
}
// System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::ContainsKeyValuePair(System.Collections.Generic.KeyValuePair`2<TKey,TValue>)
extern "C" bool Dictionary_2_ContainsKeyValuePair_m_1221731837_0_gshared (Dictionary_2_t_1114179913_0 * __this, KeyValuePair_2_t_2064968959_0 ___pair, const MethodInfo* method)
{
Object_t * V_0 = {0};
{
Object_t * L_0 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)((KeyValuePair_2_t_2064968959_0 *)(&___pair), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
NullCheck((Dictionary_2_t_1114179913_0 *)__this);
bool L_1 = (bool)VirtFuncInvoker2< bool, Object_t *, Object_t ** >::Invoke(31 /* System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::TryGetValue(TKey,TValue&) */, (Dictionary_2_t_1114179913_0 *)__this, (Object_t *)L_0, (Object_t **)(&V_0));
if (L_1)
{
goto IL_0016;
}
}
{
return (bool)0;
}
IL_0016:
{
IL2CPP_RUNTIME_CLASS_INIT(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 41));
EqualityComparer_1_t1498484409_0 * L_2 = (( EqualityComparer_1_t1498484409_0 * (*) (Object_t * /* static, unused */, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 40)->method)(NULL /*static, unused*/, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 40));
Object_t * L_3 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11)->method)((KeyValuePair_2_t_2064968959_0 *)(&___pair), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11));
Object_t * L_4 = V_0;
NullCheck((EqualityComparer_1_t1498484409_0 *)L_2);
bool L_5 = (bool)VirtFuncInvoker2< bool, Object_t *, Object_t * >::Invoke(9 /* System.Boolean System.Collections.Generic.EqualityComparer`1<System.Object>::Equals(T,T) */, (EqualityComparer_1_t1498484409_0 *)L_2, (Object_t *)L_3, (Object_t *)L_4);
return L_5;
}
}
// System.Collections.Generic.Dictionary`2/Enumerator<TKey,TValue> System.Collections.Generic.Dictionary`2<System.Object,System.Object>::GetEnumerator()
extern "C" Enumerator_t1711973002_0 Dictionary_2_GetEnumerator_m65675076_0_gshared (Dictionary_2_t_1114179913_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 L_0 = {0};
(( void (*) (Enumerator_t1711973002_0 *, Dictionary_2_t_1114179913_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 26)->method)(&L_0, (Dictionary_2_t_1114179913_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 26));
return L_0;
}
}
// System.Collections.DictionaryEntry System.Collections.Generic.Dictionary`2<System.Object,System.Object>::<CopyTo>m__0(TKey,TValue)
extern "C" DictionaryEntry_t_1842557272_0 Dictionary_2_U3CCopyToU3Em__0_m_476237165_0_gshared (Object_t * __this /* static, unused */, Object_t * ___key, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___key;
Object_t * L_1 = ___value;
DictionaryEntry_t_1842557272_0 L_2 = {0};
DictionaryEntry__ctor_m_1694295436_0(&L_2, (Object_t *)L_0, (Object_t *)L_1, /*hidden argument*/NULL);
return L_2;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::.ctor(System.Array)
extern "C" void InternalEnumerator_1__ctor_m_1337057554_0_gshared (InternalEnumerator_1_t530883272_0 * __this, Array_t * ___array, const MethodInfo* method)
{
{
Array_t * L_0 = ___array;
__this->___array_0 = L_0;
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::System.Collections.IEnumerator.Reset()
extern "C" void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m483697650_0_gshared (InternalEnumerator_1_t530883272_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1713001566_0_gshared (InternalEnumerator_1_t530883272_0 * __this, const MethodInfo* method)
{
{
KeyValuePair_2_t_2064968959_0 L_0 = (( KeyValuePair_2_t_2064968959_0 (*) (InternalEnumerator_1_t530883272_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((InternalEnumerator_1_t530883272_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
KeyValuePair_2_t_2064968959_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::Dispose()
extern "C" void InternalEnumerator_1_Dispose_m72014405_0_gshared (InternalEnumerator_1_t530883272_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::MoveNext()
extern "C" bool InternalEnumerator_1_MoveNext_m535991902_0_gshared (InternalEnumerator_1_t530883272_0 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t G_B5_0 = 0;
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001e;
}
}
{
Array_t * L_1 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_1);
int32_t L_2 = Array_get_Length_m1203127607_0((Array_t *)L_1, /*hidden argument*/NULL);
__this->___idx_1 = L_2;
}
IL_001e:
{
int32_t L_3 = (int32_t)(__this->___idx_1);
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_0043;
}
}
{
int32_t L_4 = (int32_t)(__this->___idx_1);
int32_t L_5 = (int32_t)((int32_t)((int32_t)L_4-(int32_t)1));
V_0 = (int32_t)L_5;
__this->___idx_1 = L_5;
int32_t L_6 = V_0;
G_B5_0 = ((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0044;
}
IL_0043:
{
G_B5_0 = 0;
}
IL_0044:
{
return (bool)G_B5_0;
}
}
// T System.Array/InternalEnumerator`1<System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::get_Current()
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_673706721_0;
extern Il2CppCodeGenString* _stringLiteral_2097638381_0;
extern "C" KeyValuePair_2_t_2064968959_0 InternalEnumerator_1_get_Current_m_78356299_0_gshared (InternalEnumerator_1_t530883272_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral_673706721_0 = il2cpp_codegen_string_literal_from_index(193);
_stringLiteral_2097638381_0 = il2cpp_codegen_string_literal_from_index(194);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0018;
}
}
{
InvalidOperationException_t_523179548_0 * L_1 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_1, (String_t*)_stringLiteral_673706721_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0018:
{
int32_t L_2 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_002f;
}
}
{
InvalidOperationException_t_523179548_0 * L_3 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_3, (String_t*)_stringLiteral_2097638381_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
IL_002f:
{
Array_t * L_4 = (Array_t *)(__this->___array_0);
Array_t * L_5 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_5);
int32_t L_6 = Array_get_Length_m1203127607_0((Array_t *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)(__this->___idx_1);
NullCheck((Array_t *)L_4);
KeyValuePair_2_t_2064968959_0 L_8 = (( KeyValuePair_2_t_2064968959_0 (*) (Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((Array_t *)L_4, (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_6-(int32_t)1))-(int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
return L_8;
}
}
// System.Void System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>::.ctor(TKey,TValue)
extern "C" void KeyValuePair_2__ctor_m_126701761_0_gshared (KeyValuePair_2_t_2064968959_0 * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___key;
(( void (*) (KeyValuePair_2_t_2064968959_0 *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((KeyValuePair_2_t_2064968959_0 *)__this, (Object_t *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
Object_t * L_1 = ___value;
(( void (*) (KeyValuePair_2_t_2064968959_0 *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((KeyValuePair_2_t_2064968959_0 *)__this, (Object_t *)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
return;
}
}
// TKey System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>::get_Key()
extern "C" Object_t * KeyValuePair_2_get_Key_m_1038491319_0_gshared (KeyValuePair_2_t_2064968959_0 * __this, const MethodInfo* method)
{
{
Object_t * L_0 = (Object_t *)(__this->___key_0);
return L_0;
}
}
// System.Void System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>::set_Key(TKey)
extern "C" void KeyValuePair_2_set_Key_m1278074762_0_gshared (KeyValuePair_2_t_2064968959_0 * __this, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___value;
__this->___key_0 = L_0;
return;
}
}
// TValue System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>::get_Value()
extern "C" Object_t * KeyValuePair_2_get_Value_m_395887699_0_gshared (KeyValuePair_2_t_2064968959_0 * __this, const MethodInfo* method)
{
{
Object_t * L_0 = (Object_t *)(__this->___value_1);
return L_0;
}
}
// System.Void System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>::set_Value(TValue)
extern "C" void KeyValuePair_2_set_Value_m_1340449142_0_gshared (KeyValuePair_2_t_2064968959_0 * __this, Object_t * ___value, const MethodInfo* method)
{
{
Object_t * L_0 = ___value;
__this->___value_1 = L_0;
return;
}
}
// System.String System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>::ToString()
extern TypeInfo* StringU5BU5D_t_816028754_0_il2cpp_TypeInfo_var;
extern TypeInfo* String_t_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral91_0;
extern Il2CppCodeGenString* _stringLiteral1396_0;
extern Il2CppCodeGenString* _stringLiteral93_0;
extern "C" String_t* KeyValuePair_2_ToString_m1313859518_0_gshared (KeyValuePair_2_t_2064968959_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
StringU5BU5D_t_816028754_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(32);
String_t_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(11);
_stringLiteral91_0 = il2cpp_codegen_string_literal_from_index(230);
_stringLiteral1396_0 = il2cpp_codegen_string_literal_from_index(143);
_stringLiteral93_0 = il2cpp_codegen_string_literal_from_index(232);
s_Il2CppMethodIntialized = true;
}
Object_t * V_0 = {0};
Object_t * V_1 = {0};
int32_t G_B2_0 = 0;
StringU5BU5D_t_816028754_0* G_B2_1 = {0};
StringU5BU5D_t_816028754_0* G_B2_2 = {0};
int32_t G_B1_0 = 0;
StringU5BU5D_t_816028754_0* G_B1_1 = {0};
StringU5BU5D_t_816028754_0* G_B1_2 = {0};
String_t* G_B3_0 = {0};
int32_t G_B3_1 = 0;
StringU5BU5D_t_816028754_0* G_B3_2 = {0};
StringU5BU5D_t_816028754_0* G_B3_3 = {0};
int32_t G_B5_0 = 0;
StringU5BU5D_t_816028754_0* G_B5_1 = {0};
StringU5BU5D_t_816028754_0* G_B5_2 = {0};
int32_t G_B4_0 = 0;
StringU5BU5D_t_816028754_0* G_B4_1 = {0};
StringU5BU5D_t_816028754_0* G_B4_2 = {0};
String_t* G_B6_0 = {0};
int32_t G_B6_1 = 0;
StringU5BU5D_t_816028754_0* G_B6_2 = {0};
StringU5BU5D_t_816028754_0* G_B6_3 = {0};
{
StringU5BU5D_t_816028754_0* L_0 = (StringU5BU5D_t_816028754_0*)((StringU5BU5D_t_816028754_0*)SZArrayNew(StringU5BU5D_t_816028754_0_il2cpp_TypeInfo_var, (uint32_t)5));
NullCheck(L_0);
IL2CPP_ARRAY_BOUNDS_CHECK(L_0, 0);
ArrayElementTypeCheck (L_0, _stringLiteral91_0);
*((String_t**)(String_t**)SZArrayLdElema(L_0, 0, sizeof(String_t*))) = (String_t*)_stringLiteral91_0;
StringU5BU5D_t_816028754_0* L_1 = (StringU5BU5D_t_816028754_0*)L_0;
Object_t * L_2 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((KeyValuePair_2_t_2064968959_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
G_B1_0 = 1;
G_B1_1 = L_1;
G_B1_2 = L_1;
if (!L_2)
{
G_B2_0 = 1;
G_B2_1 = L_1;
G_B2_2 = L_1;
goto IL_0039;
}
}
{
Object_t * L_3 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((KeyValuePair_2_t_2064968959_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
V_0 = (Object_t *)L_3;
NullCheck((Object_t *)(*(&V_0)));
String_t* L_4 = (String_t*)VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, (Object_t *)(*(&V_0)));
G_B3_0 = L_4;
G_B3_1 = G_B1_0;
G_B3_2 = G_B1_1;
G_B3_3 = G_B1_2;
goto IL_003e;
}
IL_0039:
{
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_5 = ((String_t_StaticFields*)String_t_il2cpp_TypeInfo_var->static_fields)->___Empty_2;
G_B3_0 = L_5;
G_B3_1 = G_B2_0;
G_B3_2 = G_B2_1;
G_B3_3 = G_B2_2;
}
IL_003e:
{
NullCheck(G_B3_2);
IL2CPP_ARRAY_BOUNDS_CHECK(G_B3_2, G_B3_1);
ArrayElementTypeCheck (G_B3_2, G_B3_0);
*((String_t**)(String_t**)SZArrayLdElema(G_B3_2, G_B3_1, sizeof(String_t*))) = (String_t*)G_B3_0;
StringU5BU5D_t_816028754_0* L_6 = (StringU5BU5D_t_816028754_0*)G_B3_3;
NullCheck(L_6);
IL2CPP_ARRAY_BOUNDS_CHECK(L_6, 2);
ArrayElementTypeCheck (L_6, _stringLiteral1396_0);
*((String_t**)(String_t**)SZArrayLdElema(L_6, 2, sizeof(String_t*))) = (String_t*)_stringLiteral1396_0;
StringU5BU5D_t_816028754_0* L_7 = (StringU5BU5D_t_816028754_0*)L_6;
Object_t * L_8 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)((KeyValuePair_2_t_2064968959_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
G_B4_0 = 3;
G_B4_1 = L_7;
G_B4_2 = L_7;
if (!L_8)
{
G_B5_0 = 3;
G_B5_1 = L_7;
G_B5_2 = L_7;
goto IL_0072;
}
}
{
Object_t * L_9 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)((KeyValuePair_2_t_2064968959_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
V_1 = (Object_t *)L_9;
NullCheck((Object_t *)(*(&V_1)));
String_t* L_10 = (String_t*)VirtFuncInvoker0< String_t* >::Invoke(3 /* System.String System.Object::ToString() */, (Object_t *)(*(&V_1)));
G_B6_0 = L_10;
G_B6_1 = G_B4_0;
G_B6_2 = G_B4_1;
G_B6_3 = G_B4_2;
goto IL_0077;
}
IL_0072:
{
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_11 = ((String_t_StaticFields*)String_t_il2cpp_TypeInfo_var->static_fields)->___Empty_2;
G_B6_0 = L_11;
G_B6_1 = G_B5_0;
G_B6_2 = G_B5_1;
G_B6_3 = G_B5_2;
}
IL_0077:
{
NullCheck(G_B6_2);
IL2CPP_ARRAY_BOUNDS_CHECK(G_B6_2, G_B6_1);
ArrayElementTypeCheck (G_B6_2, G_B6_0);
*((String_t**)(String_t**)SZArrayLdElema(G_B6_2, G_B6_1, sizeof(String_t*))) = (String_t*)G_B6_0;
StringU5BU5D_t_816028754_0* L_12 = (StringU5BU5D_t_816028754_0*)G_B6_3;
NullCheck(L_12);
IL2CPP_ARRAY_BOUNDS_CHECK(L_12, 4);
ArrayElementTypeCheck (L_12, _stringLiteral93_0);
*((String_t**)(String_t**)SZArrayLdElema(L_12, 4, sizeof(String_t*))) = (String_t*)_stringLiteral93_0;
IL2CPP_RUNTIME_CLASS_INIT(String_t_il2cpp_TypeInfo_var);
String_t* L_13 = String_Concat_m21867311_0(NULL /*static, unused*/, (StringU5BU5D_t_816028754_0*)L_12, /*hidden argument*/NULL);
return L_13;
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Object>::.ctor(System.Collections.Generic.Dictionary`2<TKey,TValue>)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral447049878_0;
extern "C" void KeyCollection__ctor_m_862898168_0_gshared (KeyCollection_t1391515721_0 * __this, Dictionary_2_t_1114179913_0 * ___dictionary, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral447049878_0 = il2cpp_codegen_string_literal_from_index(505);
s_Il2CppMethodIntialized = true;
}
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
Dictionary_2_t_1114179913_0 * L_0 = ___dictionary;
if (L_0)
{
goto IL_0017;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral447049878_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0017:
{
Dictionary_2_t_1114179913_0 * L_2 = ___dictionary;
__this->___dictionary_0 = L_2;
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Object>::System.Collections.Generic.ICollection<TKey>.Add(TKey)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2123164782_0;
extern "C" void KeyCollection_System_Collections_Generic_ICollectionU3CTKeyU3E_Add_m_1193067442_0_gshared (KeyCollection_t1391515721_0 * __this, Object_t * ___item, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
_stringLiteral2123164782_0 = il2cpp_codegen_string_literal_from_index(506);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m133757637_0(L_0, (String_t*)_stringLiteral2123164782_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Object>::System.Collections.Generic.ICollection<TKey>.Clear()
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2123164782_0;
extern "C" void KeyCollection_System_Collections_Generic_ICollectionU3CTKeyU3E_Clear_m164109637_0_gshared (KeyCollection_t1391515721_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
_stringLiteral2123164782_0 = il2cpp_codegen_string_literal_from_index(506);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m133757637_0(L_0, (String_t*)_stringLiteral2123164782_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Object>::System.Collections.Generic.ICollection<TKey>.Contains(TKey)
extern "C" bool KeyCollection_System_Collections_Generic_ICollectionU3CTKeyU3E_Contains_m_1892830340_0_gshared (KeyCollection_t1391515721_0 * __this, Object_t * ___item, const MethodInfo* method)
{
{
Dictionary_2_t_1114179913_0 * L_0 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
Object_t * L_1 = ___item;
NullCheck((Dictionary_2_t_1114179913_0 *)L_0);
bool L_2 = (bool)VirtFuncInvoker1< bool, Object_t * >::Invoke(27 /* System.Boolean System.Collections.Generic.Dictionary`2<System.Object,System.Object>::ContainsKey(TKey) */, (Dictionary_2_t_1114179913_0 *)L_0, (Object_t *)L_1);
return L_2;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Object>::System.Collections.Generic.ICollection<TKey>.Remove(TKey)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2123164782_0;
extern "C" bool KeyCollection_System_Collections_Generic_ICollectionU3CTKeyU3E_Remove_m1325978593_0_gshared (KeyCollection_t1391515721_0 * __this, Object_t * ___item, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
_stringLiteral2123164782_0 = il2cpp_codegen_string_literal_from_index(506);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m133757637_0(L_0, (String_t*)_stringLiteral2123164782_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Collections.Generic.IEnumerator`1<TKey> System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Object>::System.Collections.Generic.IEnumerable<TKey>.GetEnumerator()
extern "C" Object_t* KeyCollection_System_Collections_Generic_IEnumerableU3CTKeyU3E_GetEnumerator_m_1144907263_0_gshared (KeyCollection_t1391515721_0 * __this, const MethodInfo* method)
{
{
NullCheck((KeyCollection_t1391515721_0 *)__this);
Enumerator_t_1262849608_0 L_0 = (( Enumerator_t_1262849608_0 (*) (KeyCollection_t1391515721_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((KeyCollection_t1391515721_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
Enumerator_t_1262849608_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), &L_1);
return (Object_t*)L_2;
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Object>::System.Collections.ICollection.CopyTo(System.Array,System.Int32)
extern "C" void KeyCollection_System_Collections_ICollection_CopyTo_m2134327863_0_gshared (KeyCollection_t1391515721_0 * __this, Array_t * ___array, int32_t ___index, const MethodInfo* method)
{
ObjectU5BU5D_t1774424924_0* V_0 = {0};
{
Array_t * L_0 = ___array;
V_0 = (ObjectU5BU5D_t1774424924_0*)((ObjectU5BU5D_t1774424924_0*)IsInst(L_0, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)));
ObjectU5BU5D_t1774424924_0* L_1 = V_0;
if (!L_1)
{
goto IL_0016;
}
}
{
ObjectU5BU5D_t1774424924_0* L_2 = V_0;
int32_t L_3 = ___index;
NullCheck((KeyCollection_t1391515721_0 *)__this);
(( void (*) (KeyCollection_t1391515721_0 *, ObjectU5BU5D_t1774424924_0*, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)((KeyCollection_t1391515721_0 *)__this, (ObjectU5BU5D_t1774424924_0*)L_2, (int32_t)L_3, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
return;
}
IL_0016:
{
Dictionary_2_t_1114179913_0 * L_4 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
Array_t * L_5 = ___array;
int32_t L_6 = ___index;
NullCheck((Dictionary_2_t_1114179913_0 *)L_4);
(( void (*) (Dictionary_2_t_1114179913_0 *, Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((Dictionary_2_t_1114179913_0 *)L_4, (Array_t *)L_5, (int32_t)L_6, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
Dictionary_2_t_1114179913_0 * L_7 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
Array_t * L_8 = ___array;
int32_t L_9 = ___index;
IntPtr_t L_10 = { (void*)IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6) };
Transform_1_t1919841591_0 * L_11 = (Transform_1_t1919841591_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7));
(( void (*) (Transform_1_t1919841591_0 *, Object_t *, IntPtr_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8)->method)(L_11, (Object_t *)NULL, (IntPtr_t)L_10, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8));
NullCheck((Dictionary_2_t_1114179913_0 *)L_7);
(( void (*) (Dictionary_2_t_1114179913_0 *, Array_t *, int32_t, Transform_1_t1919841591_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9)->method)((Dictionary_2_t_1114179913_0 *)L_7, (Array_t *)L_8, (int32_t)L_9, (Transform_1_t1919841591_0 *)L_11, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9));
return;
}
}
// System.Collections.IEnumerator System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Object>::System.Collections.IEnumerable.GetEnumerator()
extern "C" Object_t * KeyCollection_System_Collections_IEnumerable_GetEnumerator_m_1227366030_0_gshared (KeyCollection_t1391515721_0 * __this, const MethodInfo* method)
{
{
NullCheck((KeyCollection_t1391515721_0 *)__this);
Enumerator_t_1262849608_0 L_0 = (( Enumerator_t_1262849608_0 (*) (KeyCollection_t1391515721_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((KeyCollection_t1391515721_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
Enumerator_t_1262849608_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), &L_1);
return (Object_t *)L_2;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Object>::System.Collections.Generic.ICollection<TKey>.get_IsReadOnly()
extern "C" bool KeyCollection_System_Collections_Generic_ICollectionU3CTKeyU3E_get_IsReadOnly_m642268125_0_gshared (KeyCollection_t1391515721_0 * __this, const MethodInfo* method)
{
{
return (bool)1;
}
}
// System.Object System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Object>::System.Collections.ICollection.get_SyncRoot()
extern TypeInfo* ICollection_t592284435_0_il2cpp_TypeInfo_var;
extern "C" Object_t * KeyCollection_System_Collections_ICollection_get_SyncRoot_m_719440197_0_gshared (KeyCollection_t1391515721_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ICollection_t592284435_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(184);
s_Il2CppMethodIntialized = true;
}
{
Dictionary_2_t_1114179913_0 * L_0 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
NullCheck((Object_t *)L_0);
Object_t * L_1 = (Object_t *)InterfaceFuncInvoker0< Object_t * >::Invoke(1 /* System.Object System.Collections.ICollection::get_SyncRoot() */, ICollection_t592284435_0_il2cpp_TypeInfo_var, (Object_t *)L_0);
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Object>::CopyTo(TKey[],System.Int32)
extern "C" void KeyCollection_CopyTo_m_1491026243_0_gshared (KeyCollection_t1391515721_0 * __this, ObjectU5BU5D_t1774424924_0* ___array, int32_t ___index, const MethodInfo* method)
{
{
Dictionary_2_t_1114179913_0 * L_0 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
ObjectU5BU5D_t1774424924_0* L_1 = ___array;
int32_t L_2 = ___index;
NullCheck((Dictionary_2_t_1114179913_0 *)L_0);
(( void (*) (Dictionary_2_t_1114179913_0 *, Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((Dictionary_2_t_1114179913_0 *)L_0, (Array_t *)(Array_t *)L_1, (int32_t)L_2, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
Dictionary_2_t_1114179913_0 * L_3 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
ObjectU5BU5D_t1774424924_0* L_4 = ___array;
int32_t L_5 = ___index;
IntPtr_t L_6 = { (void*)IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6) };
Transform_1_t1919841591_0 * L_7 = (Transform_1_t1919841591_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7));
(( void (*) (Transform_1_t1919841591_0 *, Object_t *, IntPtr_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8)->method)(L_7, (Object_t *)NULL, (IntPtr_t)L_6, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8));
NullCheck((Dictionary_2_t_1114179913_0 *)L_3);
(( void (*) (Dictionary_2_t_1114179913_0 *, ObjectU5BU5D_t1774424924_0*, int32_t, Transform_1_t1919841591_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)((Dictionary_2_t_1114179913_0 *)L_3, (ObjectU5BU5D_t1774424924_0*)L_4, (int32_t)L_5, (Transform_1_t1919841591_0 *)L_7, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
return;
}
}
// System.Collections.Generic.Dictionary`2/KeyCollection/Enumerator<TKey,TValue> System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Object>::GetEnumerator()
extern "C" Enumerator_t_1262849608_0 KeyCollection_GetEnumerator_m_1314103264_0_gshared (KeyCollection_t1391515721_0 * __this, const MethodInfo* method)
{
{
Dictionary_2_t_1114179913_0 * L_0 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
Enumerator_t_1262849608_0 L_1 = {0};
(( void (*) (Enumerator_t_1262849608_0 *, Dictionary_2_t_1114179913_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11)->method)(&L_1, (Dictionary_2_t_1114179913_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11));
return L_1;
}
}
// System.Int32 System.Collections.Generic.Dictionary`2/KeyCollection<System.Object,System.Object>::get_Count()
extern "C" int32_t KeyCollection_get_Count_m1374340501_0_gshared (KeyCollection_t1391515721_0 * __this, const MethodInfo* method)
{
{
Dictionary_2_t_1114179913_0 * L_0 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
NullCheck((Dictionary_2_t_1114179913_0 *)L_0);
int32_t L_1 = (int32_t)VirtFuncInvoker0< int32_t >::Invoke(9 /* System.Int32 System.Collections.Generic.Dictionary`2<System.Object,System.Object>::get_Count() */, (Dictionary_2_t_1114179913_0 *)L_0);
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection/Enumerator<System.Object,System.Object>::.ctor(System.Collections.Generic.Dictionary`2<TKey,TValue>)
extern "C" void Enumerator__ctor_m_1633360013_0_gshared (Enumerator_t_1262849608_0 * __this, Dictionary_2_t_1114179913_0 * ___host, const MethodInfo* method)
{
{
Dictionary_2_t_1114179913_0 * L_0 = ___host;
NullCheck((Dictionary_2_t_1114179913_0 *)L_0);
Enumerator_t1711973002_0 L_1 = (( Enumerator_t1711973002_0 (*) (Dictionary_2_t_1114179913_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Dictionary_2_t_1114179913_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
__this->___host_enumerator_0 = L_1;
return;
}
}
// System.Object System.Collections.Generic.Dictionary`2/KeyCollection/Enumerator<System.Object,System.Object>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * Enumerator_System_Collections_IEnumerator_get_Current_m_1654641586_0_gshared (Enumerator_t_1262849608_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 * L_0 = (Enumerator_t1711973002_0 *)&(__this->___host_enumerator_0);
Object_t * L_1 = (( Object_t * (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((Enumerator_t1711973002_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection/Enumerator<System.Object,System.Object>::System.Collections.IEnumerator.Reset()
extern "C" void Enumerator_System_Collections_IEnumerator_Reset_m1606518626_0_gshared (Enumerator_t_1262849608_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 * L_0 = (Enumerator_t1711973002_0 *)&(__this->___host_enumerator_0);
(( void (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((Enumerator_t1711973002_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/KeyCollection/Enumerator<System.Object,System.Object>::Dispose()
extern "C" void Enumerator_Dispose_m_2030026539_0_gshared (Enumerator_t_1262849608_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 * L_0 = (Enumerator_t1711973002_0 *)&(__this->___host_enumerator_0);
(( void (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)((Enumerator_t1711973002_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/KeyCollection/Enumerator<System.Object,System.Object>::MoveNext()
extern "C" bool Enumerator_MoveNext_m_1253118258_0_gshared (Enumerator_t_1262849608_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 * L_0 = (Enumerator_t1711973002_0 *)&(__this->___host_enumerator_0);
bool L_1 = (( bool (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((Enumerator_t1711973002_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
return L_1;
}
}
// TKey System.Collections.Generic.Dictionary`2/KeyCollection/Enumerator<System.Object,System.Object>::get_Current()
extern "C" Object_t * Enumerator_get_Current_m_843276858_0_gshared (Enumerator_t_1262849608_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 * L_0 = (Enumerator_t1711973002_0 *)&(__this->___host_enumerator_0);
KeyValuePair_2_t_2064968959_0 * L_1 = (KeyValuePair_2_t_2064968959_0 *)&(L_0->___current_3);
Object_t * L_2 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6)->method)((KeyValuePair_2_t_2064968959_0 *)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6));
return L_2;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::.ctor(System.Collections.Generic.Dictionary`2<TKey,TValue>)
extern "C" void Enumerator__ctor_m_374136159_0_gshared (Enumerator_t1711973002_0 * __this, Dictionary_2_t_1114179913_0 * ___dictionary, const MethodInfo* method)
{
{
Dictionary_2_t_1114179913_0 * L_0 = ___dictionary;
__this->___dictionary_0 = L_0;
Dictionary_2_t_1114179913_0 * L_1 = ___dictionary;
NullCheck(L_1);
int32_t L_2 = (int32_t)(L_1->___generation_14);
__this->___stamp_2 = L_2;
return;
}
}
// System.Object System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * Enumerator_System_Collections_IEnumerator_get_Current_m_1032879584_0_gshared (Enumerator_t1711973002_0 * __this, const MethodInfo* method)
{
{
(( void (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Enumerator_t1711973002_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
KeyValuePair_2_t_2064968959_0 L_0 = (KeyValuePair_2_t_2064968959_0 )(__this->___current_3);
KeyValuePair_2_t_2064968959_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::System.Collections.IEnumerator.Reset()
extern "C" void Enumerator_System_Collections_IEnumerator_Reset_m_1335825548_0_gshared (Enumerator_t1711973002_0 * __this, const MethodInfo* method)
{
{
(( void (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((Enumerator_t1711973002_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
return;
}
}
// System.Collections.DictionaryEntry System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::System.Collections.IDictionaryEnumerator.get_Entry()
extern "C" DictionaryEntry_t_1842557272_0 Enumerator_System_Collections_IDictionaryEnumerator_get_Entry_m_2015443203_0_gshared (Enumerator_t1711973002_0 * __this, const MethodInfo* method)
{
{
(( void (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Enumerator_t1711973002_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
KeyValuePair_2_t_2064968959_0 * L_0 = (KeyValuePair_2_t_2064968959_0 *)&(__this->___current_3);
Object_t * L_1 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((KeyValuePair_2_t_2064968959_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
KeyValuePair_2_t_2064968959_0 * L_2 = (KeyValuePair_2_t_2064968959_0 *)&(__this->___current_3);
Object_t * L_3 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((KeyValuePair_2_t_2064968959_0 *)L_2, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
DictionaryEntry_t_1842557272_0 L_4 = {0};
DictionaryEntry__ctor_m_1694295436_0(&L_4, (Object_t *)L_1, (Object_t *)L_3, /*hidden argument*/NULL);
return L_4;
}
}
// System.Object System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::System.Collections.IDictionaryEnumerator.get_Key()
extern "C" Object_t * Enumerator_System_Collections_IDictionaryEnumerator_get_Key_m1201448700_0_gshared (Enumerator_t1711973002_0 * __this, const MethodInfo* method)
{
{
Object_t * L_0 = (( Object_t * (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7)->method)((Enumerator_t1711973002_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7));
return L_0;
}
}
// System.Object System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::System.Collections.IDictionaryEnumerator.get_Value()
extern "C" Object_t * Enumerator_System_Collections_IDictionaryEnumerator_get_Value_m294434446_0_gshared (Enumerator_t1711973002_0 * __this, const MethodInfo* method)
{
{
Object_t * L_0 = (( Object_t * (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8)->method)((Enumerator_t1711973002_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8));
return L_0;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::MoveNext()
extern "C" bool Enumerator_MoveNext_m217327200_0_gshared (Enumerator_t1711973002_0 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t V_1 = 0;
{
(( void (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9)->method)((Enumerator_t1711973002_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9));
int32_t L_0 = (int32_t)(__this->___next_1);
if ((((int32_t)L_0) >= ((int32_t)0)))
{
goto IL_0014;
}
}
{
return (bool)0;
}
IL_0014:
{
goto IL_007b;
}
IL_0019:
{
int32_t L_1 = (int32_t)(__this->___next_1);
int32_t L_2 = (int32_t)L_1;
V_1 = (int32_t)L_2;
__this->___next_1 = ((int32_t)((int32_t)L_2+(int32_t)1));
int32_t L_3 = V_1;
V_0 = (int32_t)L_3;
Dictionary_2_t_1114179913_0 * L_4 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
NullCheck(L_4);
LinkU5BU5D_t1854582343_0* L_5 = (LinkU5BU5D_t1854582343_0*)(L_4->___linkSlots_5);
int32_t L_6 = V_0;
NullCheck(L_5);
IL2CPP_ARRAY_BOUNDS_CHECK(L_5, L_6);
int32_t L_7 = (int32_t)(((Link_t976230437_0 *)(Link_t976230437_0 *)SZArrayLdElema(L_5, L_6, sizeof(Link_t976230437_0 )))->___HashCode_0);
if (!((int32_t)((int32_t)L_7&(int32_t)((int32_t)-2147483648LL))))
{
goto IL_007b;
}
}
{
Dictionary_2_t_1114179913_0 * L_8 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
NullCheck(L_8);
ObjectU5BU5D_t1774424924_0* L_9 = (ObjectU5BU5D_t1774424924_0*)(L_8->___keySlots_6);
int32_t L_10 = V_0;
NullCheck(L_9);
IL2CPP_ARRAY_BOUNDS_CHECK(L_9, L_10);
int32_t L_11 = L_10;
Dictionary_2_t_1114179913_0 * L_12 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
NullCheck(L_12);
ObjectU5BU5D_t1774424924_0* L_13 = (ObjectU5BU5D_t1774424924_0*)(L_12->___valueSlots_7);
int32_t L_14 = V_0;
NullCheck(L_13);
IL2CPP_ARRAY_BOUNDS_CHECK(L_13, L_14);
int32_t L_15 = L_14;
KeyValuePair_2_t_2064968959_0 L_16 = {0};
(( void (*) (KeyValuePair_2_t_2064968959_0 *, Object_t *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)(&L_16, (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_9, L_11, sizeof(Object_t *))), (Object_t *)(*(Object_t **)(Object_t **)SZArrayLdElema(L_13, L_15, sizeof(Object_t *))), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
__this->___current_3 = L_16;
return (bool)1;
}
IL_007b:
{
int32_t L_17 = (int32_t)(__this->___next_1);
Dictionary_2_t_1114179913_0 * L_18 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
NullCheck(L_18);
int32_t L_19 = (int32_t)(L_18->___touchedSlots_8);
if ((((int32_t)L_17) < ((int32_t)L_19)))
{
goto IL_0019;
}
}
{
__this->___next_1 = (-1);
return (bool)0;
}
}
// System.Collections.Generic.KeyValuePair`2<TKey,TValue> System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::get_Current()
extern "C" KeyValuePair_2_t_2064968959_0 Enumerator_get_Current_m_54964272_0_gshared (Enumerator_t1711973002_0 * __this, const MethodInfo* method)
{
{
KeyValuePair_2_t_2064968959_0 L_0 = (KeyValuePair_2_t_2064968959_0 )(__this->___current_3);
return L_0;
}
}
// TKey System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::get_CurrentKey()
extern "C" Object_t * Enumerator_get_CurrentKey_m_1232807379_0_gshared (Enumerator_t1711973002_0 * __this, const MethodInfo* method)
{
{
(( void (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Enumerator_t1711973002_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
KeyValuePair_2_t_2064968959_0 * L_0 = (KeyValuePair_2_t_2064968959_0 *)&(__this->___current_3);
Object_t * L_1 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((KeyValuePair_2_t_2064968959_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
return L_1;
}
}
// TValue System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::get_CurrentValue()
extern "C" Object_t * Enumerator_get_CurrentValue_m592783249_0_gshared (Enumerator_t1711973002_0 * __this, const MethodInfo* method)
{
{
(( void (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Enumerator_t1711973002_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
KeyValuePair_2_t_2064968959_0 * L_0 = (KeyValuePair_2_t_2064968959_0 *)&(__this->___current_3);
Object_t * L_1 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((KeyValuePair_2_t_2064968959_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::Reset()
extern "C" void Enumerator_Reset_m_1293591693_0_gshared (Enumerator_t1711973002_0 * __this, const MethodInfo* method)
{
{
(( void (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9)->method)((Enumerator_t1711973002_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9));
__this->___next_1 = 0;
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::VerifyState()
extern TypeInfo* ObjectDisposedException_t_1490685872_0_il2cpp_TypeInfo_var;
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_4380558_0;
extern "C" void Enumerator_VerifyState_m_4912836_0_gshared (Enumerator_t1711973002_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ObjectDisposedException_t_1490685872_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(137);
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral_4380558_0 = il2cpp_codegen_string_literal_from_index(503);
s_Il2CppMethodIntialized = true;
}
{
Dictionary_2_t_1114179913_0 * L_0 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
if (L_0)
{
goto IL_0012;
}
}
{
ObjectDisposedException_t_1490685872_0 * L_1 = (ObjectDisposedException_t_1490685872_0 *)il2cpp_codegen_object_new (ObjectDisposedException_t_1490685872_0_il2cpp_TypeInfo_var);
ObjectDisposedException__ctor_m1180707260_0(L_1, (String_t*)NULL, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0012:
{
Dictionary_2_t_1114179913_0 * L_2 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
NullCheck(L_2);
int32_t L_3 = (int32_t)(L_2->___generation_14);
int32_t L_4 = (int32_t)(__this->___stamp_2);
if ((((int32_t)L_3) == ((int32_t)L_4)))
{
goto IL_0033;
}
}
{
InvalidOperationException_t_523179548_0 * L_5 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_5, (String_t*)_stringLiteral_4380558_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_5);
}
IL_0033:
{
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::VerifyCurrent()
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral1609931872_0;
extern "C" void Enumerator_VerifyCurrent_m_1976363612_0_gshared (Enumerator_t1711973002_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral1609931872_0 = il2cpp_codegen_string_literal_from_index(504);
s_Il2CppMethodIntialized = true;
}
{
(( void (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9)->method)((Enumerator_t1711973002_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9));
int32_t L_0 = (int32_t)(__this->___next_1);
if ((((int32_t)L_0) > ((int32_t)0)))
{
goto IL_001d;
}
}
{
InvalidOperationException_t_523179548_0 * L_1 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_1, (String_t*)_stringLiteral1609931872_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_001d:
{
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Enumerator<System.Object,System.Object>::Dispose()
extern "C" void Enumerator_Dispose_m627360643_0_gshared (Enumerator_t1711973002_0 * __this, const MethodInfo* method)
{
{
__this->___dictionary_0 = (Dictionary_2_t_1114179913_0 *)NULL;
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Object>::.ctor(System.Object,System.IntPtr)
extern "C" void Transform_1__ctor_m582405827_0_gshared (Transform_1_t1919841591_0 * __this, Object_t * ___object, IntPtr_t ___method, const MethodInfo* method)
{
__this->___method_ptr_0 = (methodPointerType)((MethodInfo*)___method.___m_value_0)->method;
__this->___method_3 = ___method;
__this->___m_target_2 = ___object;
}
// TRet System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Object>::Invoke(TKey,TValue)
extern "C" Object_t * Transform_1_Invoke_m_587817255_0_gshared (Transform_1_t1919841591_0 * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method)
{
if(__this->___prev_9 != NULL)
{
Transform_1_Invoke_m_587817255_0((Transform_1_t1919841591_0 *)__this->___prev_9,___key, ___value, method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->___method_3.___m_value_0));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->___method_3.___m_value_0));
if (__this->___m_target_2 != NULL && ___methodIsStatic)
{
typedef Object_t * (*FunctionPointerType) (Object_t *, Object_t * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(NULL,__this->___m_target_2,___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else if (__this->___m_target_2 != NULL || ___methodIsStatic)
{
typedef Object_t * (*FunctionPointerType) (Object_t * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(__this->___m_target_2,___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else
{
typedef Object_t * (*FunctionPointerType) (Object_t * __this, Object_t * ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
}
// System.IAsyncResult System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Object>::BeginInvoke(TKey,TValue,System.AsyncCallback,System.Object)
extern "C" Object_t * Transform_1_BeginInvoke_m788143672_0_gshared (Transform_1_t1919841591_0 * __this, Object_t * ___key, Object_t * ___value, AsyncCallback_t_266361018_0 * ___callback, Object_t * ___object, const MethodInfo* method)
{
void *__d_args[3] = {0};
__d_args[0] = ___key;
__d_args[1] = ___value;
return (Object_t *)il2cpp_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback, (Il2CppObject*)___object);
}
// TRet System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Object>::EndInvoke(System.IAsyncResult)
extern "C" Object_t * Transform_1_EndInvoke_m_1046843375_0_gshared (Transform_1_t1919841591_0 * __this, Object_t * ___result, const MethodInfo* method)
{
Il2CppObject *__result = il2cpp_delegate_end_invoke((Il2CppAsyncResult*) ___result, 0);
return (Object_t *)__result;
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>::.ctor(System.Collections.Generic.Dictionary`2<TKey,TValue>)
extern TypeInfo* ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral447049878_0;
extern "C" void ValueCollection__ctor_m_117708710_0_gshared (ValueCollection_t_418251273_0 * __this, Dictionary_2_t_1114179913_0 * ___dictionary, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(2);
_stringLiteral447049878_0 = il2cpp_codegen_string_literal_from_index(505);
s_Il2CppMethodIntialized = true;
}
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
Dictionary_2_t_1114179913_0 * L_0 = ___dictionary;
if (L_0)
{
goto IL_0017;
}
}
{
ArgumentNullException_t_1072101840_0 * L_1 = (ArgumentNullException_t_1072101840_0 *)il2cpp_codegen_object_new (ArgumentNullException_t_1072101840_0_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_m135444188_0(L_1, (String_t*)_stringLiteral447049878_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0017:
{
Dictionary_2_t_1114179913_0 * L_2 = ___dictionary;
__this->___dictionary_0 = L_2;
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>::System.Collections.Generic.ICollection<TValue>.Add(TValue)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2123164782_0;
extern "C" void ValueCollection_System_Collections_Generic_ICollectionU3CTValueU3E_Add_m1528225944_0_gshared (ValueCollection_t_418251273_0 * __this, Object_t * ___item, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
_stringLiteral2123164782_0 = il2cpp_codegen_string_literal_from_index(506);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m133757637_0(L_0, (String_t*)_stringLiteral2123164782_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>::System.Collections.Generic.ICollection<TValue>.Clear()
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2123164782_0;
extern "C" void ValueCollection_System_Collections_Generic_ICollectionU3CTValueU3E_Clear_m_1467688607_0_gshared (ValueCollection_t_418251273_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
_stringLiteral2123164782_0 = il2cpp_codegen_string_literal_from_index(506);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m133757637_0(L_0, (String_t*)_stringLiteral2123164782_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>::System.Collections.Generic.ICollection<TValue>.Contains(TValue)
extern "C" bool ValueCollection_System_Collections_Generic_ICollectionU3CTValueU3E_Contains_m2015709838_0_gshared (ValueCollection_t_418251273_0 * __this, Object_t * ___item, const MethodInfo* method)
{
{
Dictionary_2_t_1114179913_0 * L_0 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
Object_t * L_1 = ___item;
NullCheck((Dictionary_2_t_1114179913_0 *)L_0);
bool L_2 = (( bool (*) (Dictionary_2_t_1114179913_0 *, Object_t *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Dictionary_2_t_1114179913_0 *)L_0, (Object_t *)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
return L_2;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>::System.Collections.Generic.ICollection<TValue>.Remove(TValue)
extern TypeInfo* NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral2123164782_0;
extern "C" bool ValueCollection_System_Collections_Generic_ICollectionU3CTValueU3E_Remove_m_716460365_0_gshared (ValueCollection_t_418251273_0 * __this, Object_t * ___item, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(6);
_stringLiteral2123164782_0 = il2cpp_codegen_string_literal_from_index(506);
s_Il2CppMethodIntialized = true;
}
{
NotSupportedException_t1382227673_0 * L_0 = (NotSupportedException_t1382227673_0 *)il2cpp_codegen_object_new (NotSupportedException_t1382227673_0_il2cpp_TypeInfo_var);
NotSupportedException__ctor_m133757637_0(L_0, (String_t*)_stringLiteral2123164782_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_0);
}
}
// System.Collections.Generic.IEnumerator`1<TValue> System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>::System.Collections.Generic.IEnumerable<TValue>.GetEnumerator()
extern "C" Object_t* ValueCollection_System_Collections_Generic_IEnumerableU3CTValueU3E_GetEnumerator_m_253360785_0_gshared (ValueCollection_t_418251273_0 * __this, const MethodInfo* method)
{
{
NullCheck((ValueCollection_t_418251273_0 *)__this);
Enumerator_t_643919030_0 L_0 = (( Enumerator_t_643919030_0 (*) (ValueCollection_t_418251273_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((ValueCollection_t_418251273_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
Enumerator_t_643919030_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), &L_1);
return (Object_t*)L_2;
}
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>::System.Collections.ICollection.CopyTo(System.Array,System.Int32)
extern "C" void ValueCollection_System_Collections_ICollection_CopyTo_m1709700389_0_gshared (ValueCollection_t_418251273_0 * __this, Array_t * ___array, int32_t ___index, const MethodInfo* method)
{
ObjectU5BU5D_t1774424924_0* V_0 = {0};
{
Array_t * L_0 = ___array;
V_0 = (ObjectU5BU5D_t1774424924_0*)((ObjectU5BU5D_t1774424924_0*)IsInst(L_0, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)));
ObjectU5BU5D_t1774424924_0* L_1 = V_0;
if (!L_1)
{
goto IL_0016;
}
}
{
ObjectU5BU5D_t1774424924_0* L_2 = V_0;
int32_t L_3 = ___index;
NullCheck((ValueCollection_t_418251273_0 *)__this);
(( void (*) (ValueCollection_t_418251273_0 *, ObjectU5BU5D_t1774424924_0*, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)((ValueCollection_t_418251273_0 *)__this, (ObjectU5BU5D_t1774424924_0*)L_2, (int32_t)L_3, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
return;
}
IL_0016:
{
Dictionary_2_t_1114179913_0 * L_4 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
Array_t * L_5 = ___array;
int32_t L_6 = ___index;
NullCheck((Dictionary_2_t_1114179913_0 *)L_4);
(( void (*) (Dictionary_2_t_1114179913_0 *, Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((Dictionary_2_t_1114179913_0 *)L_4, (Array_t *)L_5, (int32_t)L_6, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
Dictionary_2_t_1114179913_0 * L_7 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
Array_t * L_8 = ___array;
int32_t L_9 = ___index;
IntPtr_t L_10 = { (void*)IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6) };
Transform_1_t1919841591_0 * L_11 = (Transform_1_t1919841591_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7));
(( void (*) (Transform_1_t1919841591_0 *, Object_t *, IntPtr_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8)->method)(L_11, (Object_t *)NULL, (IntPtr_t)L_10, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8));
NullCheck((Dictionary_2_t_1114179913_0 *)L_7);
(( void (*) (Dictionary_2_t_1114179913_0 *, Array_t *, int32_t, Transform_1_t1919841591_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9)->method)((Dictionary_2_t_1114179913_0 *)L_7, (Array_t *)L_8, (int32_t)L_9, (Transform_1_t1919841591_0 *)L_11, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9));
return;
}
}
// System.Collections.IEnumerator System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>::System.Collections.IEnumerable.GetEnumerator()
extern "C" Object_t * ValueCollection_System_Collections_IEnumerable_GetEnumerator_m_1451579808_0_gshared (ValueCollection_t_418251273_0 * __this, const MethodInfo* method)
{
{
NullCheck((ValueCollection_t_418251273_0 *)__this);
Enumerator_t_643919030_0 L_0 = (( Enumerator_t_643919030_0 (*) (ValueCollection_t_418251273_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((ValueCollection_t_418251273_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
Enumerator_t_643919030_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), &L_1);
return (Object_t *)L_2;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>::System.Collections.Generic.ICollection<TValue>.get_IsReadOnly()
extern "C" bool ValueCollection_System_Collections_Generic_ICollectionU3CTValueU3E_get_IsReadOnly_m290885697_0_gshared (ValueCollection_t_418251273_0 * __this, const MethodInfo* method)
{
{
return (bool)1;
}
}
// System.Object System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>::System.Collections.ICollection.get_SyncRoot()
extern TypeInfo* ICollection_t592284435_0_il2cpp_TypeInfo_var;
extern "C" Object_t * ValueCollection_System_Collections_ICollection_get_SyncRoot_m1874108365_0_gshared (ValueCollection_t_418251273_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
ICollection_t592284435_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(184);
s_Il2CppMethodIntialized = true;
}
{
Dictionary_2_t_1114179913_0 * L_0 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
NullCheck((Object_t *)L_0);
Object_t * L_1 = (Object_t *)InterfaceFuncInvoker0< Object_t * >::Invoke(1 /* System.Object System.Collections.ICollection::get_SyncRoot() */, ICollection_t592284435_0_il2cpp_TypeInfo_var, (Object_t *)L_0);
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>::CopyTo(TValue[],System.Int32)
extern "C" void ValueCollection_CopyTo_m1735386657_0_gshared (ValueCollection_t_418251273_0 * __this, ObjectU5BU5D_t1774424924_0* ___array, int32_t ___index, const MethodInfo* method)
{
{
Dictionary_2_t_1114179913_0 * L_0 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
ObjectU5BU5D_t1774424924_0* L_1 = ___array;
int32_t L_2 = ___index;
NullCheck((Dictionary_2_t_1114179913_0 *)L_0);
(( void (*) (Dictionary_2_t_1114179913_0 *, Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((Dictionary_2_t_1114179913_0 *)L_0, (Array_t *)(Array_t *)L_1, (int32_t)L_2, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
Dictionary_2_t_1114179913_0 * L_3 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
ObjectU5BU5D_t1774424924_0* L_4 = ___array;
int32_t L_5 = ___index;
IntPtr_t L_6 = { (void*)IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6) };
Transform_1_t1919841591_0 * L_7 = (Transform_1_t1919841591_0 *)il2cpp_codegen_object_new (IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 7));
(( void (*) (Transform_1_t1919841591_0 *, Object_t *, IntPtr_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8)->method)(L_7, (Object_t *)NULL, (IntPtr_t)L_6, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 8));
NullCheck((Dictionary_2_t_1114179913_0 *)L_3);
(( void (*) (Dictionary_2_t_1114179913_0 *, ObjectU5BU5D_t1774424924_0*, int32_t, Transform_1_t1919841591_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10)->method)((Dictionary_2_t_1114179913_0 *)L_3, (ObjectU5BU5D_t1774424924_0*)L_4, (int32_t)L_5, (Transform_1_t1919841591_0 *)L_7, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 10));
return;
}
}
// System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<TKey,TValue> System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>::GetEnumerator()
extern "C" Enumerator_t_643919030_0 ValueCollection_GetEnumerator_m1204216004_0_gshared (ValueCollection_t_418251273_0 * __this, const MethodInfo* method)
{
{
Dictionary_2_t_1114179913_0 * L_0 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
Enumerator_t_643919030_0 L_1 = {0};
(( void (*) (Enumerator_t_643919030_0 *, Dictionary_2_t_1114179913_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11)->method)(&L_1, (Dictionary_2_t_1114179913_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 11));
return L_1;
}
}
// System.Int32 System.Collections.Generic.Dictionary`2/ValueCollection<System.Object,System.Object>::get_Count()
extern "C" int32_t ValueCollection_get_Count_m_1585735449_0_gshared (ValueCollection_t_418251273_0 * __this, const MethodInfo* method)
{
{
Dictionary_2_t_1114179913_0 * L_0 = (Dictionary_2_t_1114179913_0 *)(__this->___dictionary_0);
NullCheck((Dictionary_2_t_1114179913_0 *)L_0);
int32_t L_1 = (int32_t)VirtFuncInvoker0< int32_t >::Invoke(9 /* System.Int32 System.Collections.Generic.Dictionary`2<System.Object,System.Object>::get_Count() */, (Dictionary_2_t_1114179913_0 *)L_0);
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<System.Object,System.Object>::.ctor(System.Collections.Generic.Dictionary`2<TKey,TValue>)
extern "C" void Enumerator__ctor_m76754913_0_gshared (Enumerator_t_643919030_0 * __this, Dictionary_2_t_1114179913_0 * ___host, const MethodInfo* method)
{
{
Dictionary_2_t_1114179913_0 * L_0 = ___host;
NullCheck((Dictionary_2_t_1114179913_0 *)L_0);
Enumerator_t1711973002_0 L_1 = (( Enumerator_t1711973002_0 (*) (Dictionary_2_t_1114179913_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Dictionary_2_t_1114179913_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
__this->___host_enumerator_0 = L_1;
return;
}
}
// System.Object System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<System.Object,System.Object>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * Enumerator_System_Collections_IEnumerator_get_Current_m_1176770848_0_gshared (Enumerator_t_643919030_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 * L_0 = (Enumerator_t1711973002_0 *)&(__this->___host_enumerator_0);
Object_t * L_1 = (( Object_t * (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((Enumerator_t1711973002_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
return L_1;
}
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<System.Object,System.Object>::System.Collections.IEnumerator.Reset()
extern "C" void Enumerator_System_Collections_IEnumerator_Reset_m_592767436_0_gshared (Enumerator_t_643919030_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 * L_0 = (Enumerator_t1711973002_0 *)&(__this->___host_enumerator_0);
(( void (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((Enumerator_t1711973002_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
return;
}
}
// System.Void System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<System.Object,System.Object>::Dispose()
extern "C" void Enumerator_Dispose_m1628348611_0_gshared (Enumerator_t_643919030_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 * L_0 = (Enumerator_t1711973002_0 *)&(__this->___host_enumerator_0);
(( void (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)((Enumerator_t1711973002_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<System.Object,System.Object>::MoveNext()
extern "C" bool Enumerator_MoveNext_m_738544352_0_gshared (Enumerator_t_643919030_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 * L_0 = (Enumerator_t1711973002_0 *)&(__this->___host_enumerator_0);
bool L_1 = (( bool (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5)->method)((Enumerator_t1711973002_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 5));
return L_1;
}
}
// TValue System.Collections.Generic.Dictionary`2/ValueCollection/Enumerator<System.Object,System.Object>::get_Current()
extern "C" Object_t * Enumerator_get_Current_m841474402_0_gshared (Enumerator_t_643919030_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 * L_0 = (Enumerator_t1711973002_0 *)&(__this->___host_enumerator_0);
KeyValuePair_2_t_2064968959_0 * L_1 = (KeyValuePair_2_t_2064968959_0 *)&(L_0->___current_3);
Object_t * L_2 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6)->method)((KeyValuePair_2_t_2064968959_0 *)L_1, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6));
return L_2;
}
}
// System.Void System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Collections.DictionaryEntry>::.ctor(System.Object,System.IntPtr)
extern "C" void Transform_1__ctor_m2052388693_0_gshared (Transform_1_t1095225411_0 * __this, Object_t * ___object, IntPtr_t ___method, const MethodInfo* method)
{
__this->___method_ptr_0 = (methodPointerType)((MethodInfo*)___method.___m_value_0)->method;
__this->___method_3 = ___method;
__this->___m_target_2 = ___object;
}
// TRet System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Collections.DictionaryEntry>::Invoke(TKey,TValue)
extern "C" DictionaryEntry_t_1842557272_0 Transform_1_Invoke_m757436355_0_gshared (Transform_1_t1095225411_0 * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method)
{
if(__this->___prev_9 != NULL)
{
Transform_1_Invoke_m757436355_0((Transform_1_t1095225411_0 *)__this->___prev_9,___key, ___value, method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->___method_3.___m_value_0));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->___method_3.___m_value_0));
if (__this->___m_target_2 != NULL && ___methodIsStatic)
{
typedef DictionaryEntry_t_1842557272_0 (*FunctionPointerType) (Object_t *, Object_t * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(NULL,__this->___m_target_2,___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else if (__this->___m_target_2 != NULL || ___methodIsStatic)
{
typedef DictionaryEntry_t_1842557272_0 (*FunctionPointerType) (Object_t * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(__this->___m_target_2,___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else
{
typedef DictionaryEntry_t_1842557272_0 (*FunctionPointerType) (Object_t * __this, Object_t * ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
}
// System.IAsyncResult System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Collections.DictionaryEntry>::BeginInvoke(TKey,TValue,System.AsyncCallback,System.Object)
extern "C" Object_t * Transform_1_BeginInvoke_m397518190_0_gshared (Transform_1_t1095225411_0 * __this, Object_t * ___key, Object_t * ___value, AsyncCallback_t_266361018_0 * ___callback, Object_t * ___object, const MethodInfo* method)
{
void *__d_args[3] = {0};
__d_args[0] = ___key;
__d_args[1] = ___value;
return (Object_t *)il2cpp_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback, (Il2CppObject*)___object);
}
// TRet System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Collections.DictionaryEntry>::EndInvoke(System.IAsyncResult)
extern "C" DictionaryEntry_t_1842557272_0 Transform_1_EndInvoke_m_1139365657_0_gshared (Transform_1_t1095225411_0 * __this, Object_t * ___result, const MethodInfo* method)
{
Il2CppObject *__result = il2cpp_delegate_end_invoke((Il2CppAsyncResult*) ___result, 0);
return *(DictionaryEntry_t_1842557272_0 *)UnBox ((Il2CppCodeGenObject*)__result);
}
// System.Void System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::.ctor(System.Object,System.IntPtr)
extern "C" void Transform_1__ctor_m1310500508_0_gshared (Transform_1_t1321960586_0 * __this, Object_t * ___object, IntPtr_t ___method, const MethodInfo* method)
{
__this->___method_ptr_0 = (methodPointerType)((MethodInfo*)___method.___m_value_0)->method;
__this->___method_3 = ___method;
__this->___m_target_2 = ___object;
}
// TRet System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::Invoke(TKey,TValue)
extern "C" KeyValuePair_2_t_2064968959_0 Transform_1_Invoke_m1166627932_0_gshared (Transform_1_t1321960586_0 * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method)
{
if(__this->___prev_9 != NULL)
{
Transform_1_Invoke_m1166627932_0((Transform_1_t1321960586_0 *)__this->___prev_9,___key, ___value, method);
}
il2cpp_codegen_raise_execution_engine_exception_if_method_is_not_found((MethodInfo*)(__this->___method_3.___m_value_0));
bool ___methodIsStatic = MethodIsStatic((MethodInfo*)(__this->___method_3.___m_value_0));
if (__this->___m_target_2 != NULL && ___methodIsStatic)
{
typedef KeyValuePair_2_t_2064968959_0 (*FunctionPointerType) (Object_t *, Object_t * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(NULL,__this->___m_target_2,___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else if (__this->___m_target_2 != NULL || ___methodIsStatic)
{
typedef KeyValuePair_2_t_2064968959_0 (*FunctionPointerType) (Object_t * __this, Object_t * ___key, Object_t * ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(__this->___m_target_2,___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
else
{
typedef KeyValuePair_2_t_2064968959_0 (*FunctionPointerType) (Object_t * __this, Object_t * ___value, const MethodInfo* method);
return ((FunctionPointerType)__this->___method_ptr_0)(___key, ___value,(MethodInfo*)(__this->___method_3.___m_value_0));
}
}
// System.IAsyncResult System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::BeginInvoke(TKey,TValue,System.AsyncCallback,System.Object)
extern "C" Object_t * Transform_1_BeginInvoke_m_770379257_0_gshared (Transform_1_t1321960586_0 * __this, Object_t * ___key, Object_t * ___value, AsyncCallback_t_266361018_0 * ___callback, Object_t * ___object, const MethodInfo* method)
{
void *__d_args[3] = {0};
__d_args[0] = ___key;
__d_args[1] = ___value;
return (Object_t *)il2cpp_delegate_begin_invoke((Il2CppDelegate*)__this, __d_args, (Il2CppDelegate*)___callback, (Il2CppObject*)___object);
}
// TRet System.Collections.Generic.Dictionary`2/Transform`1<System.Object,System.Object,System.Collections.Generic.KeyValuePair`2<System.Object,System.Object>>::EndInvoke(System.IAsyncResult)
extern "C" KeyValuePair_2_t_2064968959_0 Transform_1_EndInvoke_m865876654_0_gshared (Transform_1_t1321960586_0 * __this, Object_t * ___result, const MethodInfo* method)
{
Il2CppObject *__result = il2cpp_delegate_end_invoke((Il2CppAsyncResult*) ___result, 0);
return *(KeyValuePair_2_t_2064968959_0 *)UnBox ((Il2CppCodeGenObject*)__result);
}
// System.Void System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Object>::.ctor(System.Collections.Generic.Dictionary`2<TKey,TValue>)
extern "C" void ShimEnumerator__ctor_m1134937082_0_gshared (ShimEnumerator_t_578441199_0 * __this, Dictionary_2_t_1114179913_0 * ___host, const MethodInfo* method)
{
{
NullCheck((Object_t *)__this);
Object__ctor_m1772956182_0((Object_t *)__this, /*hidden argument*/NULL);
Dictionary_2_t_1114179913_0 * L_0 = ___host;
NullCheck((Dictionary_2_t_1114179913_0 *)L_0);
Enumerator_t1711973002_0 L_1 = (( Enumerator_t1711973002_0 (*) (Dictionary_2_t_1114179913_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((Dictionary_2_t_1114179913_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
__this->___host_enumerator_0 = L_1;
return;
}
}
// System.Boolean System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Object>::MoveNext()
extern "C" bool ShimEnumerator_MoveNext_m_1124126489_0_gshared (ShimEnumerator_t_578441199_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 * L_0 = (Enumerator_t1711973002_0 *)&(__this->___host_enumerator_0);
bool L_1 = (( bool (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1)->method)((Enumerator_t1711973002_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
return L_1;
}
}
// System.Collections.DictionaryEntry System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Object>::get_Entry()
extern TypeInfo* IDictionaryEnumerator_t_855216337_0_il2cpp_TypeInfo_var;
extern "C" DictionaryEntry_t_1842557272_0 ShimEnumerator_get_Entry_m_162371635_0_gshared (ShimEnumerator_t_578441199_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
IDictionaryEnumerator_t_855216337_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(163);
s_Il2CppMethodIntialized = true;
}
{
Enumerator_t1711973002_0 L_0 = (Enumerator_t1711973002_0 )(__this->___host_enumerator_0);
Enumerator_t1711973002_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2), &L_1);
NullCheck((Object_t *)L_2);
DictionaryEntry_t_1842557272_0 L_3 = (DictionaryEntry_t_1842557272_0 )InterfaceFuncInvoker0< DictionaryEntry_t_1842557272_0 >::Invoke(0 /* System.Collections.DictionaryEntry System.Collections.IDictionaryEnumerator::get_Entry() */, IDictionaryEnumerator_t_855216337_0_il2cpp_TypeInfo_var, (Object_t *)L_2);
return L_3;
}
}
// System.Object System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Object>::get_Key()
extern "C" Object_t * ShimEnumerator_get_Key_m384355048_0_gshared (ShimEnumerator_t_578441199_0 * __this, const MethodInfo* method)
{
KeyValuePair_2_t_2064968959_0 V_0 = {0};
{
Enumerator_t1711973002_0 * L_0 = (Enumerator_t1711973002_0 *)&(__this->___host_enumerator_0);
KeyValuePair_2_t_2064968959_0 L_1 = (( KeyValuePair_2_t_2064968959_0 (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((Enumerator_t1711973002_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
V_0 = (KeyValuePair_2_t_2064968959_0 )L_1;
Object_t * L_2 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4)->method)((KeyValuePair_2_t_2064968959_0 *)(&V_0), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 4));
return L_2;
}
}
// System.Object System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Object>::get_Value()
extern "C" Object_t * ShimEnumerator_get_Value_m1046450042_0_gshared (ShimEnumerator_t_578441199_0 * __this, const MethodInfo* method)
{
KeyValuePair_2_t_2064968959_0 V_0 = {0};
{
Enumerator_t1711973002_0 * L_0 = (Enumerator_t1711973002_0 *)&(__this->___host_enumerator_0);
KeyValuePair_2_t_2064968959_0 L_1 = (( KeyValuePair_2_t_2064968959_0 (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3)->method)((Enumerator_t1711973002_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3));
V_0 = (KeyValuePair_2_t_2064968959_0 )L_1;
Object_t * L_2 = (( Object_t * (*) (KeyValuePair_2_t_2064968959_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6)->method)((KeyValuePair_2_t_2064968959_0 *)(&V_0), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 6));
return L_2;
}
}
// System.Object System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Object>::get_Current()
extern TypeInfo* DictionaryEntry_t_1842557272_0_il2cpp_TypeInfo_var;
extern "C" Object_t * ShimEnumerator_get_Current_m2040833922_0_gshared (ShimEnumerator_t_578441199_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
DictionaryEntry_t_1842557272_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(195);
s_Il2CppMethodIntialized = true;
}
{
NullCheck((ShimEnumerator_t_578441199_0 *)__this);
DictionaryEntry_t_1842557272_0 L_0 = (DictionaryEntry_t_1842557272_0 )VirtFuncInvoker0< DictionaryEntry_t_1842557272_0 >::Invoke(7 /* System.Collections.DictionaryEntry System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Object>::get_Entry() */, (ShimEnumerator_t_578441199_0 *)__this);
DictionaryEntry_t_1842557272_0 L_1 = L_0;
Object_t * L_2 = Box(DictionaryEntry_t_1842557272_0_il2cpp_TypeInfo_var, &L_1);
return L_2;
}
}
// System.Void System.Collections.Generic.Dictionary`2/ShimEnumerator<System.Object,System.Object>::Reset()
extern "C" void ShimEnumerator_Reset_m_1073281204_0_gshared (ShimEnumerator_t_578441199_0 * __this, const MethodInfo* method)
{
{
Enumerator_t1711973002_0 * L_0 = (Enumerator_t1711973002_0 *)&(__this->___host_enumerator_0);
(( void (*) (Enumerator_t1711973002_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9)->method)((Enumerator_t1711973002_0 *)L_0, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 9));
return;
}
}
// System.Void System.Collections.Generic.GenericEqualityComparer`1<System.Object>::.ctor()
extern "C" void GenericEqualityComparer_1__ctor_m1097371640_0_gshared (GenericEqualityComparer_1_t378592920_0 * __this, const MethodInfo* method)
{
{
NullCheck((EqualityComparer_1_t1498484409_0 *)__this);
IL2CPP_RUNTIME_CLASS_INIT(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1));
(( void (*) (EqualityComparer_1_t1498484409_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((EqualityComparer_1_t1498484409_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
return;
}
}
// System.Int32 System.Collections.Generic.GenericEqualityComparer`1<System.Object>::GetHashCode(T)
extern "C" int32_t GenericEqualityComparer_1_GetHashCode_m_272042501_0_gshared (GenericEqualityComparer_1_t378592920_0 * __this, Object_t * ___obj, const MethodInfo* method)
{
{
Object_t * L_0 = ___obj;
if (L_0)
{
goto IL_000d;
}
}
{
return 0;
}
IL_000d:
{
NullCheck((Object_t *)(*(&___obj)));
int32_t L_1 = (int32_t)VirtFuncInvoker0< int32_t >::Invoke(2 /* System.Int32 System.Object::GetHashCode() */, (Object_t *)(*(&___obj)));
return L_1;
}
}
// System.Boolean System.Collections.Generic.GenericEqualityComparer`1<System.Object>::Equals(T,T)
extern "C" bool GenericEqualityComparer_1_Equals_m2036593421_0_gshared (GenericEqualityComparer_1_t378592920_0 * __this, Object_t * ___x, Object_t * ___y, const MethodInfo* method)
{
{
Object_t * L_0 = ___x;
if (L_0)
{
goto IL_0015;
}
}
{
Object_t * L_1 = ___y;
return (bool)((((Object_t*)(Object_t *)L_1) == ((Object_t*)(Object_t *)NULL))? 1 : 0);
}
IL_0015:
{
Object_t * L_2 = ___y;
NullCheck((Object_t*)(*(&___x)));
bool L_3 = (bool)InterfaceFuncInvoker1< bool, Object_t * >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 3), (Object_t*)(*(&___x)), (Object_t *)L_2);
return L_3;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Boolean>::.ctor(System.Array)
extern "C" void InternalEnumerator_1__ctor_m_390090438_0_gshared (InternalEnumerator_1_t1042047996_0 * __this, Array_t * ___array, const MethodInfo* method)
{
{
Array_t * L_0 = ___array;
__this->___array_0 = L_0;
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Boolean>::System.Collections.IEnumerator.Reset()
extern "C" void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m_1794017754_0_gshared (InternalEnumerator_1_t1042047996_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Object System.Array/InternalEnumerator`1<System.Boolean>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1200057490_0_gshared (InternalEnumerator_1_t1042047996_0 * __this, const MethodInfo* method)
{
{
bool L_0 = (( bool (*) (InternalEnumerator_1_t1042047996_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((InternalEnumerator_1_t1042047996_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
bool L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Boolean>::Dispose()
extern "C" void InternalEnumerator_1_Dispose_m_1789617263_0_gshared (InternalEnumerator_1_t1042047996_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Boolean System.Array/InternalEnumerator`1<System.Boolean>::MoveNext()
extern "C" bool InternalEnumerator_1_MoveNext_m_1436102510_0_gshared (InternalEnumerator_1_t1042047996_0 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t G_B5_0 = 0;
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001e;
}
}
{
Array_t * L_1 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_1);
int32_t L_2 = Array_get_Length_m1203127607_0((Array_t *)L_1, /*hidden argument*/NULL);
__this->___idx_1 = L_2;
}
IL_001e:
{
int32_t L_3 = (int32_t)(__this->___idx_1);
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_0043;
}
}
{
int32_t L_4 = (int32_t)(__this->___idx_1);
int32_t L_5 = (int32_t)((int32_t)((int32_t)L_4-(int32_t)1));
V_0 = (int32_t)L_5;
__this->___idx_1 = L_5;
int32_t L_6 = V_0;
G_B5_0 = ((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0044;
}
IL_0043:
{
G_B5_0 = 0;
}
IL_0044:
{
return (bool)G_B5_0;
}
}
// T System.Array/InternalEnumerator`1<System.Boolean>::get_Current()
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_673706721_0;
extern Il2CppCodeGenString* _stringLiteral_2097638381_0;
extern "C" bool InternalEnumerator_1_get_Current_m94889217_0_gshared (InternalEnumerator_1_t1042047996_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral_673706721_0 = il2cpp_codegen_string_literal_from_index(193);
_stringLiteral_2097638381_0 = il2cpp_codegen_string_literal_from_index(194);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0018;
}
}
{
InvalidOperationException_t_523179548_0 * L_1 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_1, (String_t*)_stringLiteral_673706721_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0018:
{
int32_t L_2 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_002f;
}
}
{
InvalidOperationException_t_523179548_0 * L_3 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_3, (String_t*)_stringLiteral_2097638381_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
IL_002f:
{
Array_t * L_4 = (Array_t *)(__this->___array_0);
Array_t * L_5 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_5);
int32_t L_6 = Array_get_Length_m1203127607_0((Array_t *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)(__this->___idx_1);
NullCheck((Array_t *)L_4);
bool L_8 = (( bool (*) (Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((Array_t *)L_4, (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_6-(int32_t)1))-(int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
return L_8;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Hashtable/Slot>::.ctor(System.Array)
extern "C" void InternalEnumerator_1__ctor_m1735201994_0_gshared (InternalEnumerator_1_t1400405874_0 * __this, Array_t * ___array, const MethodInfo* method)
{
{
Array_t * L_0 = ___array;
__this->___array_0 = L_0;
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Hashtable/Slot>::System.Collections.IEnumerator.Reset()
extern "C" void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m372492438_0_gshared (InternalEnumerator_1_t1400405874_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.Hashtable/Slot>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m434290508_0_gshared (InternalEnumerator_1_t1400405874_0 * __this, const MethodInfo* method)
{
{
Slot_t1363074209_0 L_0 = (( Slot_t1363074209_0 (*) (InternalEnumerator_1_t1400405874_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((InternalEnumerator_1_t1400405874_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
Slot_t1363074209_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.Hashtable/Slot>::Dispose()
extern "C" void InternalEnumerator_1_Dispose_m_1456590047_0_gshared (InternalEnumerator_1_t1400405874_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.Hashtable/Slot>::MoveNext()
extern "C" bool InternalEnumerator_1_MoveNext_m_1619241530_0_gshared (InternalEnumerator_1_t1400405874_0 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t G_B5_0 = 0;
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001e;
}
}
{
Array_t * L_1 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_1);
int32_t L_2 = Array_get_Length_m1203127607_0((Array_t *)L_1, /*hidden argument*/NULL);
__this->___idx_1 = L_2;
}
IL_001e:
{
int32_t L_3 = (int32_t)(__this->___idx_1);
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_0043;
}
}
{
int32_t L_4 = (int32_t)(__this->___idx_1);
int32_t L_5 = (int32_t)((int32_t)((int32_t)L_4-(int32_t)1));
V_0 = (int32_t)L_5;
__this->___idx_1 = L_5;
int32_t L_6 = V_0;
G_B5_0 = ((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0044;
}
IL_0043:
{
G_B5_0 = 0;
}
IL_0044:
{
return (bool)G_B5_0;
}
}
// T System.Array/InternalEnumerator`1<System.Collections.Hashtable/Slot>::get_Current()
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_673706721_0;
extern Il2CppCodeGenString* _stringLiteral_2097638381_0;
extern "C" Slot_t1363074209_0 InternalEnumerator_1_get_Current_m_1258540877_0_gshared (InternalEnumerator_1_t1400405874_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral_673706721_0 = il2cpp_codegen_string_literal_from_index(193);
_stringLiteral_2097638381_0 = il2cpp_codegen_string_literal_from_index(194);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0018;
}
}
{
InvalidOperationException_t_523179548_0 * L_1 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_1, (String_t*)_stringLiteral_673706721_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0018:
{
int32_t L_2 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_002f;
}
}
{
InvalidOperationException_t_523179548_0 * L_3 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_3, (String_t*)_stringLiteral_2097638381_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
IL_002f:
{
Array_t * L_4 = (Array_t *)(__this->___array_0);
Array_t * L_5 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_5);
int32_t L_6 = Array_get_Length_m1203127607_0((Array_t *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)(__this->___idx_1);
NullCheck((Array_t *)L_4);
Slot_t1363074209_0 L_8 = (( Slot_t1363074209_0 (*) (Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((Array_t *)L_4, (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_6-(int32_t)1))-(int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
return L_8;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.SortedList/Slot>::.ctor(System.Array)
extern "C" void InternalEnumerator_1__ctor_m831950091_0_gshared (InternalEnumerator_1_t1155067659_0 * __this, Array_t * ___array, const MethodInfo* method)
{
{
Array_t * L_0 = ___array;
__this->___array_0 = L_0;
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.SortedList/Slot>::System.Collections.IEnumerator.Reset()
extern "C" void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m234798773_0_gshared (InternalEnumerator_1_t1155067659_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Object System.Array/InternalEnumerator`1<System.Collections.SortedList/Slot>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m_60675487_0_gshared (InternalEnumerator_1_t1155067659_0 * __this, const MethodInfo* method)
{
{
Slot_t20691934_0 L_0 = (( Slot_t20691934_0 (*) (InternalEnumerator_1_t1155067659_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((InternalEnumerator_1_t1155067659_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
Slot_t20691934_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Collections.SortedList/Slot>::Dispose()
extern "C" void InternalEnumerator_1_Dispose_m857987234_0_gshared (InternalEnumerator_1_t1155067659_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Boolean System.Array/InternalEnumerator`1<System.Collections.SortedList/Slot>::MoveNext()
extern "C" bool InternalEnumerator_1_MoveNext_m_530928991_0_gshared (InternalEnumerator_1_t1155067659_0 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t G_B5_0 = 0;
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001e;
}
}
{
Array_t * L_1 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_1);
int32_t L_2 = Array_get_Length_m1203127607_0((Array_t *)L_1, /*hidden argument*/NULL);
__this->___idx_1 = L_2;
}
IL_001e:
{
int32_t L_3 = (int32_t)(__this->___idx_1);
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_0043;
}
}
{
int32_t L_4 = (int32_t)(__this->___idx_1);
int32_t L_5 = (int32_t)((int32_t)((int32_t)L_4-(int32_t)1));
V_0 = (int32_t)L_5;
__this->___idx_1 = L_5;
int32_t L_6 = V_0;
G_B5_0 = ((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0044;
}
IL_0043:
{
G_B5_0 = 0;
}
IL_0044:
{
return (bool)G_B5_0;
}
}
// T System.Array/InternalEnumerator`1<System.Collections.SortedList/Slot>::get_Current()
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_673706721_0;
extern Il2CppCodeGenString* _stringLiteral_2097638381_0;
extern "C" Slot_t20691934_0 InternalEnumerator_1_get_Current_m_2027004910_0_gshared (InternalEnumerator_1_t1155067659_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral_673706721_0 = il2cpp_codegen_string_literal_from_index(193);
_stringLiteral_2097638381_0 = il2cpp_codegen_string_literal_from_index(194);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0018;
}
}
{
InvalidOperationException_t_523179548_0 * L_1 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_1, (String_t*)_stringLiteral_673706721_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0018:
{
int32_t L_2 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_002f;
}
}
{
InvalidOperationException_t_523179548_0 * L_3 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_3, (String_t*)_stringLiteral_2097638381_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
IL_002f:
{
Array_t * L_4 = (Array_t *)(__this->___array_0);
Array_t * L_5 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_5);
int32_t L_6 = Array_get_Length_m1203127607_0((Array_t *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)(__this->___idx_1);
NullCheck((Array_t *)L_4);
Slot_t20691934_0 L_8 = (( Slot_t20691934_0 (*) (Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((Array_t *)L_4, (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_6-(int32_t)1))-(int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
return L_8;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.Emit.ILTokenInfo>::.ctor(System.Array)
extern "C" void InternalEnumerator_1__ctor_m_1814008098_0_gshared (InternalEnumerator_1_t399519576_0 * __this, Array_t * ___array, const MethodInfo* method)
{
{
Array_t * L_0 = ___array;
__this->___array_0 = L_0;
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.Emit.ILTokenInfo>::System.Collections.IEnumerator.Reset()
extern "C" void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m_1260196350_0_gshared (InternalEnumerator_1_t399519576_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Object System.Array/InternalEnumerator`1<System.Reflection.Emit.ILTokenInfo>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m375843822_0_gshared (InternalEnumerator_1_t399519576_0 * __this, const MethodInfo* method)
{
{
ILTokenInfo_t1935982065_0 L_0 = (( ILTokenInfo_t1935982065_0 (*) (InternalEnumerator_1_t399519576_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((InternalEnumerator_1_t399519576_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
ILTokenInfo_t1935982065_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.Emit.ILTokenInfo>::Dispose()
extern "C" void InternalEnumerator_1_Dispose_m1771263541_0_gshared (InternalEnumerator_1_t399519576_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Boolean System.Array/InternalEnumerator`1<System.Reflection.Emit.ILTokenInfo>::MoveNext()
extern "C" bool InternalEnumerator_1_MoveNext_m2010832750_0_gshared (InternalEnumerator_1_t399519576_0 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t G_B5_0 = 0;
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001e;
}
}
{
Array_t * L_1 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_1);
int32_t L_2 = Array_get_Length_m1203127607_0((Array_t *)L_1, /*hidden argument*/NULL);
__this->___idx_1 = L_2;
}
IL_001e:
{
int32_t L_3 = (int32_t)(__this->___idx_1);
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_0043;
}
}
{
int32_t L_4 = (int32_t)(__this->___idx_1);
int32_t L_5 = (int32_t)((int32_t)((int32_t)L_4-(int32_t)1));
V_0 = (int32_t)L_5;
__this->___idx_1 = L_5;
int32_t L_6 = V_0;
G_B5_0 = ((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0044;
}
IL_0043:
{
G_B5_0 = 0;
}
IL_0044:
{
return (bool)G_B5_0;
}
}
// T System.Array/InternalEnumerator`1<System.Reflection.Emit.ILTokenInfo>::get_Current()
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_673706721_0;
extern Il2CppCodeGenString* _stringLiteral_2097638381_0;
extern "C" ILTokenInfo_t1935982065_0 InternalEnumerator_1_get_Current_m_676407259_0_gshared (InternalEnumerator_1_t399519576_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral_673706721_0 = il2cpp_codegen_string_literal_from_index(193);
_stringLiteral_2097638381_0 = il2cpp_codegen_string_literal_from_index(194);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0018;
}
}
{
InvalidOperationException_t_523179548_0 * L_1 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_1, (String_t*)_stringLiteral_673706721_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0018:
{
int32_t L_2 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_002f;
}
}
{
InvalidOperationException_t_523179548_0 * L_3 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_3, (String_t*)_stringLiteral_2097638381_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
IL_002f:
{
Array_t * L_4 = (Array_t *)(__this->___array_0);
Array_t * L_5 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_5);
int32_t L_6 = Array_get_Length_m1203127607_0((Array_t *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)(__this->___idx_1);
NullCheck((Array_t *)L_4);
ILTokenInfo_t1935982065_0 L_8 = (( ILTokenInfo_t1935982065_0 (*) (Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((Array_t *)L_4, (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_6-(int32_t)1))-(int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
return L_8;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.Emit.ILGenerator/LabelData>::.ctor(System.Array)
extern "C" void InternalEnumerator_1__ctor_m238137273_0_gshared (InternalEnumerator_1_t1382438749_0 * __this, Array_t * ___array, const MethodInfo* method)
{
{
Array_t * L_0 = ___array;
__this->___array_0 = L_0;
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.Emit.ILGenerator/LabelData>::System.Collections.IEnumerator.Reset()
extern "C" void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m1811681607_0_gshared (InternalEnumerator_1_t1382438749_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Object System.Array/InternalEnumerator`1<System.Reflection.Emit.ILGenerator/LabelData>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m_31605325_0_gshared (InternalEnumerator_1_t1382438749_0 * __this, const MethodInfo* method)
{
{
LabelData_t_1204723828_0 L_0 = (( LabelData_t_1204723828_0 (*) (InternalEnumerator_1_t1382438749_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((InternalEnumerator_1_t1382438749_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
LabelData_t_1204723828_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.Emit.ILGenerator/LabelData>::Dispose()
extern "C" void InternalEnumerator_1_Dispose_m_1042555696_0_gshared (InternalEnumerator_1_t1382438749_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Boolean System.Array/InternalEnumerator`1<System.Reflection.Emit.ILGenerator/LabelData>::MoveNext()
extern "C" bool InternalEnumerator_1_MoveNext_m_10471757_0_gshared (InternalEnumerator_1_t1382438749_0 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t G_B5_0 = 0;
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001e;
}
}
{
Array_t * L_1 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_1);
int32_t L_2 = Array_get_Length_m1203127607_0((Array_t *)L_1, /*hidden argument*/NULL);
__this->___idx_1 = L_2;
}
IL_001e:
{
int32_t L_3 = (int32_t)(__this->___idx_1);
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_0043;
}
}
{
int32_t L_4 = (int32_t)(__this->___idx_1);
int32_t L_5 = (int32_t)((int32_t)((int32_t)L_4-(int32_t)1));
V_0 = (int32_t)L_5;
__this->___idx_1 = L_5;
int32_t L_6 = V_0;
G_B5_0 = ((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0044;
}
IL_0043:
{
G_B5_0 = 0;
}
IL_0044:
{
return (bool)G_B5_0;
}
}
// T System.Array/InternalEnumerator`1<System.Reflection.Emit.ILGenerator/LabelData>::get_Current()
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_673706721_0;
extern Il2CppCodeGenString* _stringLiteral_2097638381_0;
extern "C" LabelData_t_1204723828_0 InternalEnumerator_1_get_Current_m_1986898304_0_gshared (InternalEnumerator_1_t1382438749_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral_673706721_0 = il2cpp_codegen_string_literal_from_index(193);
_stringLiteral_2097638381_0 = il2cpp_codegen_string_literal_from_index(194);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0018;
}
}
{
InvalidOperationException_t_523179548_0 * L_1 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_1, (String_t*)_stringLiteral_673706721_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0018:
{
int32_t L_2 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_002f;
}
}
{
InvalidOperationException_t_523179548_0 * L_3 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_3, (String_t*)_stringLiteral_2097638381_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
IL_002f:
{
Array_t * L_4 = (Array_t *)(__this->___array_0);
Array_t * L_5 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_5);
int32_t L_6 = Array_get_Length_m1203127607_0((Array_t *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)(__this->___idx_1);
NullCheck((Array_t *)L_4);
LabelData_t_1204723828_0 L_8 = (( LabelData_t_1204723828_0 (*) (Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((Array_t *)L_4, (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_6-(int32_t)1))-(int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
return L_8;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.Emit.ILGenerator/LabelFixup>::.ctor(System.Array)
extern "C" void InternalEnumerator_1__ctor_m_214331081_0_gshared (InternalEnumerator_1_t_29285275_0 * __this, Array_t * ___array, const MethodInfo* method)
{
{
Array_t * L_0 = ___array;
__this->___array_0 = L_0;
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.Emit.ILGenerator/LabelFixup>::System.Collections.IEnumerator.Reset()
extern "C" void InternalEnumerator_1_System_Collections_IEnumerator_Reset_m_2103045367_0_gshared (InternalEnumerator_1_t_29285275_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Object System.Array/InternalEnumerator`1<System.Reflection.Emit.ILGenerator/LabelFixup>::System.Collections.IEnumerator.get_Current()
extern "C" Object_t * InternalEnumerator_1_System_Collections_IEnumerator_get_Current_m1633943551_0_gshared (InternalEnumerator_1_t_29285275_0 * __this, const MethodInfo* method)
{
{
LabelFixup_t1310356942_0 L_0 = (( LabelFixup_t1310356942_0 (*) (InternalEnumerator_1_t_29285275_0 *, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0)->method)((InternalEnumerator_1_t_29285275_0 *)__this, /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 0));
LabelFixup_t1310356942_0 L_1 = L_0;
Object_t * L_2 = Box(IL2CPP_RGCTX_DATA(InitializedTypeInfo(method->declaring_type)->rgctx_data, 1), &L_1);
return L_2;
}
}
// System.Void System.Array/InternalEnumerator`1<System.Reflection.Emit.ILGenerator/LabelFixup>::Dispose()
extern "C" void InternalEnumerator_1_Dispose_m_2125863986_0_gshared (InternalEnumerator_1_t_29285275_0 * __this, const MethodInfo* method)
{
{
__this->___idx_1 = ((int32_t)-2);
return;
}
}
// System.Boolean System.Array/InternalEnumerator`1<System.Reflection.Emit.ILGenerator/LabelFixup>::MoveNext()
extern "C" bool InternalEnumerator_1_MoveNext_m1336166329_0_gshared (InternalEnumerator_1_t_29285275_0 * __this, const MethodInfo* method)
{
int32_t V_0 = 0;
int32_t G_B5_0 = 0;
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_001e;
}
}
{
Array_t * L_1 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_1);
int32_t L_2 = Array_get_Length_m1203127607_0((Array_t *)L_1, /*hidden argument*/NULL);
__this->___idx_1 = L_2;
}
IL_001e:
{
int32_t L_3 = (int32_t)(__this->___idx_1);
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_0043;
}
}
{
int32_t L_4 = (int32_t)(__this->___idx_1);
int32_t L_5 = (int32_t)((int32_t)((int32_t)L_4-(int32_t)1));
V_0 = (int32_t)L_5;
__this->___idx_1 = L_5;
int32_t L_6 = V_0;
G_B5_0 = ((((int32_t)((((int32_t)L_6) == ((int32_t)(-1)))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0044;
}
IL_0043:
{
G_B5_0 = 0;
}
IL_0044:
{
return (bool)G_B5_0;
}
}
// T System.Array/InternalEnumerator`1<System.Reflection.Emit.ILGenerator/LabelFixup>::get_Current()
extern TypeInfo* InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var;
extern Il2CppCodeGenString* _stringLiteral_673706721_0;
extern Il2CppCodeGenString* _stringLiteral_2097638381_0;
extern "C" LabelFixup_t1310356942_0 InternalEnumerator_1_get_Current_m_723682976_0_gshared (InternalEnumerator_1_t_29285275_0 * __this, const MethodInfo* method)
{
static bool s_Il2CppMethodIntialized;
if (!s_Il2CppMethodIntialized)
{
InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var = il2cpp_codegen_type_info_from_index(71);
_stringLiteral_673706721_0 = il2cpp_codegen_string_literal_from_index(193);
_stringLiteral_2097638381_0 = il2cpp_codegen_string_literal_from_index(194);
s_Il2CppMethodIntialized = true;
}
{
int32_t L_0 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_0) == ((uint32_t)((int32_t)-2)))))
{
goto IL_0018;
}
}
{
InvalidOperationException_t_523179548_0 * L_1 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_1, (String_t*)_stringLiteral_673706721_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_1);
}
IL_0018:
{
int32_t L_2 = (int32_t)(__this->___idx_1);
if ((!(((uint32_t)L_2) == ((uint32_t)(-1)))))
{
goto IL_002f;
}
}
{
InvalidOperationException_t_523179548_0 * L_3 = (InvalidOperationException_t_523179548_0 *)il2cpp_codegen_object_new (InvalidOperationException_t_523179548_0_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m1485483280_0(L_3, (String_t*)_stringLiteral_2097638381_0, /*hidden argument*/NULL);
il2cpp_codegen_raise_exception((Il2CppCodeGenException*)L_3);
}
IL_002f:
{
Array_t * L_4 = (Array_t *)(__this->___array_0);
Array_t * L_5 = (Array_t *)(__this->___array_0);
NullCheck((Array_t *)L_5);
int32_t L_6 = Array_get_Length_m1203127607_0((Array_t *)L_5, /*hidden argument*/NULL);
int32_t L_7 = (int32_t)(__this->___idx_1);
NullCheck((Array_t *)L_4);
LabelFixup_t1310356942_0 L_8 = (( LabelFixup_t1310356942_0 (*) (Array_t *, int32_t, const MethodInfo*))IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2)->method)((Array_t *)L_4, (int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_6-(int32_t)1))-(int32_t)L_7)), /*hidden argument*/IL2CPP_RGCTX_METHOD_INFO(InitializedTypeInfo(method->declaring_type)->rgctx_data, 2));
return L_8;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"amberm@mit.edu"
] | amberm@mit.edu |
e9beff6cc7a6364ec0192b5e0c0633cb82870cfe | 7b9796ed8ac2d1811d4b7b1867a9e47e1324d1b4 | /hybris/egl/platforms/hwcomposer/hwcomposer_window.h | f5208bdb52daf965a8c9bd88e5a7a6bcbcd58b00 | [
"Apache-2.0"
] | permissive | vamanea/hybris | 8a4d187a06470ff5c7c291183bfd231e91bce770 | 1868a00ba62026626b863665f0ded068f7ff0b71 | refs/heads/master | 2021-01-22T07:11:14.034851 | 2013-11-16T05:25:10 | 2013-11-16T05:25:10 | 14,051,362 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,870 | h | /*
* Copyright (C) 2013 libhybris
*
* 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 FBDEV_WINDOW_H
#define FBDEV_WINDOW_H
#include "nativewindowbase.h"
#include <linux/fb.h>
#include <android/hardware/gralloc.h>
#include <list>
class HWComposerNativeWindowBuffer : public BaseNativeWindowBuffer {
friend class HWComposerNativeWindow;
protected:
HWComposerNativeWindowBuffer(unsigned int width,
unsigned int height,
unsigned int format,
unsigned int usage) ;
virtual ~HWComposerNativeWindowBuffer() ;
protected:
int busy;
int fenceFd;
};
class HWComposerNativeWindow : public BaseNativeWindow {
public:
HWComposerNativeWindow(unsigned int width, unsigned int height, unsigned int format);
~HWComposerNativeWindow();
void setup(gralloc_module_t* gralloc, alloc_device_t* alloc);
void lockFrontBuffer(HWComposerNativeWindowBuffer **buffer);
void unlockFrontBuffer(HWComposerNativeWindowBuffer *buffer);
protected:
// overloads from BaseNativeWindow
virtual int setSwapInterval(int interval);
virtual int dequeueBuffer(BaseNativeWindowBuffer** buffer, int* fenceFd);
virtual int queueBuffer(BaseNativeWindowBuffer* buffer, int fenceFd);
virtual int cancelBuffer(BaseNativeWindowBuffer* buffer, int fenceFd);
virtual int lockBuffer(BaseNativeWindowBuffer* buffer);
virtual unsigned int type() const;
virtual unsigned int width() const;
virtual unsigned int height() const;
virtual unsigned int format() const;
virtual unsigned int defaultWidth() const;
virtual unsigned int defaultHeight() const;
virtual unsigned int queueLength() const;
virtual unsigned int transformHint() const;
// perform calls
virtual int setUsage(int usage);
virtual int setBuffersFormat(int format);
virtual int setBuffersDimensions(int width, int height);
virtual int setBufferCount(int cnt);
private:
void destroyBuffers();
private:
framebuffer_device_t* m_fbDev;
alloc_device_t* m_alloc;
unsigned int m_usage;
unsigned int m_bufFormat;
int m_freeBufs;
std::list<HWComposerNativeWindowBuffer*> m_bufList;
HWComposerNativeWindowBuffer* m_frontBuf;
int m_width;
int m_height;
};
#endif
// vim: noai:ts=4:sw=4:ss=4:expandtab
| [
"carsten.munk@jollamobile.com"
] | carsten.munk@jollamobile.com |
9c1f094341f2e9ea3d0b40064df4a0859eeebe61 | e9854cb02e90dab7ec0a49c65f658babba819d56 | /Curve Editor Framework/QT/src/corelib/statemachine/qabstractstate.cpp | ca183be84e30a456b5b0b035f4b8b1c50b76aff1 | [] | no_license | katzeforest/Computer-Animation | 2bbb1df374d65240ca2209b3a75a0b6a8b99ad58 | 01481111a622ae8812fb0b76550f5d66de206bab | refs/heads/master | 2021-01-23T19:46:13.455834 | 2015-06-08T21:29:02 | 2015-06-08T21:29:02 | 37,092,780 | 1 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 5,894 | cpp | /****************************************************************************
**
** Copyright (C) 2011 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation (qt-info@nokia.com)
**
** This file is part of the QtCore module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:LGPL$
** Commercial Usage
** Licensees holding valid Qt Commercial licenses may use this file in
** accordance with the Qt Commercial License Agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and Nokia.
**
** GNU Lesser General Public License Usage
** Alternatively, this file may be used under the terms of the GNU Lesser
** General Public License version 2.1 as published by the Free Software
** Foundation and appearing in the file LICENSE.LGPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU Lesser General Public License version 2.1 requirements
** will be met: http://www.gnu.org/licenses/old-licenses/lgpl-2.1.html.
**
** In addition, as a special exception, Nokia gives you certain additional
** rights. These rights are described in the Nokia Qt LGPL Exception
** version 1.1, included in the file LGPL_EXCEPTION.txt in this package.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3.0 as published by the Free Software
** Foundation and appearing in the file LICENSE.GPL included in the
** packaging of this file. Please review the following information to
** ensure the GNU General Public License version 3.0 requirements will be
** met: http://www.gnu.org/copyleft/gpl.html.
**
** If you have questions regarding the use of this file, please contact
** Nokia at qt-info@nokia.com.
** $QT_END_LICENSE$
**
****************************************************************************/
#include "qabstractstate.h"
#ifndef QT_NO_STATEMACHINE
#include "qabstractstate_p.h"
#include "qstate.h"
#include "qstate_p.h"
#include "qstatemachine.h"
#include "qstatemachine_p.h"
QT_BEGIN_NAMESPACE
/*!
\class QAbstractState
\brief The QAbstractState class is the base class of states of a QStateMachine.
\since 4.6
\ingroup statemachine
The QAbstractState class is the abstract base class of states that are part
of a QStateMachine. It defines the interface that all state objects have in
common. QAbstractState is part of \l{The State Machine Framework}.
The entered() signal is emitted when the state has been entered. The
exited() signal is emitted when the state has been exited.
The parentState() function returns the state's parent state. The machine()
function returns the state machine that the state is part of.
\section1 Subclassing
The onEntry() function is called when the state is entered; reimplement this
function to perform custom processing when the state is entered.
The onExit() function is called when the state is exited; reimplement this
function to perform custom processing when the state is exited.
*/
QAbstractStatePrivate::QAbstractStatePrivate(StateType type)
: stateType(type), isMachine(false), parentState(0)
{
}
QAbstractStatePrivate *QAbstractStatePrivate::get(QAbstractState *q)
{
return q->d_func();
}
const QAbstractStatePrivate *QAbstractStatePrivate::get(const QAbstractState *q)
{
return q->d_func();
}
QStateMachine *QAbstractStatePrivate::machine() const
{
QObject *par = parent;
while (par != 0) {
if (QStateMachine *mach = qobject_cast<QStateMachine*>(par))
return mach;
par = par->parent();
}
return 0;
}
void QAbstractStatePrivate::callOnEntry(QEvent *e)
{
Q_Q(QAbstractState);
q->onEntry(e);
}
void QAbstractStatePrivate::callOnExit(QEvent *e)
{
Q_Q(QAbstractState);
q->onExit(e);
}
void QAbstractStatePrivate::emitEntered()
{
Q_Q(QAbstractState);
emit q->entered();
}
void QAbstractStatePrivate::emitExited()
{
Q_Q(QAbstractState);
emit q->exited();
}
/*!
Constructs a new state with the given \a parent state.
*/
QAbstractState::QAbstractState(QState *parent)
: QObject(*new QAbstractStatePrivate(QAbstractStatePrivate::AbstractState), parent)
{
}
/*!
\internal
*/
QAbstractState::QAbstractState(QAbstractStatePrivate &dd, QState *parent)
: QObject(dd, parent)
{
}
/*!
Destroys this state.
*/
QAbstractState::~QAbstractState()
{
}
/*!
Returns this state's parent state, or 0 if the state has no parent state.
*/
QState *QAbstractState::parentState() const
{
Q_D(const QAbstractState);
if (d->parentState != parent())
d->parentState = qobject_cast<QState*>(parent());
return d->parentState;
}
/*!
Returns the state machine that this state is part of, or 0 if the state is
not part of a state machine.
*/
QStateMachine *QAbstractState::machine() const
{
Q_D(const QAbstractState);
return d->machine();
}
/*!
\fn QAbstractState::onExit(QEvent *event)
This function is called when the state is exited. The given \a event is what
caused the state to be exited. Reimplement this function to perform custom
processing when the state is exited.
*/
/*!
\fn QAbstractState::onEntry(QEvent *event)
This function is called when the state is entered. The given \a event is
what caused the state to be entered. Reimplement this function to perform
custom processing when the state is entered.
*/
/*!
\fn QAbstractState::entered()
This signal is emitted when the state has been entered (after onEntry() has
been called).
*/
/*!
\fn QAbstractState::exited()
This signal is emitted when the state has been exited (after onExit() has
been called).
*/
/*!
\reimp
*/
bool QAbstractState::event(QEvent *e)
{
return QObject::event(e);
}
QT_END_NAMESPACE
#endif //QT_NO_STATEMACHINE
| [
"sonyang@seas.upenn.edu"
] | sonyang@seas.upenn.edu |
ef55b3f5e8998b16449fb675db6e3cad561bfd69 | d238efe4b1f1999e8ef254201ddabc99dcd4fded | /c++/rio_lib/src/rio_lib/data.cc | dfb570b37aea65f69c9dd1e29bae62328a860bf3 | [
"MIT"
] | permissive | WaldJohannaU/3RScan | fccd2c342c0a7e86a4f38eaf2567e03b8d07c616 | 12f040d3dc849e394ed366acd7b54e63acb49205 | refs/heads/master | 2022-06-21T20:19:39.439416 | 2022-05-06T20:23:21 | 2022-05-06T20:23:21 | 211,139,161 | 132 | 16 | MIT | 2022-05-25T22:43:34 | 2019-09-26T16:55:23 | C++ | UTF-8 | C++ | false | false | 3,308 | cc | // dataset loader
#include <fstream>
#include <iostream>
#include "rio_lib/data.h"
Data::Data(const std::string& data_file) {
std::cout << "loading " << data_file << std::endl;
ReadJson(data_file);
}
void Data::ReadJson(const std::string& data_file) {
// Read json file and save its output.
std::ifstream is(data_file);
std::string dataset((std::istreambuf_iterator<char>(is)), std::istreambuf_iterator<char>());
std::string err;
const auto json = json11::Json::parse(dataset, err);
if (err != "") {
std::cerr << "Error reading " << data_file << " " << err << std::endl;
return;
}
for (auto &s: json.array_items()) {
const auto scans = s["scans"].array_items();
const std::string& reference_id = s["reference"].string_value();
const std::string& type = s["type"].string_value();
for (auto &scan: scans) {
const std::string& scan_id = scan["reference"].string_value();
scan2references[scan_id] = reference_id;
if (type != "test")
ReadRescanJson(scan_id, reference_id, scan);
}
}
}
void Data::ReadMatrix(Eigen::Matrix4f& matrix, const json11::Json& json_matrix) {
matrix = Eigen::Matrix4f::Identity();
int i = 0;
for (auto& elem: json_matrix.array_items())
matrix(i++) = elem.number_value();
}
void Data::ReadRescanJson(const std::string& scan_id,
const std::string& reference_id,
const json11::Json& json_object) {
// Read Rescan scan data.
ReScan rescan;
rescan.reference_id = reference_id;
ReadMatrix(rescan.rescan2reference, json_object["transform"]);
for (const auto& rigid: json_object["rigid"].array_items()) {
const int instance_id = rigid["instance_reference"].number_value();
Eigen::Matrix4f rigid_transform;
ReadMatrix(rigid_transform, rigid["transform"]);
// The transformation in the json is actually from reference to rescan
// so we need to take the inverse.
rescan.rigid_transforms[instance_id] = rigid_transform.inverse();
}
rescans[scan_id] = rescan;
}
const std::string Data::GetReference(const std::string& scan_id) const {
if (IsRescan(scan_id))
return scan2references.at(scan_id);
else
return "";
}
const bool Data::IsRescan(const std::string& scan_id) const {
return (scan2references.find(scan_id) != scan2references.end());
}
const bool Data::IsReference(const std::string& scan_id) const {
return !IsRescan(scan_id);
}
const Eigen::Matrix4f Data::GetRescanTransform(const std::string& scan_id) const {
if (rescans.find(scan_id) != rescans.end())
return rescans.at(scan_id).rescan2reference;
else
return Eigen::Matrix4f::Identity();
}
const Eigen::Matrix4f Data::GetRigidTransform(const std::string& scan_id, const int& instance) const {
if (rescans.find(scan_id) != rescans.end()) {
const MapIntMatrix4fAligned& rigids = rescans.at(scan_id).rigid_transforms;
if (rigids.find(instance) != rigids.end())
return rigids.at(instance);
}
return Eigen::Matrix4f::Identity();
}
const std::map<std::string, std::string>& Data::GetScan2References() const {
return scan2references;
}
| [
"johanna.wald@tum.de"
] | johanna.wald@tum.de |
97ca755c1c27a8393c66eef620b0da04d7486990 | 9ffca60e69fafff0c58aaf0be69250e7b5704200 | /LightOJ/1200-1299/1255.cpp | 965b09eb26b7eb50ec2f359f7cc2790dc8321eb2 | [] | no_license | rizky-bagus/Tsunemori-Akane | 344a4e0cbc4d144f236da7643454587408ad9783 | 28e5b9cac2b17f0ab90d41637618091affadef21 | refs/heads/master | 2020-07-12T00:40:51.942999 | 2017-01-31T19:37:55 | 2017-01-31T19:37:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 715 | cpp | #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <algorithm>
using namespace std;
const int maxn = 1000005;
char s[maxn], t[maxn];
int f[maxn];
int KMP() {
int n = strlen(s), m = strlen(t), ans = 0;
f[0] = -1;
for (int i = 1, j = -1; i < m; ++i) {
while (j >= 0 && t[i] != t[j + 1]) j = f[j];
if (t[j + 1] == t[i]) j++;
f[i] = j;
}
for (int i = 0, j = -1; i < n; ++i) {
while (j >= 0 && s[i] != t[j + 1]) j = f[j];
if (s[i] == t[j + 1]) j++;
if (j == m - 1) {
ans ++;
j = f[j];
}
}
return ans;
}
int main() {
freopen("in", "r", stdin);
int T; scanf("%d", &T);
for (int _ = 1; _ <= T; ++_) {
scanf("%s%s", s, t);
printf("Case %d: %d\n", _, KMP());
}
return 0;
}
| [
"shimi@hackerrank.com"
] | shimi@hackerrank.com |
24ea9649ddda63e2339d969cc5539cbe8fc59106 | 408f0fceec97ed5ec45b475a16001200925e74e4 | /SimpleShooting/Main.cpp | 91966527d90aa07458fb9f90f59794b6048eb630 | [] | no_license | a1502020/hello-siv3d | 69c47adb4f487b2c028335d2836bee52c4623b91 | 1f99318a55a9ada59375f5437448b5efeb28edee | refs/heads/master | 2021-01-20T18:23:43.841658 | 2016-06-24T00:09:44 | 2016-06-24T00:09:44 | 61,181,954 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,481 | cpp | ๏ปฟ
# include <Siv3D.hpp>
#include "OwnChar.h"
#include "EnemyChar.h"
#include "Shot.h"
#include <list>
using namespace std;
void Main()
{
// ่ชๆฉ { ๅๆไฝ็ฝฎ, ๅๅพ, ่ฒ, ้ๅบฆ }
OwnChar me = { { 320, 400 }, 20,{ 255, 0, 0, 255 }, 6 };
// ่ชๆฉใฎๅผพ
list<Shot> ownShots;
// ่ชๆฉใฎๅผพใฎ็บๅฐ้้
const int32 shotInterval = 10;
int32 shotIntervalCnt = 0;
// ๆต { ๅๆไฝ็ฝฎ, ๅๅพ, ่ฒ, ๅใ, ้ๅบฆ }
list<EnemyChar> enemies;
// ใฒใผใ ็ตไบใใฉใฐ
bool finished = false;
while (System::Update() && !finished)
{
// ่ชๆฉ็งปๅ
if (Input::KeyRight.pressed) me.moveRight();
if (Input::KeyUp.pressed) me.moveUp();
if (Input::KeyLeft.pressed) me.moveLeft();
if (Input::KeyDown.pressed) me.moveDown();
// ่ชๆฉใฎๅผพ็บๅฐ
if (shotIntervalCnt > 0) --shotIntervalCnt;
if (shotIntervalCnt == 0 && (Input::KeyZ | Input::KeySpace).pressed) {
ownShots.push_back({ me.p, 8, {255, 128, 0, 192}, Pi * 1.5, 8 });
shotIntervalCnt = shotInterval;
}
// ่ชๆฉใฎๅผพ็งปๅ
for (Shot &s : ownShots) {
s.update();
}
// ็ป้ขๅคใฎๅผพใๅ้ค
ownShots.remove_if([&](const Shot &s) {
return !Window::ClientRect().intersects(Circle(s.p, s.r));
});
// ๆต็งปๅ
for (EnemyChar &e : enemies)
{
e.update();
}
// ็ป้ขๅคใฎๆตใๅ้ค
enemies.remove_if([&](const EnemyChar &e) {
return !Window::ClientRect().intersects(Circle(e.p, e.r));
});
// ๆตใจ่ชๆฉใฎๅฝใใๅคๅฎ
for (EnemyChar &e : enemies) {
if (e.collides(Circle(me.p, me.r))) {
finished = true;
}
}
// ๆตใจ่ชๆฉใฎๅผพใฎๅฝใใๅคๅฎ
for (auto ite = enemies.begin(); ite != enemies.end();) {
auto its = ownShots.begin();
while (its != ownShots.end() && !(*ite).collides(Circle((*its).p, (*its).r))) ++its;
if (its != ownShots.end()) {
ite = enemies.erase(ite);
ownShots.erase(its);
}
else {
++ite;
}
}
// ๆตๅบ็พ
if (RandomBool(1.0 / 40)) {
int32 r = Random(15, 30);
Point p = RandomPoint({ r, r, Window::Width() - 2 * r, 1 });
Color col = { 255, 0, 255, 255 };
double angle = Random(Pi * 0.25, Pi * 0.75);
int32 v = Random(2, 5);
enemies.push_back({ p, r, col, angle, v });
}
// ๆ็ป
Circle(me.p, me.r).draw(me.col);
for (EnemyChar &e : enemies)
{
e.draw();
}
for (Shot &s : ownShots) {
s.draw();
}
}
}
| [
"a1502020@sendai-nct.jp"
] | a1502020@sendai-nct.jp |
ee1ae7d7d43d6a5d4d92a796d4ae3648105a9a5b | 29be7c52e05d32a4b02e6c0a1a6424abb2f60d57 | /fuse-qreader/Example/build/Android/Debug/app/src/main/include/Fuse.Gestures.SwipedHow.h | 14b032c2df5d54abfb941d583220a86af6dbbf4e | [
"MIT"
] | permissive | redtree0/CITOS-APP | 3b8cbc86fd88f6adb5b480035788eac08290c7a6 | 624f69770d8573dffc174f1f9540c22f19c71f14 | refs/heads/master | 2020-03-29T05:42:49.041569 | 2018-09-25T14:24:55 | 2018-09-25T14:24:55 | 149,594,359 | 0 | 0 | null | 2018-09-20T10:47:57 | 2018-09-20T10:47:57 | null | UTF-8 | C++ | false | false | 374 | h | // This file was generated based on C:/Users/์ฑ์ฌ์ค์ตํฉITํ๋ถ/AppData/Local/Fusetools/Packages/Fuse.Gestures/1.9.0/Swipe.uno.
// WARNING: Changes might be lost if you edit this file directly.
#pragma once
#include <Uno.Int.h>
namespace g{
namespace Fuse{
namespace Gestures{
// public enum SwipedHow :521
uEnumType* SwipedHow_typeof();
}}} // ::g::Fuse::Gestures
| [
"moter74@naver.com"
] | moter74@naver.com |
811b9476d8fe73225b61bcc0cb0609d5c5a57e0e | c2d270aff0a4d939f43b6359ac2c564b2565be76 | /src/net/socket/socket_test_util.cc | 363efd7e41bc9207e27ab26eed624dd5e6f6ddf8 | [
"BSD-3-Clause"
] | permissive | bopopescu/QuicDep | dfa5c2b6aa29eb6f52b12486ff7f3757c808808d | bc86b705a6cf02d2eade4f3ea8cf5fe73ef52aa0 | refs/heads/master | 2022-04-26T04:36:55.675836 | 2020-04-29T21:29:26 | 2020-04-29T21:29:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 62,072 | cc | // Copyright (c) 2012 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 "net/socket/socket_test_util.h"
#include <inttypes.h> // For SCNx64
#include <stdint.h>
#include <stdio.h>
#include <algorithm>
#include <string>
#include <utility>
#include <vector>
#include "base/bind.h"
#include "base/bind_helpers.h"
#include "base/callback_helpers.h"
#include "base/compiler_specific.h"
#include "base/files/file_util.h"
#include "base/location.h"
#include "base/logging.h"
#include "base/run_loop.h"
#include "base/single_thread_task_runner.h"
#include "base/threading/thread_task_runner_handle.h"
#include "base/time/time.h"
#include "net/base/address_family.h"
#include "net/base/address_list.h"
#include "net/base/auth.h"
#include "net/base/hex_utils.h"
#include "net/base/ip_address.h"
#include "net/base/load_timing_info.h"
#include "net/http/http_network_session.h"
#include "net/http/http_request_headers.h"
#include "net/http/http_response_headers.h"
#include "net/log/net_log_source.h"
#include "net/log/net_log_source_type.h"
#include "net/socket/socket.h"
#include "net/socket/websocket_endpoint_lock_manager.h"
#include "net/ssl/ssl_cert_request_info.h"
#include "net/ssl/ssl_connection_status_flags.h"
#include "net/ssl/ssl_info.h"
#include "net/traffic_annotation/network_traffic_annotation_test_helper.h"
#include "testing/gtest/include/gtest/gtest.h"
#define NET_TRACE(level, s) VLOG(level) << s << __FUNCTION__ << "() "
namespace net {
namespace {
inline char AsciifyHigh(char x) {
char nybble = static_cast<char>((x >> 4) & 0x0F);
return nybble + ((nybble < 0x0A) ? '0' : 'A' - 10);
}
inline char AsciifyLow(char x) {
char nybble = static_cast<char>((x >> 0) & 0x0F);
return nybble + ((nybble < 0x0A) ? '0' : 'A' - 10);
}
inline char Asciify(char x) {
if ((x < 0) || !isprint(x))
return '.';
return x;
}
void DumpData(const char* data, int data_len) {
if (logging::LOG_INFO < logging::GetMinLogLevel())
return;
DVLOG(1) << "Length: " << data_len;
const char* pfx = "Data: ";
if (!data || (data_len <= 0)) {
DVLOG(1) << pfx << "<None>";
} else {
int i;
for (i = 0; i <= (data_len - 4); i += 4) {
DVLOG(1) << pfx
<< AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0])
<< AsciifyHigh(data[i + 1]) << AsciifyLow(data[i + 1])
<< AsciifyHigh(data[i + 2]) << AsciifyLow(data[i + 2])
<< AsciifyHigh(data[i + 3]) << AsciifyLow(data[i + 3])
<< " '"
<< Asciify(data[i + 0])
<< Asciify(data[i + 1])
<< Asciify(data[i + 2])
<< Asciify(data[i + 3])
<< "'";
pfx = " ";
}
// Take care of any 'trailing' bytes, if data_len was not a multiple of 4.
switch (data_len - i) {
case 3:
DVLOG(1) << pfx
<< AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0])
<< AsciifyHigh(data[i + 1]) << AsciifyLow(data[i + 1])
<< AsciifyHigh(data[i + 2]) << AsciifyLow(data[i + 2])
<< " '"
<< Asciify(data[i + 0])
<< Asciify(data[i + 1])
<< Asciify(data[i + 2])
<< " '";
break;
case 2:
DVLOG(1) << pfx
<< AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0])
<< AsciifyHigh(data[i + 1]) << AsciifyLow(data[i + 1])
<< " '"
<< Asciify(data[i + 0])
<< Asciify(data[i + 1])
<< " '";
break;
case 1:
DVLOG(1) << pfx
<< AsciifyHigh(data[i + 0]) << AsciifyLow(data[i + 0])
<< " '"
<< Asciify(data[i + 0])
<< " '";
break;
}
}
}
template <MockReadWriteType type>
void DumpMockReadWrite(const MockReadWrite<type>& r) {
if (logging::LOG_INFO < logging::GetMinLogLevel())
return;
DVLOG(1) << "Async: " << (r.mode == ASYNC)
<< "\nResult: " << r.result;
DumpData(r.data, r.data_len);
const char* stop = (r.sequence_number & MockRead::STOPLOOP) ? " (STOP)" : "";
DVLOG(1) << "Stage: " << (r.sequence_number & ~MockRead::STOPLOOP) << stop;
}
} // namespace
MockConnect::MockConnect() : mode(ASYNC), result(OK) {
peer_addr = IPEndPoint(IPAddress(192, 0, 2, 33), 0);
}
MockConnect::MockConnect(IoMode io_mode, int r) : mode(io_mode), result(r) {
peer_addr = IPEndPoint(IPAddress(192, 0, 2, 33), 0);
}
MockConnect::MockConnect(IoMode io_mode, int r, IPEndPoint addr) :
mode(io_mode),
result(r),
peer_addr(addr) {
}
MockConnect::~MockConnect() = default;
void SocketDataProvider::OnEnableTCPFastOpenIfSupported() {}
bool SocketDataProvider::IsIdle() const {
return true;
}
void SocketDataProvider::Initialize(AsyncSocket* socket) {
CHECK(!socket_);
CHECK(socket);
socket_ = socket;
Reset();
}
void SocketDataProvider::DetachSocket() {
CHECK(socket_);
socket_ = nullptr;
}
SocketDataProvider::SocketDataProvider() : socket_(nullptr) {}
SocketDataProvider::~SocketDataProvider() {
if (socket_)
socket_->OnDataProviderDestroyed();
}
StaticSocketDataHelper::StaticSocketDataHelper(MockRead* reads,
size_t reads_count,
MockWrite* writes,
size_t writes_count)
: reads_(reads),
read_index_(0),
read_count_(reads_count),
writes_(writes),
write_index_(0),
write_count_(writes_count) {
}
StaticSocketDataHelper::~StaticSocketDataHelper() = default;
const MockRead& StaticSocketDataHelper::PeekRead() const {
CHECK(!AllReadDataConsumed());
return reads_[read_index_];
}
const MockWrite& StaticSocketDataHelper::PeekWrite() const {
CHECK(!AllWriteDataConsumed());
return writes_[write_index_];
}
const MockRead& StaticSocketDataHelper::AdvanceRead() {
CHECK(!AllReadDataConsumed());
return reads_[read_index_++];
}
const MockWrite& StaticSocketDataHelper::AdvanceWrite() {
CHECK(!AllWriteDataConsumed());
return writes_[write_index_++];
}
void StaticSocketDataHelper::Reset() {
read_index_ = 0;
write_index_ = 0;
}
bool StaticSocketDataHelper::VerifyWriteData(const std::string& data) {
CHECK(!AllWriteDataConsumed());
// Check that the actual data matches the expectations, skipping over any
// pause events.
const MockWrite& next_write = PeekRealWrite();
if (!next_write.data)
return true;
// Note: Partial writes are supported here. If the expected data
// is a match, but shorter than the write actually written, that is legal.
// Example:
// Application writes "foobarbaz" (9 bytes)
// Expected write was "foo" (3 bytes)
// This is a success, and the function returns true.
std::string expected_data(next_write.data, next_write.data_len);
std::string actual_data(data.substr(0, next_write.data_len));
EXPECT_GE(data.length(), expected_data.length());
EXPECT_TRUE(actual_data == expected_data)
<< "Actual write data:\n" << HexDump(actual_data)
<< "Expected write data:\n" << HexDump(expected_data);
return expected_data == actual_data;
}
const MockWrite& StaticSocketDataHelper::PeekRealWrite() const {
for (size_t i = write_index_; i < write_count_; i++) {
if (writes_[i].mode != ASYNC || writes_[i].result != ERR_IO_PENDING)
return writes_[i];
}
CHECK(false) << "No write data available.";
return writes_[0]; // Avoid warning about unreachable missing return.
}
StaticSocketDataProvider::StaticSocketDataProvider()
: StaticSocketDataProvider(nullptr, 0, nullptr, 0) {
}
StaticSocketDataProvider::StaticSocketDataProvider(MockRead* reads,
size_t reads_count,
MockWrite* writes,
size_t writes_count)
: helper_(reads, reads_count, writes, writes_count) {
}
StaticSocketDataProvider::~StaticSocketDataProvider() = default;
MockRead StaticSocketDataProvider::OnRead() {
CHECK(!helper_.AllReadDataConsumed());
return helper_.AdvanceRead();
}
MockWriteResult StaticSocketDataProvider::OnWrite(const std::string& data) {
if (helper_.write_count() == 0) {
// Not using mock writes; succeed synchronously.
return MockWriteResult(SYNCHRONOUS, data.length());
}
EXPECT_FALSE(helper_.AllWriteDataConsumed())
<< "No more mock data to match write:\n"
<< HexDump(data);
if (helper_.AllWriteDataConsumed()) {
return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
}
// Check that what we are writing matches the expectation.
// Then give the mocked return value.
if (!helper_.VerifyWriteData(data))
return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
const MockWrite& next_write = helper_.AdvanceWrite();
// In the case that the write was successful, return the number of bytes
// written. Otherwise return the error code.
int result =
next_write.result == OK ? next_write.data_len : next_write.result;
return MockWriteResult(next_write.mode, result);
}
bool StaticSocketDataProvider::AllReadDataConsumed() const {
return helper_.AllReadDataConsumed();
}
bool StaticSocketDataProvider::AllWriteDataConsumed() const {
return helper_.AllWriteDataConsumed();
}
void StaticSocketDataProvider::Reset() {
helper_.Reset();
}
SSLSocketDataProvider::SSLSocketDataProvider(IoMode mode, int result)
: connect(mode, result),
next_proto(kProtoUnknown),
cert_request_info(NULL),
channel_id_service(NULL) {
SSLConnectionStatusSetVersion(SSL_CONNECTION_VERSION_TLS1_2,
&ssl_info.connection_status);
// Set to TLS_ECDHE_ECDSA_WITH_CHACHA20_POLY1305
SSLConnectionStatusSetCipherSuite(0xcca9, &ssl_info.connection_status);
}
SSLSocketDataProvider::SSLSocketDataProvider(
const SSLSocketDataProvider& other) = default;
SSLSocketDataProvider::~SSLSocketDataProvider() = default;
SequencedSocketData::SequencedSocketData(MockRead* reads,
size_t reads_count,
MockWrite* writes,
size_t writes_count)
: helper_(reads, reads_count, writes, writes_count),
sequence_number_(0),
read_state_(IDLE),
write_state_(IDLE),
busy_before_sync_reads_(false),
is_using_tcp_fast_open_(false),
weak_factory_(this) {
// Check that reads and writes have a contiguous set of sequence numbers
// starting from 0 and working their way up, with no repeats and skipping
// no values.
size_t next_read = 0;
size_t next_write = 0;
int next_sequence_number = 0;
bool last_event_was_pause = false;
while (next_read < reads_count || next_write < writes_count) {
if (next_read < reads_count &&
reads[next_read].sequence_number == next_sequence_number) {
// Check if this is a pause.
if (reads[next_read].mode == ASYNC &&
reads[next_read].result == ERR_IO_PENDING) {
CHECK(!last_event_was_pause) << "Two pauses in a row are not allowed: "
<< next_sequence_number;
last_event_was_pause = true;
} else if (last_event_was_pause) {
CHECK_EQ(ASYNC, reads[next_read].mode)
<< "A sync event after a pause makes no sense: "
<< next_sequence_number;
CHECK_NE(ERR_IO_PENDING, reads[next_read].result)
<< "A pause event after a pause makes no sense: "
<< next_sequence_number;
last_event_was_pause = false;
}
++next_read;
++next_sequence_number;
continue;
}
if (next_write < writes_count &&
writes[next_write].sequence_number == next_sequence_number) {
// Check if this is a pause.
if (writes[next_write].mode == ASYNC &&
writes[next_write].result == ERR_IO_PENDING) {
CHECK(!last_event_was_pause) << "Two pauses in a row are not allowed: "
<< next_sequence_number;
last_event_was_pause = true;
} else if (last_event_was_pause) {
CHECK_EQ(ASYNC, writes[next_write].mode)
<< "A sync event after a pause makes no sense: "
<< next_sequence_number;
CHECK_NE(ERR_IO_PENDING, writes[next_write].result)
<< "A pause event after a pause makes no sense: "
<< next_sequence_number;
last_event_was_pause = false;
}
++next_write;
++next_sequence_number;
continue;
}
CHECK(false) << "Sequence number not found where expected: "
<< next_sequence_number;
return;
}
// Last event must not be a pause. For the final event to indicate the
// operation never completes, it should be SYNCHRONOUS and return
// ERR_IO_PENDING.
CHECK(!last_event_was_pause);
CHECK_EQ(next_read, reads_count);
CHECK_EQ(next_write, writes_count);
}
SequencedSocketData::SequencedSocketData(const MockConnect& connect,
MockRead* reads,
size_t reads_count,
MockWrite* writes,
size_t writes_count)
: SequencedSocketData(reads, reads_count, writes, writes_count) {
set_connect_data(connect);
}
MockRead SequencedSocketData::OnRead() {
CHECK_EQ(IDLE, read_state_);
CHECK(!helper_.AllReadDataConsumed());
NET_TRACE(1, " *** ") << "sequence_number: " << sequence_number_;
const MockRead& next_read = helper_.PeekRead();
NET_TRACE(1, " *** ") << "next_read: " << next_read.sequence_number;
CHECK_GE(next_read.sequence_number, sequence_number_);
if (next_read.sequence_number <= sequence_number_) {
if (next_read.mode == SYNCHRONOUS) {
NET_TRACE(1, " *** ") << "Returning synchronously";
DumpMockReadWrite(next_read);
helper_.AdvanceRead();
++sequence_number_;
MaybePostWriteCompleteTask();
return next_read;
}
// If the result is ERR_IO_PENDING, then pause.
if (next_read.result == ERR_IO_PENDING) {
NET_TRACE(1, " *** ") << "Pausing read at: " << sequence_number_;
read_state_ = PAUSED;
if (run_until_paused_run_loop_)
run_until_paused_run_loop_->Quit();
return MockRead(SYNCHRONOUS, ERR_IO_PENDING);
}
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&SequencedSocketData::OnReadComplete,
weak_factory_.GetWeakPtr()));
CHECK_NE(COMPLETING, write_state_);
read_state_ = COMPLETING;
} else if (next_read.mode == SYNCHRONOUS) {
ADD_FAILURE() << "Unable to perform synchronous IO while stopped";
return MockRead(SYNCHRONOUS, ERR_UNEXPECTED);
} else {
NET_TRACE(1, " *** ") << "Waiting for write to trigger read";
read_state_ = PENDING;
}
return MockRead(SYNCHRONOUS, ERR_IO_PENDING);
}
MockWriteResult SequencedSocketData::OnWrite(const std::string& data) {
CHECK_EQ(IDLE, write_state_);
CHECK(!helper_.AllWriteDataConsumed())
<< "\nNo more mock data to match write:\n"
<< HexDump(data);
NET_TRACE(1, " *** ") << "sequence_number: " << sequence_number_;
const MockWrite& next_write = helper_.PeekWrite();
NET_TRACE(1, " *** ") << "next_write: " << next_write.sequence_number;
CHECK_GE(next_write.sequence_number, sequence_number_);
if (!helper_.VerifyWriteData(data))
return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
if (next_write.sequence_number <= sequence_number_) {
if (next_write.mode == SYNCHRONOUS) {
helper_.AdvanceWrite();
++sequence_number_;
MaybePostReadCompleteTask();
// In the case that the write was successful, return the number of bytes
// written. Otherwise return the error code.
int rv =
next_write.result != OK ? next_write.result : next_write.data_len;
NET_TRACE(1, " *** ") << "Returning synchronously";
return MockWriteResult(SYNCHRONOUS, rv);
}
// If the result is ERR_IO_PENDING, then pause.
if (next_write.result == ERR_IO_PENDING) {
NET_TRACE(1, " *** ") << "Pausing write at: " << sequence_number_;
write_state_ = PAUSED;
if (run_until_paused_run_loop_)
run_until_paused_run_loop_->Quit();
return MockWriteResult(SYNCHRONOUS, ERR_IO_PENDING);
}
NET_TRACE(1, " *** ") << "Posting task to complete write";
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&SequencedSocketData::OnWriteComplete,
weak_factory_.GetWeakPtr()));
CHECK_NE(COMPLETING, read_state_);
write_state_ = COMPLETING;
} else if (next_write.mode == SYNCHRONOUS) {
ADD_FAILURE() << "Unable to perform synchronous IO while stopped";
return MockWriteResult(SYNCHRONOUS, ERR_UNEXPECTED);
} else {
NET_TRACE(1, " *** ") << "Waiting for read to trigger write";
write_state_ = PENDING;
}
return MockWriteResult(SYNCHRONOUS, ERR_IO_PENDING);
}
bool SequencedSocketData::AllReadDataConsumed() const {
return helper_.AllReadDataConsumed();
}
bool SequencedSocketData::AllWriteDataConsumed() const {
return helper_.AllWriteDataConsumed();
}
void SequencedSocketData::OnEnableTCPFastOpenIfSupported() {
is_using_tcp_fast_open_ = true;
}
bool SequencedSocketData::IsIdle() const {
// If |busy_before_sync_reads_| is not set, always considered idle. If
// no reads left, or the next operation is a write, also consider it idle.
if (!busy_before_sync_reads_ || helper_.AllReadDataConsumed() ||
helper_.PeekRead().sequence_number != sequence_number_) {
return true;
}
// If the next operation is synchronous read, treat the socket as not idle.
if (helper_.PeekRead().mode == SYNCHRONOUS)
return false;
return true;
}
bool SequencedSocketData::IsPaused() const {
// Both states should not be paused.
DCHECK(read_state_ != PAUSED || write_state_ != PAUSED);
return write_state_ == PAUSED || read_state_ == PAUSED;
}
void SequencedSocketData::Resume() {
if (!IsPaused()) {
ADD_FAILURE() << "Unable to Resume when not paused.";
return;
}
sequence_number_++;
if (read_state_ == PAUSED) {
read_state_ = PENDING;
helper_.AdvanceRead();
} else { // write_state_ == PAUSED
write_state_ = PENDING;
helper_.AdvanceWrite();
}
if (!helper_.AllWriteDataConsumed() &&
helper_.PeekWrite().sequence_number == sequence_number_) {
// The next event hasn't even started yet. Pausing isn't really needed in
// that case, but may as well support it.
if (write_state_ != PENDING)
return;
write_state_ = COMPLETING;
OnWriteComplete();
return;
}
CHECK(!helper_.AllReadDataConsumed());
// The next event hasn't even started yet. Pausing isn't really needed in
// that case, but may as well support it.
if (read_state_ != PENDING)
return;
read_state_ = COMPLETING;
OnReadComplete();
}
void SequencedSocketData::RunUntilPaused() {
CHECK(!run_until_paused_run_loop_);
if (IsPaused())
return;
run_until_paused_run_loop_.reset(new base::RunLoop());
run_until_paused_run_loop_->Run();
run_until_paused_run_loop_.reset();
DCHECK(IsPaused());
}
void SequencedSocketData::MaybePostReadCompleteTask() {
NET_TRACE(1, " ****** ") << " current: " << sequence_number_;
// Only trigger the next read to complete if there is already a read pending
// which should complete at the current sequence number.
if (read_state_ != PENDING ||
helper_.PeekRead().sequence_number != sequence_number_) {
return;
}
// If the result is ERR_IO_PENDING, then pause.
if (helper_.PeekRead().result == ERR_IO_PENDING) {
NET_TRACE(1, " *** ") << "Pausing read at: " << sequence_number_;
read_state_ = PAUSED;
if (run_until_paused_run_loop_)
run_until_paused_run_loop_->Quit();
return;
}
NET_TRACE(1, " ****** ") << "Posting task to complete read: "
<< sequence_number_;
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&SequencedSocketData::OnReadComplete,
weak_factory_.GetWeakPtr()));
CHECK_NE(COMPLETING, write_state_);
read_state_ = COMPLETING;
}
bool SequencedSocketData::IsUsingTCPFastOpen() const {
return is_using_tcp_fast_open_;
}
void SequencedSocketData::MaybePostWriteCompleteTask() {
NET_TRACE(1, " ****** ") << " current: " << sequence_number_;
// Only trigger the next write to complete if there is already a write pending
// which should complete at the current sequence number.
if (write_state_ != PENDING ||
helper_.PeekWrite().sequence_number != sequence_number_) {
return;
}
// If the result is ERR_IO_PENDING, then pause.
if (helper_.PeekWrite().result == ERR_IO_PENDING) {
NET_TRACE(1, " *** ") << "Pausing write at: " << sequence_number_;
write_state_ = PAUSED;
if (run_until_paused_run_loop_)
run_until_paused_run_loop_->Quit();
return;
}
NET_TRACE(1, " ****** ") << "Posting task to complete write: "
<< sequence_number_;
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&SequencedSocketData::OnWriteComplete,
weak_factory_.GetWeakPtr()));
CHECK_NE(COMPLETING, read_state_);
write_state_ = COMPLETING;
}
void SequencedSocketData::Reset() {
helper_.Reset();
sequence_number_ = 0;
read_state_ = IDLE;
write_state_ = IDLE;
is_using_tcp_fast_open_ = false;
weak_factory_.InvalidateWeakPtrs();
}
void SequencedSocketData::OnReadComplete() {
CHECK_EQ(COMPLETING, read_state_);
NET_TRACE(1, " *** ") << "Completing read for: " << sequence_number_;
MockRead data = helper_.AdvanceRead();
DCHECK_EQ(sequence_number_, data.sequence_number);
sequence_number_++;
read_state_ = IDLE;
// The result of this read completing might trigger the completion
// of a pending write. If so, post a task to complete the write later.
// Since the socket may call back into the SequencedSocketData
// from socket()->OnReadComplete(), trigger the write task to be posted
// before calling that.
MaybePostWriteCompleteTask();
if (!socket()) {
NET_TRACE(1, " *** ") << "No socket available to complete read";
return;
}
NET_TRACE(1, " *** ") << "Completing socket read for: "
<< data.sequence_number;
DumpMockReadWrite(data);
socket()->OnReadComplete(data);
NET_TRACE(1, " *** ") << "Done";
}
void SequencedSocketData::OnWriteComplete() {
CHECK_EQ(COMPLETING, write_state_);
NET_TRACE(1, " *** ") << " Completing write for: " << sequence_number_;
const MockWrite& data = helper_.AdvanceWrite();
DCHECK_EQ(sequence_number_, data.sequence_number);
sequence_number_++;
write_state_ = IDLE;
int rv = data.result == OK ? data.data_len : data.result;
// The result of this write completing might trigger the completion
// of a pending read. If so, post a task to complete the read later.
// Since the socket may call back into the SequencedSocketData
// from socket()->OnWriteComplete(), trigger the write task to be posted
// before calling that.
MaybePostReadCompleteTask();
if (!socket()) {
NET_TRACE(1, " *** ") << "No socket available to complete write";
return;
}
NET_TRACE(1, " *** ") << " Completing socket write for: "
<< data.sequence_number;
socket()->OnWriteComplete(rv);
NET_TRACE(1, " *** ") << "Done";
}
SequencedSocketData::~SequencedSocketData() = default;
MockClientSocketFactory::MockClientSocketFactory()
: enable_read_if_ready_(false) {}
MockClientSocketFactory::~MockClientSocketFactory() = default;
void MockClientSocketFactory::AddSocketDataProvider(
SocketDataProvider* data) {
mock_data_.Add(data);
}
void MockClientSocketFactory::AddSSLSocketDataProvider(
SSLSocketDataProvider* data) {
mock_ssl_data_.Add(data);
}
void MockClientSocketFactory::ResetNextMockIndexes() {
mock_data_.ResetNextIndex();
mock_ssl_data_.ResetNextIndex();
}
std::unique_ptr<DatagramClientSocket>
MockClientSocketFactory::CreateDatagramClientSocket(
DatagramSocket::BindType bind_type,
const RandIntCallback& rand_int_cb,
NetLog* net_log,
const NetLogSource& source) {
SocketDataProvider* data_provider = mock_data_.GetNext();
std::unique_ptr<MockUDPClientSocket> socket(
new MockUDPClientSocket(data_provider, net_log));
if (bind_type == DatagramSocket::RANDOM_BIND)
socket->set_source_port(
static_cast<uint16_t>(rand_int_cb.Run(1025, 65535)));
udp_client_socket_ports_.push_back(socket->source_port());
return std::move(socket);
}
std::unique_ptr<StreamSocket>
MockClientSocketFactory::CreateTransportClientSocket(
const AddressList& addresses,
std::unique_ptr<SocketPerformanceWatcher> socket_performance_watcher,
NetLog* net_log,
const NetLogSource& source) {
SocketDataProvider* data_provider = mock_data_.GetNext();
std::unique_ptr<MockTCPClientSocket> socket(
new MockTCPClientSocket(addresses, net_log, data_provider));
if (enable_read_if_ready_)
socket->set_enable_read_if_ready(enable_read_if_ready_);
return std::move(socket);
}
std::unique_ptr<SSLClientSocket> MockClientSocketFactory::CreateSSLClientSocket(
std::unique_ptr<ClientSocketHandle> transport_socket,
const HostPortPair& host_and_port,
const SSLConfig& ssl_config,
const SSLClientSocketContext& context) {
SSLSocketDataProvider* next_ssl_data = mock_ssl_data_.GetNext();
if (!next_ssl_data->next_protos_expected_in_ssl_config.empty()) {
EXPECT_EQ(next_ssl_data->next_protos_expected_in_ssl_config.size(),
ssl_config.alpn_protos.size());
EXPECT_TRUE(
std::equal(next_ssl_data->next_protos_expected_in_ssl_config.begin(),
next_ssl_data->next_protos_expected_in_ssl_config.end(),
ssl_config.alpn_protos.begin()));
}
return std::unique_ptr<SSLClientSocket>(new MockSSLClientSocket(
std::move(transport_socket), host_and_port, ssl_config, next_ssl_data));
}
void MockClientSocketFactory::ClearSSLSessionCache() {
}
MockClientSocket::MockClientSocket(const NetLogWithSource& net_log)
: connected_(false), net_log_(net_log), weak_factory_(this) {
peer_addr_ = IPEndPoint(IPAddress(192, 0, 2, 33), 0);
}
int MockClientSocket::SetReceiveBufferSize(int32_t size) {
return OK;
}
int MockClientSocket::SetSendBufferSize(int32_t size) {
return OK;
}
void MockClientSocket::Disconnect() {
connected_ = false;
}
bool MockClientSocket::IsConnected() const {
return connected_;
}
bool MockClientSocket::IsConnectedAndIdle() const {
return connected_;
}
int MockClientSocket::GetPeerAddress(IPEndPoint* address) const {
if (!IsConnected())
return ERR_SOCKET_NOT_CONNECTED;
*address = peer_addr_;
return OK;
}
int MockClientSocket::GetLocalAddress(IPEndPoint* address) const {
*address = IPEndPoint(IPAddress(192, 0, 2, 33), 123);
return OK;
}
const NetLogWithSource& MockClientSocket::NetLog() const {
return net_log_;
}
bool MockClientSocket::WasAlpnNegotiated() const {
return false;
}
NextProto MockClientSocket::GetNegotiatedProtocol() const {
return kProtoUnknown;
}
void MockClientSocket::GetConnectionAttempts(ConnectionAttempts* out) const {
out->clear();
}
int64_t MockClientSocket::GetTotalReceivedBytes() const {
NOTIMPLEMENTED();
return 0;
}
void MockClientSocket::GetSSLCertRequestInfo(
SSLCertRequestInfo* cert_request_info) {
}
int MockClientSocket::ExportKeyingMaterial(const base::StringPiece& label,
bool has_context,
const base::StringPiece& context,
unsigned char* out,
unsigned int outlen) {
memset(out, 'A', outlen);
return OK;
}
ChannelIDService* MockClientSocket::GetChannelIDService() const {
NOTREACHED();
return NULL;
}
Error MockClientSocket::GetTokenBindingSignature(crypto::ECPrivateKey* key,
TokenBindingType tb_type,
std::vector<uint8_t>* out) {
NOTREACHED();
return ERR_NOT_IMPLEMENTED;
}
crypto::ECPrivateKey* MockClientSocket::GetChannelIDKey() const {
NOTREACHED();
return NULL;
}
MockClientSocket::~MockClientSocket() = default;
void MockClientSocket::RunCallbackAsync(const CompletionCallback& callback,
int result) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&MockClientSocket::RunCallback,
weak_factory_.GetWeakPtr(), callback, result));
}
void MockClientSocket::RunCallback(const CompletionCallback& callback,
int result) {
if (!callback.is_null())
callback.Run(result);
}
MockTCPClientSocket::MockTCPClientSocket(const AddressList& addresses,
net::NetLog* net_log,
SocketDataProvider* data)
: MockClientSocket(NetLogWithSource::Make(net_log, NetLogSourceType::NONE)),
addresses_(addresses),
data_(data),
read_offset_(0),
read_data_(SYNCHRONOUS, ERR_UNEXPECTED),
need_read_data_(true),
peer_closed_connection_(false),
pending_read_buf_(NULL),
pending_read_buf_len_(0),
was_used_to_convey_data_(false),
enable_read_if_ready_(false) {
DCHECK(data_);
peer_addr_ = data->connect_data().peer_addr;
data_->Initialize(this);
}
MockTCPClientSocket::~MockTCPClientSocket() {
if (data_)
data_->DetachSocket();
}
int MockTCPClientSocket::Read(IOBuffer* buf, int buf_len,
const CompletionCallback& callback) {
// If the buffer is already in use, a read is already in progress!
DCHECK(!pending_read_buf_);
// Use base::Unretained() is safe because MockClientSocket::RunCallbackAsync()
// takes a weak ptr of the base class, MockClientSocket.
int rv = ReadIfReadyImpl(
buf, buf_len,
base::Bind(&MockTCPClientSocket::RetryRead, base::Unretained(this)));
if (rv == ERR_IO_PENDING) {
pending_read_buf_ = buf;
pending_read_buf_len_ = buf_len;
pending_read_callback_ = callback;
}
return rv;
}
int MockTCPClientSocket::ReadIfReady(IOBuffer* buf,
int buf_len,
const CompletionCallback& callback) {
DCHECK(!pending_read_if_ready_callback_);
if (!enable_read_if_ready_)
return ERR_READ_IF_READY_NOT_IMPLEMENTED;
return ReadIfReadyImpl(buf, buf_len, callback);
}
int MockTCPClientSocket::Write(
IOBuffer* buf,
int buf_len,
const CompletionCallback& callback,
const NetworkTrafficAnnotationTag& /* traffic_annotation */) {
DCHECK(buf);
DCHECK_GT(buf_len, 0);
if (!connected_ || !data_)
return ERR_UNEXPECTED;
std::string data(buf->data(), buf_len);
MockWriteResult write_result = data_->OnWrite(data);
was_used_to_convey_data_ = true;
// ERR_IO_PENDING is a signal that the socket data will call back
// asynchronously later.
if (write_result.result == ERR_IO_PENDING) {
pending_write_callback_ = callback;
return ERR_IO_PENDING;
}
if (write_result.mode == ASYNC) {
RunCallbackAsync(callback, write_result.result);
return ERR_IO_PENDING;
}
return write_result.result;
}
void MockTCPClientSocket::GetConnectionAttempts(ConnectionAttempts* out) const {
*out = connection_attempts_;
}
void MockTCPClientSocket::ClearConnectionAttempts() {
connection_attempts_.clear();
}
void MockTCPClientSocket::AddConnectionAttempts(
const ConnectionAttempts& attempts) {
connection_attempts_.insert(connection_attempts_.begin(), attempts.begin(),
attempts.end());
}
int MockTCPClientSocket::Connect(const CompletionCallback& callback) {
if (!data_)
return ERR_UNEXPECTED;
if (connected_)
return OK;
connected_ = true;
peer_closed_connection_ = false;
int result = data_->connect_data().result;
IoMode mode = data_->connect_data().mode;
if (result != OK && result != ERR_IO_PENDING) {
IPEndPoint address;
if (GetPeerAddress(&address) == OK)
connection_attempts_.push_back(ConnectionAttempt(address, result));
}
if (mode == SYNCHRONOUS)
return result;
if (result == ERR_IO_PENDING)
pending_connect_callback_ = callback;
else
RunCallbackAsync(callback, result);
return ERR_IO_PENDING;
}
void MockTCPClientSocket::Disconnect() {
MockClientSocket::Disconnect();
pending_connect_callback_.Reset();
pending_read_callback_.Reset();
}
bool MockTCPClientSocket::IsConnected() const {
if (!data_)
return false;
return connected_ && !peer_closed_connection_;
}
bool MockTCPClientSocket::IsConnectedAndIdle() const {
if (!data_)
return false;
return IsConnected() && data_->IsIdle();
}
int MockTCPClientSocket::GetPeerAddress(IPEndPoint* address) const {
if (addresses_.empty())
return MockClientSocket::GetPeerAddress(address);
*address = addresses_[0];
return OK;
}
bool MockTCPClientSocket::WasEverUsed() const {
return was_used_to_convey_data_;
}
void MockTCPClientSocket::EnableTCPFastOpenIfSupported() {
EXPECT_FALSE(IsConnected()) << "Can't enable fast open after connect.";
data_->OnEnableTCPFastOpenIfSupported();
}
bool MockTCPClientSocket::GetSSLInfo(SSLInfo* ssl_info) {
return false;
}
void MockTCPClientSocket::OnReadComplete(const MockRead& data) {
// If |data_| has been destroyed, safest to just do nothing.
if (!data_)
return;
// There must be a read pending.
DCHECK(pending_read_if_ready_callback_);
// You can't complete a read with another ERR_IO_PENDING status code.
DCHECK_NE(ERR_IO_PENDING, data.result);
// Since we've been waiting for data, need_read_data_ should be true.
DCHECK(need_read_data_);
read_data_ = data;
need_read_data_ = false;
// The caller is simulating that this IO completes right now. Don't
// let CompleteRead() schedule a callback.
read_data_.mode = SYNCHRONOUS;
RunCallback(base::ResetAndReturn(&pending_read_if_ready_callback_),
read_data_.result > 0 ? OK : read_data_.result);
}
void MockTCPClientSocket::OnWriteComplete(int rv) {
// If |data_| has been destroyed, safest to just do nothing.
if (!data_)
return;
// There must be a read pending.
DCHECK(!pending_write_callback_.is_null());
CompletionCallback callback = pending_write_callback_;
RunCallback(callback, rv);
}
void MockTCPClientSocket::OnConnectComplete(const MockConnect& data) {
// If |data_| has been destroyed, safest to just do nothing.
if (!data_)
return;
CompletionCallback callback = pending_connect_callback_;
RunCallback(callback, data.result);
}
void MockTCPClientSocket::OnDataProviderDestroyed() {
data_ = nullptr;
}
void MockTCPClientSocket::RetryRead(int rv) {
DCHECK(pending_read_callback_);
DCHECK(pending_read_buf_.get());
DCHECK_LT(0, pending_read_buf_len_);
if (rv == OK) {
rv = ReadIfReadyImpl(
pending_read_buf_.get(), pending_read_buf_len_,
base::Bind(&MockTCPClientSocket::RetryRead, base::Unretained(this)));
if (rv == ERR_IO_PENDING)
return;
}
pending_read_buf_ = nullptr;
pending_read_buf_len_ = 0;
RunCallback(base::ResetAndReturn(&pending_read_callback_), rv);
}
int MockTCPClientSocket::ReadIfReadyImpl(IOBuffer* buf,
int buf_len,
const CompletionCallback& callback) {
if (!connected_ || !data_)
return ERR_UNEXPECTED;
DCHECK(!pending_read_if_ready_callback_);
if (need_read_data_) {
read_data_ = data_->OnRead();
if (read_data_.result == ERR_CONNECTION_CLOSED) {
// This MockRead is just a marker to instruct us to set
// peer_closed_connection_.
peer_closed_connection_ = true;
}
if (read_data_.result == ERR_TEST_PEER_CLOSE_AFTER_NEXT_MOCK_READ) {
// This MockRead is just a marker to instruct us to set
// peer_closed_connection_. Skip it and get the next one.
read_data_ = data_->OnRead();
peer_closed_connection_ = true;
}
// ERR_IO_PENDING means that the SocketDataProvider is taking responsibility
// to complete the async IO manually later (via OnReadComplete).
if (read_data_.result == ERR_IO_PENDING) {
// We need to be using async IO in this case.
DCHECK(!callback.is_null());
pending_read_if_ready_callback_ = callback;
return ERR_IO_PENDING;
}
need_read_data_ = false;
}
int result = read_data_.result;
DCHECK_NE(ERR_IO_PENDING, result);
if (read_data_.mode == ASYNC) {
DCHECK(!callback.is_null());
read_data_.mode = SYNCHRONOUS;
RunCallbackAsync(callback, result);
return ERR_IO_PENDING;
}
was_used_to_convey_data_ = true;
if (read_data_.data) {
if (read_data_.data_len - read_offset_ > 0) {
result = std::min(buf_len, read_data_.data_len - read_offset_);
memcpy(buf->data(), read_data_.data + read_offset_, result);
read_offset_ += result;
if (read_offset_ == read_data_.data_len) {
need_read_data_ = true;
read_offset_ = 0;
}
} else {
result = 0; // EOF
}
}
return result;
}
// static
void MockSSLClientSocket::ConnectCallback(
MockSSLClientSocket* ssl_client_socket,
const CompletionCallback& callback,
int rv) {
if (rv == OK)
ssl_client_socket->connected_ = true;
callback.Run(rv);
}
MockSSLClientSocket::MockSSLClientSocket(
std::unique_ptr<ClientSocketHandle> transport_socket,
const HostPortPair& host_port_pair,
const SSLConfig& ssl_config,
SSLSocketDataProvider* data)
: MockClientSocket(
// Have to use the right NetLogWithSource for LoadTimingInfo
// regression
// tests.
transport_socket->socket()->NetLog()),
transport_(std::move(transport_socket)),
data_(data) {
DCHECK(data_);
peer_addr_ = data->connect.peer_addr;
}
MockSSLClientSocket::~MockSSLClientSocket() {
Disconnect();
}
int MockSSLClientSocket::Read(IOBuffer* buf, int buf_len,
const CompletionCallback& callback) {
return transport_->socket()->Read(buf, buf_len, callback);
}
int MockSSLClientSocket::ReadIfReady(IOBuffer* buf,
int buf_len,
const CompletionCallback& callback) {
return transport_->socket()->ReadIfReady(buf, buf_len, callback);
}
int MockSSLClientSocket::Write(
IOBuffer* buf,
int buf_len,
const CompletionCallback& callback,
const NetworkTrafficAnnotationTag& traffic_annotation) {
return transport_->socket()->Write(buf, buf_len, callback,
traffic_annotation);
}
int MockSSLClientSocket::Connect(const CompletionCallback& callback) {
int rv = transport_->socket()->Connect(
base::Bind(&ConnectCallback, base::Unretained(this), callback));
if (rv == OK) {
if (data_->connect.result == OK)
connected_ = true;
if (data_->connect.mode == ASYNC) {
RunCallbackAsync(callback, data_->connect.result);
return ERR_IO_PENDING;
}
return data_->connect.result;
}
return rv;
}
void MockSSLClientSocket::Disconnect() {
MockClientSocket::Disconnect();
if (transport_->socket() != NULL)
transport_->socket()->Disconnect();
}
bool MockSSLClientSocket::IsConnected() const {
return transport_->socket()->IsConnected();
}
bool MockSSLClientSocket::IsConnectedAndIdle() const {
return transport_->socket()->IsConnectedAndIdle();
}
bool MockSSLClientSocket::WasEverUsed() const {
return transport_->socket()->WasEverUsed();
}
int MockSSLClientSocket::GetPeerAddress(IPEndPoint* address) const {
return transport_->socket()->GetPeerAddress(address);
}
bool MockSSLClientSocket::WasAlpnNegotiated() const {
return data_->next_proto != kProtoUnknown;
}
NextProto MockSSLClientSocket::GetNegotiatedProtocol() const {
return data_->next_proto;
}
bool MockSSLClientSocket::GetSSLInfo(SSLInfo* requested_ssl_info) {
requested_ssl_info->Reset();
*requested_ssl_info = data_->ssl_info;
return true;
}
void MockSSLClientSocket::GetSSLCertRequestInfo(
SSLCertRequestInfo* cert_request_info) {
DCHECK(cert_request_info);
if (data_->cert_request_info) {
cert_request_info->host_and_port =
data_->cert_request_info->host_and_port;
cert_request_info->is_proxy = data_->cert_request_info->is_proxy;
cert_request_info->cert_authorities =
data_->cert_request_info->cert_authorities;
cert_request_info->cert_key_types =
data_->cert_request_info->cert_key_types;
} else {
cert_request_info->Reset();
}
}
ChannelIDService* MockSSLClientSocket::GetChannelIDService() const {
return data_->channel_id_service;
}
Error MockSSLClientSocket::GetTokenBindingSignature(crypto::ECPrivateKey* key,
TokenBindingType tb_type,
std::vector<uint8_t>* out) {
out->push_back('A');
return OK;
}
void MockSSLClientSocket::OnReadComplete(const MockRead& data) {
NOTIMPLEMENTED();
}
void MockSSLClientSocket::OnWriteComplete(int rv) {
NOTIMPLEMENTED();
}
void MockSSLClientSocket::OnConnectComplete(const MockConnect& data) {
NOTIMPLEMENTED();
}
MockUDPClientSocket::MockUDPClientSocket(SocketDataProvider* data,
net::NetLog* net_log)
: connected_(false),
data_(data),
read_offset_(0),
read_data_(SYNCHRONOUS, ERR_UNEXPECTED),
need_read_data_(true),
source_port_(123),
network_(NetworkChangeNotifier::kInvalidNetworkHandle),
pending_read_buf_(NULL),
pending_read_buf_len_(0),
net_log_(NetLogWithSource::Make(net_log, NetLogSourceType::NONE)),
weak_factory_(this) {
DCHECK(data_);
data_->Initialize(this);
peer_addr_ = data->connect_data().peer_addr;
}
MockUDPClientSocket::~MockUDPClientSocket() {
if (data_)
data_->DetachSocket();
}
int MockUDPClientSocket::Read(IOBuffer* buf,
int buf_len,
const CompletionCallback& callback) {
if (!connected_ || !data_)
return ERR_UNEXPECTED;
// If the buffer is already in use, a read is already in progress!
DCHECK(!pending_read_buf_);
// Store our async IO data.
pending_read_buf_ = buf;
pending_read_buf_len_ = buf_len;
pending_read_callback_ = callback;
if (need_read_data_) {
read_data_ = data_->OnRead();
// ERR_IO_PENDING means that the SocketDataProvider is taking responsibility
// to complete the async IO manually later (via OnReadComplete).
if (read_data_.result == ERR_IO_PENDING) {
// We need to be using async IO in this case.
DCHECK(!callback.is_null());
return ERR_IO_PENDING;
}
need_read_data_ = false;
}
return CompleteRead();
}
int MockUDPClientSocket::Write(
IOBuffer* buf,
int buf_len,
const CompletionCallback& callback,
const NetworkTrafficAnnotationTag& /* traffic_annotation */) {
DCHECK(buf);
DCHECK_GT(buf_len, 0);
if (!connected_ || !data_)
return ERR_UNEXPECTED;
std::string data(buf->data(), buf_len);
MockWriteResult write_result = data_->OnWrite(data);
// ERR_IO_PENDING is a signal that the socket data will call back
// asynchronously.
if (write_result.result == ERR_IO_PENDING) {
pending_write_callback_ = callback;
return ERR_IO_PENDING;
}
if (write_result.mode == ASYNC) {
RunCallbackAsync(callback, write_result.result);
return ERR_IO_PENDING;
}
return write_result.result;
}
int MockUDPClientSocket::SetReceiveBufferSize(int32_t size) {
return OK;
}
int MockUDPClientSocket::SetSendBufferSize(int32_t size) {
return OK;
}
int MockUDPClientSocket::SetDoNotFragment() {
return OK;
}
void MockUDPClientSocket::Close() {
connected_ = false;
}
int MockUDPClientSocket::GetPeerAddress(IPEndPoint* address) const {
*address = peer_addr_;
return OK;
}
int MockUDPClientSocket::GetLocalAddress(IPEndPoint* address) const {
*address = IPEndPoint(IPAddress(192, 0, 2, 33), source_port_);
return OK;
}
void MockUDPClientSocket::UseNonBlockingIO() {}
const NetLogWithSource& MockUDPClientSocket::NetLog() const {
return net_log_;
}
int MockUDPClientSocket::Connect(const IPEndPoint& address) {
if (!data_)
return ERR_UNEXPECTED;
connected_ = true;
peer_addr_ = address;
return data_->connect_data().result;
}
int MockUDPClientSocket::ConnectUsingNetwork(
NetworkChangeNotifier::NetworkHandle network,
const IPEndPoint& address) {
DCHECK(!connected_);
if (!data_)
return ERR_UNEXPECTED;
network_ = network;
connected_ = true;
peer_addr_ = address;
return data_->connect_data().result;
}
int MockUDPClientSocket::ConnectUsingDefaultNetwork(const IPEndPoint& address) {
DCHECK(!connected_);
if (!data_)
return ERR_UNEXPECTED;
network_ = kDefaultNetworkForTests;
connected_ = true;
peer_addr_ = address;
return data_->connect_data().result;
}
NetworkChangeNotifier::NetworkHandle MockUDPClientSocket::GetBoundNetwork()
const {
return network_;
}
void MockUDPClientSocket::ApplySocketTag(const SocketTag& tag) {}
void MockUDPClientSocket::OnReadComplete(const MockRead& data) {
if (!data_)
return;
// There must be a read pending.
DCHECK(pending_read_buf_.get());
// You can't complete a read with another ERR_IO_PENDING status code.
DCHECK_NE(ERR_IO_PENDING, data.result);
// Since we've been waiting for data, need_read_data_ should be true.
DCHECK(need_read_data_);
read_data_ = data;
need_read_data_ = false;
// The caller is simulating that this IO completes right now. Don't
// let CompleteRead() schedule a callback.
read_data_.mode = SYNCHRONOUS;
CompletionCallback callback = pending_read_callback_;
int rv = CompleteRead();
RunCallback(callback, rv);
}
void MockUDPClientSocket::OnWriteComplete(int rv) {
if (!data_)
return;
// There must be a read pending.
DCHECK(!pending_write_callback_.is_null());
CompletionCallback callback = pending_write_callback_;
RunCallback(callback, rv);
}
void MockUDPClientSocket::OnConnectComplete(const MockConnect& data) {
NOTIMPLEMENTED();
}
void MockUDPClientSocket::OnDataProviderDestroyed() {
data_ = nullptr;
}
int MockUDPClientSocket::CompleteRead() {
DCHECK(pending_read_buf_.get());
DCHECK(pending_read_buf_len_ > 0);
// Save the pending async IO data and reset our |pending_| state.
scoped_refptr<IOBuffer> buf = pending_read_buf_;
int buf_len = pending_read_buf_len_;
CompletionCallback callback = pending_read_callback_;
pending_read_buf_ = NULL;
pending_read_buf_len_ = 0;
pending_read_callback_.Reset();
int result = read_data_.result;
DCHECK(result != ERR_IO_PENDING);
if (read_data_.data) {
if (read_data_.data_len - read_offset_ > 0) {
result = std::min(buf_len, read_data_.data_len - read_offset_);
memcpy(buf->data(), read_data_.data + read_offset_, result);
read_offset_ += result;
if (read_offset_ == read_data_.data_len) {
need_read_data_ = true;
read_offset_ = 0;
}
} else {
result = 0; // EOF
}
}
if (read_data_.mode == ASYNC) {
DCHECK(!callback.is_null());
RunCallbackAsync(callback, result);
return ERR_IO_PENDING;
}
return result;
}
void MockUDPClientSocket::RunCallbackAsync(const CompletionCallback& callback,
int result) {
base::ThreadTaskRunnerHandle::Get()->PostTask(
FROM_HERE, base::Bind(&MockUDPClientSocket::RunCallback,
weak_factory_.GetWeakPtr(), callback, result));
}
void MockUDPClientSocket::RunCallback(const CompletionCallback& callback,
int result) {
if (!callback.is_null())
callback.Run(result);
}
TestSocketRequest::TestSocketRequest(
std::vector<TestSocketRequest*>* request_order, size_t* completion_count)
: request_order_(request_order),
completion_count_(completion_count),
callback_(base::Bind(&TestSocketRequest::OnComplete,
base::Unretained(this))) {
DCHECK(request_order);
DCHECK(completion_count);
}
TestSocketRequest::~TestSocketRequest() = default;
void TestSocketRequest::OnComplete(int result) {
SetResult(result);
(*completion_count_)++;
request_order_->push_back(this);
}
// static
const int ClientSocketPoolTest::kIndexOutOfBounds = -1;
// static
const int ClientSocketPoolTest::kRequestNotFound = -2;
ClientSocketPoolTest::ClientSocketPoolTest() : completion_count_(0) {}
ClientSocketPoolTest::~ClientSocketPoolTest() = default;
int ClientSocketPoolTest::GetOrderOfRequest(size_t index) const {
index--;
if (index >= requests_.size())
return kIndexOutOfBounds;
for (size_t i = 0; i < request_order_.size(); i++)
if (requests_[index].get() == request_order_[i])
return i + 1;
return kRequestNotFound;
}
bool ClientSocketPoolTest::ReleaseOneConnection(KeepAlive keep_alive) {
for (std::unique_ptr<TestSocketRequest>& it : requests_) {
if (it->handle()->is_initialized()) {
if (keep_alive == NO_KEEP_ALIVE)
it->handle()->socket()->Disconnect();
it->handle()->Reset();
base::RunLoop().RunUntilIdle();
return true;
}
}
return false;
}
void ClientSocketPoolTest::ReleaseAllConnections(KeepAlive keep_alive) {
bool released_one;
do {
released_one = ReleaseOneConnection(keep_alive);
} while (released_one);
}
MockTransportClientSocketPool::MockConnectJob::MockConnectJob(
std::unique_ptr<StreamSocket> socket,
ClientSocketHandle* handle,
const CompletionCallback& callback)
: socket_(std::move(socket)), handle_(handle), user_callback_(callback) {}
MockTransportClientSocketPool::MockConnectJob::~MockConnectJob() = default;
int MockTransportClientSocketPool::MockConnectJob::Connect() {
int rv = socket_->Connect(base::Bind(&MockConnectJob::OnConnect,
base::Unretained(this)));
if (rv != ERR_IO_PENDING) {
user_callback_.Reset();
OnConnect(rv);
}
return rv;
}
bool MockTransportClientSocketPool::MockConnectJob::CancelHandle(
const ClientSocketHandle* handle) {
if (handle != handle_)
return false;
socket_.reset();
handle_ = NULL;
user_callback_.Reset();
return true;
}
void MockTransportClientSocketPool::MockConnectJob::OnConnect(int rv) {
if (!socket_.get())
return;
if (rv == OK) {
handle_->SetSocket(std::move(socket_));
// Needed for socket pool tests that layer other sockets on top of mock
// sockets.
LoadTimingInfo::ConnectTiming connect_timing;
base::TimeTicks now = base::TimeTicks::Now();
connect_timing.dns_start = now;
connect_timing.dns_end = now;
connect_timing.connect_start = now;
connect_timing.connect_end = now;
handle_->set_connect_timing(connect_timing);
} else {
socket_.reset();
// Needed to test copying of ConnectionAttempts in SSL ConnectJob.
ConnectionAttempts attempts;
attempts.push_back(ConnectionAttempt(IPEndPoint(), rv));
handle_->set_connection_attempts(attempts);
}
handle_ = NULL;
if (!user_callback_.is_null()) {
CompletionCallback callback = user_callback_;
user_callback_.Reset();
callback.Run(rv);
}
}
MockTransportClientSocketPool::MockTransportClientSocketPool(
int max_sockets,
int max_sockets_per_group,
ClientSocketFactory* socket_factory)
: TransportClientSocketPool(max_sockets,
max_sockets_per_group,
NULL,
NULL,
NULL,
NULL),
client_socket_factory_(socket_factory),
last_request_priority_(DEFAULT_PRIORITY),
release_count_(0),
cancel_count_(0) {}
MockTransportClientSocketPool::~MockTransportClientSocketPool() = default;
int MockTransportClientSocketPool::RequestSocket(
const std::string& group_name,
const void* socket_params,
RequestPriority priority,
RespectLimits respect_limits,
ClientSocketHandle* handle,
const CompletionCallback& callback,
const NetLogWithSource& net_log) {
last_request_priority_ = priority;
std::unique_ptr<StreamSocket> socket =
client_socket_factory_->CreateTransportClientSocket(
AddressList(), NULL, net_log.net_log(), NetLogSource());
MockConnectJob* job = new MockConnectJob(std::move(socket), handle, callback);
job_list_.push_back(base::WrapUnique(job));
handle->set_pool_id(1);
return job->Connect();
}
void MockTransportClientSocketPool::SetPriority(const std::string& group_name,
ClientSocketHandle* handle,
RequestPriority priority) {
// TODO: Implement.
}
void MockTransportClientSocketPool::CancelRequest(const std::string& group_name,
ClientSocketHandle* handle) {
for (std::unique_ptr<MockConnectJob>& it : job_list_) {
if (it->CancelHandle(handle)) {
cancel_count_++;
break;
}
}
}
void MockTransportClientSocketPool::ReleaseSocket(
const std::string& group_name,
std::unique_ptr<StreamSocket> socket,
int id) {
EXPECT_EQ(1, id);
release_count_++;
}
MockSOCKSClientSocketPool::MockSOCKSClientSocketPool(
int max_sockets,
int max_sockets_per_group,
TransportClientSocketPool* transport_pool)
: SOCKSClientSocketPool(max_sockets,
max_sockets_per_group,
NULL,
transport_pool,
NULL,
NULL),
transport_pool_(transport_pool) {}
MockSOCKSClientSocketPool::~MockSOCKSClientSocketPool() = default;
int MockSOCKSClientSocketPool::RequestSocket(const std::string& group_name,
const void* socket_params,
RequestPriority priority,
RespectLimits respect_limits,
ClientSocketHandle* handle,
const CompletionCallback& callback,
const NetLogWithSource& net_log) {
return transport_pool_->RequestSocket(group_name, socket_params, priority,
respect_limits, handle, callback,
net_log);
}
void MockSOCKSClientSocketPool::SetPriority(const std::string& group_name,
ClientSocketHandle* handle,
RequestPriority priority) {
transport_pool_->SetPriority(group_name, handle, priority);
}
void MockSOCKSClientSocketPool::CancelRequest(
const std::string& group_name,
ClientSocketHandle* handle) {
return transport_pool_->CancelRequest(group_name, handle);
}
void MockSOCKSClientSocketPool::ReleaseSocket(
const std::string& group_name,
std::unique_ptr<StreamSocket> socket,
int id) {
return transport_pool_->ReleaseSocket(group_name, std::move(socket), id);
}
ScopedWebSocketEndpointZeroUnlockDelay::
ScopedWebSocketEndpointZeroUnlockDelay() {
old_delay_ =
WebSocketEndpointLockManager::GetInstance()->SetUnlockDelayForTesting(
base::TimeDelta());
}
ScopedWebSocketEndpointZeroUnlockDelay::
~ScopedWebSocketEndpointZeroUnlockDelay() {
base::TimeDelta active_delay =
WebSocketEndpointLockManager::GetInstance()->SetUnlockDelayForTesting(
old_delay_);
EXPECT_EQ(active_delay, base::TimeDelta());
}
WrappedStreamSocket::WrappedStreamSocket(
std::unique_ptr<StreamSocket> transport)
: transport_(std::move(transport)) {}
WrappedStreamSocket::~WrappedStreamSocket() {}
int WrappedStreamSocket::Connect(const CompletionCallback& callback) {
return transport_->Connect(callback);
}
void WrappedStreamSocket::Disconnect() {
transport_->Disconnect();
}
bool WrappedStreamSocket::IsConnected() const {
return transport_->IsConnected();
}
bool WrappedStreamSocket::IsConnectedAndIdle() const {
return transport_->IsConnectedAndIdle();
}
int WrappedStreamSocket::GetPeerAddress(IPEndPoint* address) const {
return transport_->GetPeerAddress(address);
}
int WrappedStreamSocket::GetLocalAddress(IPEndPoint* address) const {
return transport_->GetLocalAddress(address);
}
const NetLogWithSource& WrappedStreamSocket::NetLog() const {
return transport_->NetLog();
}
void WrappedStreamSocket::SetSubresourceSpeculation() {
transport_->SetSubresourceSpeculation();
}
void WrappedStreamSocket::SetOmniboxSpeculation() {
transport_->SetOmniboxSpeculation();
}
bool WrappedStreamSocket::WasEverUsed() const {
return transport_->WasEverUsed();
}
bool WrappedStreamSocket::WasAlpnNegotiated() const {
return transport_->WasAlpnNegotiated();
}
NextProto WrappedStreamSocket::GetNegotiatedProtocol() const {
return transport_->GetNegotiatedProtocol();
}
bool WrappedStreamSocket::GetSSLInfo(SSLInfo* ssl_info) {
return transport_->GetSSLInfo(ssl_info);
}
void WrappedStreamSocket::GetConnectionAttempts(ConnectionAttempts* out) const {
transport_->GetConnectionAttempts(out);
}
void WrappedStreamSocket::ClearConnectionAttempts() {
transport_->ClearConnectionAttempts();
}
void WrappedStreamSocket::AddConnectionAttempts(
const ConnectionAttempts& attempts) {
transport_->AddConnectionAttempts(attempts);
}
int64_t WrappedStreamSocket::GetTotalReceivedBytes() const {
return transport_->GetTotalReceivedBytes();
}
void WrappedStreamSocket::ApplySocketTag(const SocketTag& tag) {
transport_->ApplySocketTag(tag);
}
int WrappedStreamSocket::Read(IOBuffer* buf,
int buf_len,
const CompletionCallback& callback) {
return transport_->Read(buf, buf_len, callback);
}
int WrappedStreamSocket::ReadIfReady(IOBuffer* buf,
int buf_len,
const CompletionCallback& callback) {
return transport_->ReadIfReady(buf, buf_len, callback);
}
int WrappedStreamSocket::Write(
IOBuffer* buf,
int buf_len,
const CompletionCallback& callback,
const NetworkTrafficAnnotationTag& traffic_annotation) {
return transport_->Write(buf, buf_len, callback);
}
int WrappedStreamSocket::SetReceiveBufferSize(int32_t size) {
return transport_->SetReceiveBufferSize(size);
}
int WrappedStreamSocket::SetSendBufferSize(int32_t size) {
return transport_->SetSendBufferSize(size);
}
void MockTaggingStreamSocket::ApplySocketTag(const SocketTag& tag) {
tag_ = tag;
transport_->ApplySocketTag(tag);
}
const char kSOCKS5GreetRequest[] = { 0x05, 0x01, 0x00 };
const int kSOCKS5GreetRequestLength = arraysize(kSOCKS5GreetRequest);
const char kSOCKS5GreetResponse[] = { 0x05, 0x00 };
const int kSOCKS5GreetResponseLength = arraysize(kSOCKS5GreetResponse);
const char kSOCKS5OkRequest[] =
{ 0x05, 0x01, 0x00, 0x03, 0x04, 'h', 'o', 's', 't', 0x00, 0x50 };
const int kSOCKS5OkRequestLength = arraysize(kSOCKS5OkRequest);
const char kSOCKS5OkResponse[] =
{ 0x05, 0x00, 0x00, 0x01, 127, 0, 0, 1, 0x00, 0x50 };
const int kSOCKS5OkResponseLength = arraysize(kSOCKS5OkResponse);
int64_t CountReadBytes(const MockRead reads[], size_t reads_size) {
int64_t total = 0;
for (const MockRead* read = reads; read != reads + reads_size; ++read)
total += read->data_len;
return total;
}
int64_t CountWriteBytes(const MockWrite writes[], size_t writes_size) {
int64_t total = 0;
for (const MockWrite* write = writes; write != writes + writes_size; ++write)
total += write->data_len;
return total;
}
#if defined(OS_ANDROID)
uint64_t GetTaggedBytes(int32_t expected_tag) {
// To determine how many bytes the system saw with a particular tag read
// the /proc/net/xt_qtaguid/stats file which contains the kernel's
// dump of all the UIDs and their tags sent and received bytes.
uint64_t bytes = 0;
std::string contents;
EXPECT_TRUE(base::ReadFileToString(
base::FilePath::FromUTF8Unsafe("/proc/net/xt_qtaguid/stats"), &contents));
for (size_t i = contents.find('\n'); // Skip first line which is headers.
i != std::string::npos && i < contents.length();) {
uint64_t tag, rx_bytes;
uid_t uid;
int n;
// Parse out the numbers we care about. For reference here's the column
// headers:
// idx iface acct_tag_hex uid_tag_int cnt_set rx_bytes rx_packets tx_bytes
// tx_packets rx_tcp_bytes rx_tcp_packets rx_udp_bytes rx_udp_packets
// rx_other_bytes rx_other_packets tx_tcp_bytes tx_tcp_packets tx_udp_bytes
// tx_udp_packets tx_other_bytes tx_other_packets
EXPECT_EQ(sscanf(contents.c_str() + i,
"%*d %*s 0x%" SCNx64 " %d %*d %" SCNu64
" %*d %*d %*d %*d %*d %*d %*d %*d "
"%*d %*d %*d %*d %*d %*d %*d%n",
&tag, &uid, &rx_bytes, &n),
3);
// If this line matches our UID and |expected_tag| then add it to the total.
if (uid == getuid() && (int32_t)(tag >> 32) == expected_tag) {
bytes += rx_bytes;
}
// Move |i| to the next line.
i += n + 1;
}
return bytes;
}
#endif
} // namespace net
| [
"rdeshm0@aptvm070-6.apt.emulab.net"
] | rdeshm0@aptvm070-6.apt.emulab.net |
6c6326b34078fea7d4e446d3d82b2c05d114dde2 | c411e49cdacb485415bcc3603feaa98f45e97963 | /AtividadeLaco/Programa15/main.cpp | 9226668bfc17fc667d62e7edc796855e6e2f79f4 | [] | no_license | Icoeer22/ProgramasC- | a5b256b8a3fbaf0ed982f326122ce8bfb0e0e8c9 | 51270adf362a491a469d46cf0066bf97a57edd5d | refs/heads/master | 2023-05-26T06:20:04.915905 | 2021-06-11T17:03:19 | 2021-06-11T17:03:19 | 362,957,641 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 420 | cpp | #include <iostream>
#include <locale.h>
using namespace std;
int main()
{
setlocale(LC_ALL, "Portuguese");
int num, impar,par = 0,c;
for (c = 0; c <= 19; c++){
cout<< "Informe um valor: ";
cin>> num;
if(num % 2 == 0){
par ++;
}
else{
impar ++;
}
}
cout<< "Foram digitados " << par << " pares e " << impar << " impares.";
}
| [
"pabloaugustodequadros@gmail.com"
] | pabloaugustodequadros@gmail.com |
af04cc63127979f5b85157a0408e0468eb40eab3 | c4988fbdd3dd1f3b363997de3f87f9ae31d3f279 | /sdk/cpprest/api/OperatorInformationApi.cpp | a148fbdcc28d44fb32989af8ae128d6b8d4478ed | [
"Apache-2.0"
] | permissive | JonathanBlood/rtpi-swagger | f49683b2f25c10819415a32d63bec5afe375c228 | 3fa98394d06f50bef420de545e7f14b6457ccf60 | refs/heads/develop | 2020-03-28T22:59:35.820441 | 2017-06-17T15:53:43 | 2017-06-17T15:53:43 | 94,630,491 | 0 | 0 | null | 2017-06-17T15:55:37 | 2017-06-17T14:58:01 | C++ | UTF-8 | C++ | false | false | 6,656 | cpp | /**
* RTPI REST Web Services API
* <p>RTPI REST Web Services API (<a href=\"https://goo.gl/s6NTJe\">RRWS API</a>) provides REST interface to retrieve information on real time bus information, timetables and bus stops. </p> <p>Each method available in RRWS API will be invoked using plain HTTP Request (GET method). Depending on parameters provided, result will be returned either in XML or JSON format (if format is not provided then JSON is used by default). Response will contain requested information (see method specification for details) and error status of the request.</p> <h2>Error Codes</h2> <table> <tr><th>Error Code</th><th>Description</th></tr> <tr><td>0</td><td>Success</td></tr> <tr><td>1</td><td>No Results</td></tr> <tr><td>2</td><td>Missing Parameter</td></tr> <tr><td>3</td><td>Invalid Parameter</td></tr> <tr><td>4</td><td>Sceduled Downtime</td></tr> <tr><td>5</td><td>Unexpected System Error</td></tr> </table> <p>Error code is included in response for each message. For some error codes additional details will be provided in free text format (Error Message field).</p>
*
* OpenAPI spec version: 1.0.0
*
*
* NOTE: This class is auto generated by the swagger code generator program.
* https://github.com/swagger-api/swagger-codegen.git
* Do not edit the class manually.
*
* 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 "OperatorInformationApi.h"
#include "IHttpBody.h"
#include "JsonBody.h"
#include "MultipartFormData.h"
#include <unordered_set>
#include <boost/algorithm/string/replace.hpp>
namespace io {
namespace swagger {
namespace client {
namespace api {
using namespace io::swagger::client::model;
OperatorInformationApi::OperatorInformationApi( std::shared_ptr<ApiClient> apiClient )
: m_ApiClient(apiClient)
{
}
OperatorInformationApi::~OperatorInformationApi()
{
}
pplx::task<std::shared_ptr<OperatorList>> OperatorInformationApi::getOperators(utility::string_t format)
{
std::shared_ptr<ApiConfiguration> apiConfiguration( m_ApiClient->getConfiguration() );
utility::string_t path = U("/operatorinformation");
std::map<utility::string_t, utility::string_t> queryParams;
std::map<utility::string_t, utility::string_t> headerParams( apiConfiguration->getDefaultHeaders() );
std::map<utility::string_t, utility::string_t> formParams;
std::map<utility::string_t, std::shared_ptr<HttpContent>> fileParams;
std::unordered_set<utility::string_t> responseHttpContentTypes;
responseHttpContentTypes.insert( U("application/json") );
responseHttpContentTypes.insert( U("application/xml") );
utility::string_t responseHttpContentType;
// use JSON if possible
if ( responseHttpContentTypes.size() == 0 || responseHttpContentTypes.find(U("application/json")) != responseHttpContentTypes.end() )
{
responseHttpContentType = U("application/json");
}
// multipart formdata
else if( responseHttpContentTypes.find(U("multipart/form-data")) != responseHttpContentTypes.end() )
{
responseHttpContentType = U("multipart/form-data");
}
else
{
throw ApiException(400, U("OperatorInformationApi->getOperators does not produce any supported media type"));
}
headerParams[U("Accept")] = responseHttpContentType;
std::unordered_set<utility::string_t> consumeHttpContentTypes;
consumeHttpContentTypes.insert( U("application/json") );
consumeHttpContentTypes.insert( U("application/xml") );
{
queryParams[U("format")] = ApiClient::parameterToString(format);
}
std::shared_ptr<IHttpBody> httpBody;
utility::string_t requestHttpContentType;
// use JSON if possible
if ( consumeHttpContentTypes.size() == 0 || consumeHttpContentTypes.find(U("application/json")) != consumeHttpContentTypes.end() )
{
requestHttpContentType = U("application/json");
}
// multipart formdata
else if( consumeHttpContentTypes.find(U("multipart/form-data")) != consumeHttpContentTypes.end() )
{
requestHttpContentType = U("multipart/form-data");
}
else
{
throw ApiException(415, U("OperatorInformationApi->getOperators does not consume any supported media type"));
}
return m_ApiClient->callApi(path, U("GET"), queryParams, httpBody, headerParams, formParams, fileParams, requestHttpContentType)
.then([=](web::http::http_response response)
{
// 1xx - informational : OK
// 2xx - successful : OK
// 3xx - redirection : OK
// 4xx - client error : not OK
// 5xx - client error : not OK
if (response.status_code() >= 400)
{
throw ApiException(response.status_code()
, U("error calling getOperators: ") + response.reason_phrase()
, std::make_shared<std::stringstream>(response.extract_utf8string(true).get()));
}
// check response content type
if(response.headers().has(U("Content-Type")))
{
utility::string_t contentType = response.headers()[U("Content-Type")];
if( contentType.find(responseHttpContentType) == std::string::npos )
{
throw ApiException(500
, U("error calling getOperators: unexpected response type: ") + contentType
, std::make_shared<std::stringstream>(response.extract_utf8string(true).get()));
}
}
return response.extract_string();
})
.then([=](utility::string_t response)
{
std::shared_ptr<OperatorList> result(new OperatorList());
if(responseHttpContentType == U("application/json"))
{
web::json::value json = web::json::value::parse(response);
result->fromJson(json);
}
// else if(responseHttpContentType == U("multipart/form-data"))
// {
// TODO multipart response parsing
// }
else
{
throw ApiException(500
, U("error calling findPetsByStatus: unsupported response type"));
}
return result;
});
}
}
}
}
}
| [
"JonathanBlood2009@gmail.com"
] | JonathanBlood2009@gmail.com |
49f3e988d0b835ea9020a775d6e0c634b095820f | acbc9d24964a47850b8c3e02ceeacc3ad39fa854 | /playGround.cpp | 239b50865c5b03b0668e22059680cb42e74fbe63 | [] | no_license | Shung-2/Mystic_Art | 0906b3373728645dfe5010e382d7f7d44e9f984b | fc767c28b15fee19c922cacb4c62d815a9ebb991 | refs/heads/main | 2023-08-15T16:32:58.699567 | 2021-09-24T08:21:14 | 2021-09-24T08:21:14 | 409,871,910 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 1,958 | cpp | #include "stdafx.h"
#include "playGround.h"
playGround::playGround()
{
}
playGround::~playGround()
{
}
//์ด๊ธฐํ๋ ์ฌ๊ธฐ๋ค ํ์ธ์ ์ ๋ฐ
HRESULT playGround::init()
{
gameNode::init(true);
/* SHIP ์์
๋ด์ฉ */
//IMAGEMANAGER->addImage("๋ฐฐ๊ฒฝ", "background.bmp", WINSIZEX, WINSIZEY, true, RGB(255, 0, 255));
//_ship = new spaceShip;
//_ship->init();
//IMAGEMANAGER->addImage("bullet", "bullet.bmp", 21, 21, true, RGB(255, 0, 255));
//IMAGEMANAGER->addFrameImage("enemy", "ufo.bmp", 0, 0, 530, 32, 10, 1, true, RGB(255, 0, 255));
/* SCENE ์ถ๊ฐ */
SCENEMANAGER->addScene("INTRO", new testScene);
SCENEMANAGER->addScene("OPTION", new testScene2);
SCENEMANAGER->addScene("STAGE 1", new Stage1);
SCENEMANAGER->addScene("STAGE 2", new Stage2);
SCENEMANAGER->addScene("STAGE 3", new Stage3);
SCENEMANAGER->changeScene("INTRO");
/* STAGE ๋์ ํ ๋น */
st = new Stage1;
st->setPlayerAddressLink(pl);
return S_OK;
}
//๋ฉ๋ชจ๋ฆฌ ํด์ ๋ ์ฌ๊ธฐ๋ค ํ์ธ์ ์ ๋ฐ
void playGround::release()
{
gameNode::release();
//SAFE_DELETE(_ship);
}
void playGround::update()
{
gameNode::update();
//_ship->update();
/* ํน์ ํค๋ฅผ ์
๋ ฅ ํ ๋ ์ฌ ์ ํ */
SCENEMANAGER->update();
if (KEYMANAGER->isOnceKeyDown(VK_F1))
{
SCENEMANAGER->changeScene("STAGE 1");
}
if (KEYMANAGER->isOnceKeyDown(VK_F2))
{
SCENEMANAGER->changeScene("STAGE 2");
}
if (KEYMANAGER->isOnceKeyDown(VK_F3))
{
SCENEMANAGER->changeScene("STAGE 3");
}
}
void playGround::render()
{
PatBlt(getMemDC(), 0, 0, WINSIZEX, WINSIZEY, WHITENESS);
// ์์ ๊ฑด๋ค์ง๋ง๋ผ
//================์ ๋ฐ ์ด ์ฌ์ด์ ์ข ๊ทธ๋ฆฝ์๋ค==========================
//IMAGEMANAGER->findImage("๋ฐฐ๊ฒฝ")->render(getMemDC(), 0, 0);
//_ship->render();
SCENEMANAGER->render();
TIMEMANAGER->render(getMemDC());
//==================================================
//์ฌ๊ธฐ๋ ๊ฑด๋ค์ง๋ง๋ผ
this->getBackBuffer()->render(getHDC(), 0, 0);
}
| [
"66060749+Shung-2@users.noreply.github.com"
] | 66060749+Shung-2@users.noreply.github.com |
ade1eda37ce4f24b3d890d1ccb765f4f6c4b73db | c5bbed363b5d4e887271faeb0361ae7ac6af8b82 | /binary search/18_staircaseSearch.cpp | 7643fb7da46d9e9aa00dd5d5ea7010d4354ebf55 | [] | no_license | adityachoudharyclg/codingFinalYear | f78be4d59086b1166274c1b0dece714d680c0acb | 9098ce79c65ec0e816b0c801a401a07c98eeb1af | refs/heads/master | 2023-02-12T21:45:22.026770 | 2020-12-31T23:46:49 | 2020-12-31T23:46:49 | 266,867,584 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 846 | cpp | #include <bits/stdc++.h>
#define ll long long
#define mod 1000000007
using namespace std;
int solve(int arr[][500], int m, int n, int ele) {
int i = 0;
int j = n - 1;
while (i < m && j >= 0) {
if (arr[i][j] == ele) {
return 1;
} else if (arr[i][j] > ele) {
j--;
} else if (arr[i][j] < ele) {
i++;
}
}
return 0;
}
int main() {
freopen("input.txt", "r", stdin);
freopen("output.txt", "w", stdout);
int t;
cin >> t;
while (t--) {
int m, n;
cin >> m >> n;
int arr[500][500];
for (int i = 0; i < m; i++) {
for (int j = 0; j < n; j++) {
cin >> arr[i][j];
}
}
int ele;
cin >> ele;
cout << solve(arr, m, n, ele) << endl;
}
return 0;
} | [
"33027155+adityachoudary54@users.noreply.github.com"
] | 33027155+adityachoudary54@users.noreply.github.com |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.