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 |
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
09e533c67966afe6bde4cc3570ff5f22be50e673 | bd97d912ab97ea7308b6a4ab6223c6f406e5ec16 | /main.cpp | 99fd0936628d123effd9ba68b9a5e1561498b373 | [] | no_license | lapinozz/DungeonGeneration | 862550ba197e83ad1f05cff3a0b9b23aaf7f4e5b | 0ffe04a25d1ac4896099cbf1df1d14933e787b58 | refs/heads/master | 2021-01-15T10:12:49.749123 | 2016-09-15T20:00:27 | 2016-09-15T20:00:27 | 68,326,142 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,994 | cpp | #include <SFML/System.hpp>
#include <SFML/Graphics.hpp>
#include "tilemap.hpp"
#include "dungeonGenerator.hpp"
#include <imgui.h>
#include <imgui-SFML.h>
int main()
{
sf::RenderWindow window(sf::VideoMode(750, 750), "map");
ImGui::SFML::Init(window);
Dungeon dungeon;
sf::Clock deltaClock;
while(window.isOpen())
{
sf::Event event;
while(window.pollEvent(event))
{
ImGui::SFML::ProcessEvent(event);
if (event.type == sf::Event::Closed)
{
window.close();
}
}
window.clear();
dungeon.rooms.clear();
dungeon.corridors.clear();
dungeon.edges.clear();
ImGui::SFML::Update(deltaClock.restart());
ImGui::Begin("Data");
ImGui::SliderInt("Seed", &dungeon.seed, -1, 99999);
ImGui::SliderInt("Minimum Room Size", &dungeon.roomSizeMin, 2, dungeon.roomSizeMax);
ImGui::SliderInt("Maximum Room Size", &dungeon.roomSizeMax, dungeon.roomSizeMin, std::min(dungeon.size.x, dungeon.size.y));
ImGui::SliderInt("Room Pool Size", &dungeon.roomPoolSize, 1, 100);
ImGui::SliderInt("Distance", &dungeon.minimalRoomDistance, 1, 100);
ImGui::SliderInt("Directional Distance", &dungeon.minimalDirectionalRoomDistance, 1, 100);
ImGui::SliderInt("Additional Corridors", &dungeon.additionalEdge, 0, 100);
ImGui::SliderInt("Distance from door to corner", &dungeon.minDoorDistToCorner, 0, dungeon.roomSizeMin - 2);
ImGui::End(); // end windowindowindow
generateDungeon(dungeon);
sf::RectangleShape rect({10, 10});
rect.setFillColor(sf::Color::White);
for(const auto& room: dungeon.rooms)
{
rect.setPosition((sf::Vector2f)room.pos * 10.f);
rect.setSize((sf::Vector2f)room.size * 10.f);
window.draw(rect);
}
sf::CircleShape circle;
circle.setRadius(3);
circle.setOrigin(circle.getRadius(), circle.getRadius());
circle.setFillColor(sf::Color::Blue);
for(const auto& room : dungeon.rooms)
{
circle.setPosition((sf::Vector2f)(room.pos + room.size/2) * 10.f);
circle.move(0.5f, 0.5f);
window.draw(circle);
}
for(const auto& edge : dungeon.edges)
{
sf::VertexArray va;
va.setPrimitiveType(sf::Lines);
va.append({(sf::Vector2f)edge.p1*10.f, sf::Color::Yellow});
va.append({(sf::Vector2f)edge.p2*10.f, sf::Color::Yellow});
window.draw(va);
}
rect.setFillColor(sf::Color::Green);
for(const auto& corridor : dungeon.corridors)
{
rect.setPosition((sf::Vector2f)corridor.start*10.f);
rect.setSize((sf::Vector2f)corridor.end*10.f - (sf::Vector2f)corridor.start*10.f);
window.draw(rect);
}
ImGui::Render();
window.display();
}
}
| [
"monstrefou@gmail.com"
] | monstrefou@gmail.com |
96c50bd3984c1c0e5c4b100672484ff264428463 | 1f29483a03357cb50bf5da56fcef5825ce5acf79 | /Analysis/src/ScaleFactorHandlerBase.cc | 3b589fe2943171323e1a5de5647405116a5d89be | [] | no_license | usarica/STOP_1Lepton | 65ee75df196e3d86418a24003fda9bd097f51859 | 8bb313845111709372d3c00f8848c1555c0ef71e | refs/heads/master | 2020-04-12T05:52:11.062045 | 2019-07-18T14:57:46 | 2019-07-18T14:57:46 | 162,334,632 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 790 | cc | #include "ScaleFactorHandlerBase.h"
#include "TDirectory.h"
void ScaleFactorHandlerBase::closeFile(TFile*& f){
if (f){
if (f->IsOpen()) f->Close();
else delete f;
}
f = nullptr;
}
template<typename T> bool ScaleFactorHandlerBase::getHistogram(T*& h, TFile*& f, TString s){
TDirectory* curdir = gDirectory;
if (s=="") return false;
if (!f) return false;
if (!f->IsOpen()) return false;
if (f->IsZombie()) return false;
f->cd();
h = (T*) f->Get(s);
curdir->cd();
return (h!=nullptr);
}
template bool ScaleFactorHandlerBase::getHistogram<TH1F>(TH1F*& h, TFile*& f, TString s);
template bool ScaleFactorHandlerBase::getHistogram<TH1D>(TH1D*& h, TFile*& f, TString s);
template bool ScaleFactorHandlerBase::getHistogram<TH2F>(TH2F*& h, TFile*& f, TString s);
| [
"ulascan90@gmail.com"
] | ulascan90@gmail.com |
288278ea1022182acf8332a4ed57dbc349aff030 | f556301fd9bdba0e463bb6f08bd83db0fd258a8d | /extensions/gen/mojo/public/tools/fuzzers/fuzz.mojom.cc | 9eed5977fb8821af273d76cb399e50f765458f03 | [
"LicenseRef-scancode-unknown-license-reference",
"BSD-3-Clause"
] | permissive | blockspacer/chromium_base_conan | ce7c0825b6a62c2c1272ccab5e31f15d316aa9ac | 726d2a446eb926f694e04ab166c0bbfdb40850f2 | refs/heads/master | 2022-09-14T17:13:27.992790 | 2022-08-24T11:04:58 | 2022-08-24T11:04:58 | 225,695,691 | 18 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 77,490 | cc | // mojo/public/tools/fuzzers/fuzz.mojom.cc is auto generated by mojom_bindings_generator.py, do not edit
// Copyright 2013 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#if defined(__clang__)
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Wunused-private-field"
#endif
#include "mojo/public/tools/fuzzers/fuzz.mojom.h"
#include <math.h>
#include <stdint.h>
#include <utility>
#include "base/hash/md5_constexpr.h"
#include "base/run_loop.h"
#include "base/strings/string_number_conversions.h"
#include "base/task/common/task_annotator.h"
#include "base/trace_event/trace_event.h"
#include "mojo/public/cpp/bindings/lib/generated_code_util.h"
#include "mojo/public/cpp/bindings/lib/message_internal.h"
#include "mojo/public/cpp/bindings/lib/serialization_util.h"
#include "mojo/public/cpp/bindings/lib/unserialized_message_context.h"
#include "mojo/public/cpp/bindings/lib/validate_params.h"
#include "mojo/public/cpp/bindings/lib/validation_context.h"
#include "mojo/public/cpp/bindings/lib/validation_errors.h"
#include "mojo/public/cpp/bindings/mojo_buildflags.h"
#include "mojo/public/interfaces/bindings/interface_control_messages.mojom.h"
#include "third_party/perfetto/include/perfetto/tracing/traced_value.h"
#include "mojo/public/tools/fuzzers/fuzz.mojom-params-data.h"
#include "mojo/public/tools/fuzzers/fuzz.mojom-shared-message-ids.h"
#include "mojo/public/tools/fuzzers/fuzz.mojom-import-headers.h"
#ifndef MOJO_PUBLIC_TOOLS_FUZZERS_FUZZ_MOJOM_JUMBO_H_
#define MOJO_PUBLIC_TOOLS_FUZZERS_FUZZ_MOJOM_JUMBO_H_
#endif
namespace fuzz {
namespace mojom {
FuzzDummyStruct::FuzzDummyStruct()
: dummy() {}
FuzzDummyStruct::FuzzDummyStruct(
int8_t dummy_in)
: dummy(std::move(dummy_in)) {}
FuzzDummyStruct::~FuzzDummyStruct() = default;
size_t FuzzDummyStruct::Hash(size_t seed) const {
seed = mojo::internal::Hash(seed, this->dummy);
return seed;
}
void FuzzDummyStruct::WriteIntoTracedValue(perfetto::TracedValue context) const {
auto dict = std::move(context).WriteDictionary();
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"dummy"), this->dummy,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type int8_t>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
}
bool FuzzDummyStruct::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) {
return Data_::Validate(data, validation_context);
}
FuzzStruct::FuzzStruct()
: fuzz_bool(),
fuzz_int8(),
fuzz_uint8(),
fuzz_int16(),
fuzz_uint16(),
fuzz_int32(),
fuzz_uint32(),
fuzz_int64(),
fuzz_uint64(),
fuzz_float(),
fuzz_double(),
fuzz_string(),
fuzz_bool_array(),
fuzz_primitive_array(),
fuzz_primitive_map(),
fuzz_array_map(),
fuzz_union_map(),
fuzz_union_array(),
fuzz_struct_array(),
fuzz_nullable_array(),
fuzz_complex() {}
FuzzStruct::FuzzStruct(
bool fuzz_bool_in,
int8_t fuzz_int8_in,
uint8_t fuzz_uint8_in,
int16_t fuzz_int16_in,
uint16_t fuzz_uint16_in,
int32_t fuzz_int32_in,
uint32_t fuzz_uint32_in,
int64_t fuzz_int64_in,
uint64_t fuzz_uint64_in,
float fuzz_float_in,
double fuzz_double_in,
const std::string& fuzz_string_in,
std::vector<bool> fuzz_bool_array_in,
std::vector<int8_t> fuzz_primitive_array_in,
const base::flat_map<std::string, int8_t>& fuzz_primitive_map_in,
const base::flat_map<std::string, std::vector<std::string>>& fuzz_array_map_in,
base::flat_map<FuzzEnum, FuzzUnionPtr> fuzz_union_map_in,
std::vector<FuzzUnionPtr> fuzz_union_array_in,
std::vector<FuzzStructPtr> fuzz_struct_array_in,
base::Optional<std::vector<int8_t>> fuzz_nullable_array_in,
base::Optional<std::vector<base::flat_map<FuzzEnum, base::flat_map<int8_t, base::Optional<std::vector<FuzzStructPtr>>>>>> fuzz_complex_in)
: fuzz_bool(std::move(fuzz_bool_in)),
fuzz_int8(std::move(fuzz_int8_in)),
fuzz_uint8(std::move(fuzz_uint8_in)),
fuzz_int16(std::move(fuzz_int16_in)),
fuzz_uint16(std::move(fuzz_uint16_in)),
fuzz_int32(std::move(fuzz_int32_in)),
fuzz_uint32(std::move(fuzz_uint32_in)),
fuzz_int64(std::move(fuzz_int64_in)),
fuzz_uint64(std::move(fuzz_uint64_in)),
fuzz_float(std::move(fuzz_float_in)),
fuzz_double(std::move(fuzz_double_in)),
fuzz_string(std::move(fuzz_string_in)),
fuzz_bool_array(std::move(fuzz_bool_array_in)),
fuzz_primitive_array(std::move(fuzz_primitive_array_in)),
fuzz_primitive_map(std::move(fuzz_primitive_map_in)),
fuzz_array_map(std::move(fuzz_array_map_in)),
fuzz_union_map(std::move(fuzz_union_map_in)),
fuzz_union_array(std::move(fuzz_union_array_in)),
fuzz_struct_array(std::move(fuzz_struct_array_in)),
fuzz_nullable_array(std::move(fuzz_nullable_array_in)),
fuzz_complex(std::move(fuzz_complex_in)) {}
FuzzStruct::~FuzzStruct() = default;
void FuzzStruct::WriteIntoTracedValue(perfetto::TracedValue context) const {
auto dict = std::move(context).WriteDictionary();
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_bool"), this->fuzz_bool,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type bool>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_int8"), this->fuzz_int8,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type int8_t>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_uint8"), this->fuzz_uint8,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type uint8_t>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_int16"), this->fuzz_int16,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type int16_t>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_uint16"), this->fuzz_uint16,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type uint16_t>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_int32"), this->fuzz_int32,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type int32_t>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_uint32"), this->fuzz_uint32,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type uint32_t>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_int64"), this->fuzz_int64,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type int64_t>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_uint64"), this->fuzz_uint64,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type uint64_t>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_float"), this->fuzz_float,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type float>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_double"), this->fuzz_double,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type double>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_string"), this->fuzz_string,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type const std::string&>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_bool_array"), this->fuzz_bool_array,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type const std::vector<bool>&>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_primitive_array"), this->fuzz_primitive_array,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type const std::vector<int8_t>&>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_primitive_map"), this->fuzz_primitive_map,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type const base::flat_map<std::string, int8_t>&>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_array_map"), this->fuzz_array_map,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type const base::flat_map<std::string, std::vector<std::string>>&>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_union_map"), this->fuzz_union_map,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type base::flat_map<FuzzEnum, FuzzUnionPtr>>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_union_array"), this->fuzz_union_array,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type std::vector<FuzzUnionPtr>>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_struct_array"), this->fuzz_struct_array,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type std::vector<FuzzStructPtr>>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_nullable_array"), this->fuzz_nullable_array,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type const base::Optional<std::vector<int8_t>>&>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem(
"fuzz_complex"), this->fuzz_complex,
#if BUILDFLAG(MOJO_TRACE_ENABLED)
"<value of type base::Optional<std::vector<base::flat_map<FuzzEnum, base::flat_map<int8_t, base::Optional<std::vector<FuzzStructPtr>>>>>>>"
#else
"<value>"
#endif // BUILDFLAG(MOJO_TRACE_ENABLED)
);
}
bool FuzzStruct::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) {
return Data_::Validate(data, validation_context);
}
FuzzUnion::FuzzUnion() : tag_(Tag::FUZZ_BOOL) {
data_.fuzz_bool = bool();
}
FuzzUnion::~FuzzUnion() {
DestroyActive();
}
void FuzzUnion::set_fuzz_bool(
bool fuzz_bool) {
if (tag_ != Tag::FUZZ_BOOL) {
DestroyActive();
tag_ = Tag::FUZZ_BOOL;
}
data_.fuzz_bool = fuzz_bool;
}
void FuzzUnion::set_fuzz_int8(
int8_t fuzz_int8) {
if (tag_ != Tag::FUZZ_INT8) {
DestroyActive();
tag_ = Tag::FUZZ_INT8;
}
data_.fuzz_int8 = fuzz_int8;
}
void FuzzUnion::set_fuzz_uint8(
uint8_t fuzz_uint8) {
if (tag_ != Tag::FUZZ_UINT8) {
DestroyActive();
tag_ = Tag::FUZZ_UINT8;
}
data_.fuzz_uint8 = fuzz_uint8;
}
void FuzzUnion::set_fuzz_int16(
int16_t fuzz_int16) {
if (tag_ != Tag::FUZZ_INT16) {
DestroyActive();
tag_ = Tag::FUZZ_INT16;
}
data_.fuzz_int16 = fuzz_int16;
}
void FuzzUnion::set_fuzz_uint16(
uint16_t fuzz_uint16) {
if (tag_ != Tag::FUZZ_UINT16) {
DestroyActive();
tag_ = Tag::FUZZ_UINT16;
}
data_.fuzz_uint16 = fuzz_uint16;
}
void FuzzUnion::set_fuzz_int32(
int32_t fuzz_int32) {
if (tag_ != Tag::FUZZ_INT32) {
DestroyActive();
tag_ = Tag::FUZZ_INT32;
}
data_.fuzz_int32 = fuzz_int32;
}
void FuzzUnion::set_fuzz_uint32(
uint32_t fuzz_uint32) {
if (tag_ != Tag::FUZZ_UINT32) {
DestroyActive();
tag_ = Tag::FUZZ_UINT32;
}
data_.fuzz_uint32 = fuzz_uint32;
}
void FuzzUnion::set_fuzz_int64(
int64_t fuzz_int64) {
if (tag_ != Tag::FUZZ_INT64) {
DestroyActive();
tag_ = Tag::FUZZ_INT64;
}
data_.fuzz_int64 = fuzz_int64;
}
void FuzzUnion::set_fuzz_uint64(
uint64_t fuzz_uint64) {
if (tag_ != Tag::FUZZ_UINT64) {
DestroyActive();
tag_ = Tag::FUZZ_UINT64;
}
data_.fuzz_uint64 = fuzz_uint64;
}
void FuzzUnion::set_fuzz_float(
float fuzz_float) {
if (tag_ != Tag::FUZZ_FLOAT) {
DestroyActive();
tag_ = Tag::FUZZ_FLOAT;
}
data_.fuzz_float = fuzz_float;
}
void FuzzUnion::set_fuzz_double(
double fuzz_double) {
if (tag_ != Tag::FUZZ_DOUBLE) {
DestroyActive();
tag_ = Tag::FUZZ_DOUBLE;
}
data_.fuzz_double = fuzz_double;
}
void FuzzUnion::set_fuzz_string(
const std::string& fuzz_string) {
if (tag_ == Tag::FUZZ_STRING) {
*(data_.fuzz_string) = std::move(fuzz_string);
} else {
DestroyActive();
tag_ = Tag::FUZZ_STRING;
data_.fuzz_string = new std::string(
std::move(fuzz_string));
}
}
void FuzzUnion::set_fuzz_bool_array(
std::vector<bool> fuzz_bool_array) {
if (tag_ == Tag::FUZZ_BOOL_ARRAY) {
*(data_.fuzz_bool_array) = std::move(fuzz_bool_array);
} else {
DestroyActive();
tag_ = Tag::FUZZ_BOOL_ARRAY;
data_.fuzz_bool_array = new std::vector<bool>(
std::move(fuzz_bool_array));
}
}
void FuzzUnion::set_fuzz_primitive_array(
std::vector<int8_t> fuzz_primitive_array) {
if (tag_ == Tag::FUZZ_PRIMITIVE_ARRAY) {
*(data_.fuzz_primitive_array) = std::move(fuzz_primitive_array);
} else {
DestroyActive();
tag_ = Tag::FUZZ_PRIMITIVE_ARRAY;
data_.fuzz_primitive_array = new std::vector<int8_t>(
std::move(fuzz_primitive_array));
}
}
void FuzzUnion::set_fuzz_struct_array(
std::vector<FuzzDummyStructPtr> fuzz_struct_array) {
if (tag_ == Tag::FUZZ_STRUCT_ARRAY) {
*(data_.fuzz_struct_array) = std::move(fuzz_struct_array);
} else {
DestroyActive();
tag_ = Tag::FUZZ_STRUCT_ARRAY;
data_.fuzz_struct_array = new std::vector<FuzzDummyStructPtr>(
std::move(fuzz_struct_array));
}
}
void FuzzUnion::set_fuzz_primitive_map(
const base::flat_map<std::string, int8_t>& fuzz_primitive_map) {
if (tag_ == Tag::FUZZ_PRIMITIVE_MAP) {
*(data_.fuzz_primitive_map) = std::move(fuzz_primitive_map);
} else {
DestroyActive();
tag_ = Tag::FUZZ_PRIMITIVE_MAP;
data_.fuzz_primitive_map = new base::flat_map<std::string, int8_t>(
std::move(fuzz_primitive_map));
}
}
void FuzzUnion::set_fuzz_array_map(
const base::flat_map<std::string, std::vector<std::string>>& fuzz_array_map) {
if (tag_ == Tag::FUZZ_ARRAY_MAP) {
*(data_.fuzz_array_map) = std::move(fuzz_array_map);
} else {
DestroyActive();
tag_ = Tag::FUZZ_ARRAY_MAP;
data_.fuzz_array_map = new base::flat_map<std::string, std::vector<std::string>>(
std::move(fuzz_array_map));
}
}
void FuzzUnion::set_fuzz_struct_map(
base::flat_map<std::string, FuzzDummyStructPtr> fuzz_struct_map) {
if (tag_ == Tag::FUZZ_STRUCT_MAP) {
*(data_.fuzz_struct_map) = std::move(fuzz_struct_map);
} else {
DestroyActive();
tag_ = Tag::FUZZ_STRUCT_MAP;
data_.fuzz_struct_map = new base::flat_map<std::string, FuzzDummyStructPtr>(
std::move(fuzz_struct_map));
}
}
void FuzzUnion::set_fuzz_union_map(
base::flat_map<FuzzEnum, FuzzUnionPtr> fuzz_union_map) {
if (tag_ == Tag::FUZZ_UNION_MAP) {
*(data_.fuzz_union_map) = std::move(fuzz_union_map);
} else {
DestroyActive();
tag_ = Tag::FUZZ_UNION_MAP;
data_.fuzz_union_map = new base::flat_map<FuzzEnum, FuzzUnionPtr>(
std::move(fuzz_union_map));
}
}
void FuzzUnion::set_fuzz_complex(
base::Optional<std::vector<base::flat_map<FuzzEnum, base::flat_map<int8_t, base::Optional<std::vector<FuzzUnionPtr>>>>>> fuzz_complex) {
if (tag_ == Tag::FUZZ_COMPLEX) {
*(data_.fuzz_complex) = std::move(fuzz_complex);
} else {
DestroyActive();
tag_ = Tag::FUZZ_COMPLEX;
data_.fuzz_complex = new base::Optional<std::vector<base::flat_map<FuzzEnum, base::flat_map<int8_t, base::Optional<std::vector<FuzzUnionPtr>>>>>>(
std::move(fuzz_complex));
}
}
void FuzzUnion::DestroyActive() {
switch (tag_) {
case Tag::FUZZ_BOOL:
break;
case Tag::FUZZ_INT8:
break;
case Tag::FUZZ_UINT8:
break;
case Tag::FUZZ_INT16:
break;
case Tag::FUZZ_UINT16:
break;
case Tag::FUZZ_INT32:
break;
case Tag::FUZZ_UINT32:
break;
case Tag::FUZZ_INT64:
break;
case Tag::FUZZ_UINT64:
break;
case Tag::FUZZ_FLOAT:
break;
case Tag::FUZZ_DOUBLE:
break;
case Tag::FUZZ_STRING:
delete data_.fuzz_string;
break;
case Tag::FUZZ_BOOL_ARRAY:
delete data_.fuzz_bool_array;
break;
case Tag::FUZZ_PRIMITIVE_ARRAY:
delete data_.fuzz_primitive_array;
break;
case Tag::FUZZ_STRUCT_ARRAY:
delete data_.fuzz_struct_array;
break;
case Tag::FUZZ_PRIMITIVE_MAP:
delete data_.fuzz_primitive_map;
break;
case Tag::FUZZ_ARRAY_MAP:
delete data_.fuzz_array_map;
break;
case Tag::FUZZ_STRUCT_MAP:
delete data_.fuzz_struct_map;
break;
case Tag::FUZZ_UNION_MAP:
delete data_.fuzz_union_map;
break;
case Tag::FUZZ_COMPLEX:
delete data_.fuzz_complex;
break;
}
}
bool FuzzUnion::Validate(
const void* data,
mojo::internal::ValidationContext* validation_context) {
return Data_::Validate(data, validation_context, false);
}
const char FuzzDummyInterface::Name_[] = "fuzz.mojom.FuzzDummyInterface";
FuzzDummyInterfaceProxy::FuzzDummyInterfaceProxy(mojo::MessageReceiverWithResponder* receiver)
: receiver_(receiver) {
}
void FuzzDummyInterfaceProxy::Ping(
) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT0("mojom", "fuzz::mojom::FuzzDummyInterface::Ping");
#endif
const bool kExpectsResponse = false;
const bool kIsSync = false;
const uint32_t kFlags =
((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
((kIsSync) ? mojo::Message::kFlagIsSync : 0);
mojo::Message message(
internal::kFuzzDummyInterface_Ping_Name, kFlags, 0, 0, nullptr);
mojo::internal::MessageFragment<
::fuzz::mojom::internal::FuzzDummyInterface_Ping_Params_Data> params(
message);
params.Allocate();
#if defined(ENABLE_IPC_FUZZER)
message.set_interface_name(FuzzDummyInterface::Name_);
message.set_method_name("Ping");
#endif
// This return value may be ignored as false implies the Connector has
// encountered an error, which will be visible through other means.
ignore_result(receiver_->Accept(&message));
}
// static
bool FuzzDummyInterfaceStubDispatch::Accept(
FuzzDummyInterface* impl,
mojo::Message* message) {
switch (message->header()->name) {
case internal::kFuzzDummyInterface_Ping_Name: {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1(
"mojom",
"(Impl)fuzz::mojom::FuzzDummyInterface::Ping",
"message", message->name());
#endif
static constexpr uint32_t kMessageHash = base::MD5Hash32Constexpr(
"(Impl)fuzz::mojom::FuzzDummyInterface::Ping");
base::TaskAnnotator::ScopedSetIpcHash scoped_ipc_hash(kMessageHash);
DCHECK(message->is_serialized());
internal::FuzzDummyInterface_Ping_Params_Data* params =
reinterpret_cast<internal::FuzzDummyInterface_Ping_Params_Data*>(
message->mutable_payload());
bool success = true;
FuzzDummyInterface_Ping_ParamsDataView input_data_view(params, message);
if (!success) {
ReportValidationErrorForMessage(
message,
mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
FuzzDummyInterface::Name_, 0, false);
return false;
}
// A null |impl| means no implementation was bound.
DCHECK(impl);
impl->Ping();
return true;
}
}
return false;
}
// static
bool FuzzDummyInterfaceStubDispatch::AcceptWithResponder(
FuzzDummyInterface* impl,
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
const bool message_is_sync = message->has_flag(mojo::Message::kFlagIsSync);
const uint64_t request_id = message->request_id();
ALLOW_UNUSED_LOCAL(message_is_sync);
ALLOW_UNUSED_LOCAL(request_id);
switch (message->header()->name) {
case internal::kFuzzDummyInterface_Ping_Name: {
break;
}
}
return false;
}
static const std::pair<uint32_t, mojo::internal::GenericValidationInfo> kFuzzDummyInterfaceValidationInfo[] = {
{internal::kFuzzDummyInterface_Ping_Name,
{&internal::FuzzDummyInterface_Ping_Params_Data::Validate,
nullptr /* no response */}},
};
bool FuzzDummyInterfaceRequestValidator::Accept(mojo::Message* message) {
const char* name = ::fuzz::mojom::FuzzDummyInterface::Name_;
return mojo::internal::ValidateRequestGeneric(message, name, kFuzzDummyInterfaceValidationInfo);
}
const char FuzzInterface::Name_[] = "fuzz.mojom.FuzzInterface";
bool FuzzInterface::FuzzBasicSyncResp() {
NOTREACHED();
return false;
}
bool FuzzInterface::FuzzArgsSyncResp(FuzzStructPtr a, FuzzStructPtr b) {
NOTREACHED();
return false;
}
class FuzzInterface_FuzzBasicResp_ForwardToCallback
: public mojo::MessageReceiver {
public:
FuzzInterface_FuzzBasicResp_ForwardToCallback(
FuzzInterface::FuzzBasicRespCallback callback
) : callback_(std::move(callback)) {
}
bool Accept(mojo::Message* message) override;
private:
FuzzInterface::FuzzBasicRespCallback callback_;
DISALLOW_COPY_AND_ASSIGN(FuzzInterface_FuzzBasicResp_ForwardToCallback);
};
class FuzzInterface_FuzzBasicSyncResp_HandleSyncResponse
: public mojo::MessageReceiver {
public:
FuzzInterface_FuzzBasicSyncResp_HandleSyncResponse(
bool* result)
: result_(result) {
DCHECK(!*result_);
}
bool Accept(mojo::Message* message) override;
private:
bool* result_;DISALLOW_COPY_AND_ASSIGN(FuzzInterface_FuzzBasicSyncResp_HandleSyncResponse);
};
class FuzzInterface_FuzzBasicSyncResp_ForwardToCallback
: public mojo::MessageReceiver {
public:
FuzzInterface_FuzzBasicSyncResp_ForwardToCallback(
FuzzInterface::FuzzBasicSyncRespCallback callback
) : callback_(std::move(callback)) {
}
bool Accept(mojo::Message* message) override;
private:
FuzzInterface::FuzzBasicSyncRespCallback callback_;
DISALLOW_COPY_AND_ASSIGN(FuzzInterface_FuzzBasicSyncResp_ForwardToCallback);
};
class FuzzInterface_FuzzArgsResp_ForwardToCallback
: public mojo::MessageReceiver {
public:
FuzzInterface_FuzzArgsResp_ForwardToCallback(
FuzzInterface::FuzzArgsRespCallback callback
) : callback_(std::move(callback)) {
}
bool Accept(mojo::Message* message) override;
private:
FuzzInterface::FuzzArgsRespCallback callback_;
DISALLOW_COPY_AND_ASSIGN(FuzzInterface_FuzzArgsResp_ForwardToCallback);
};
class FuzzInterface_FuzzArgsSyncResp_HandleSyncResponse
: public mojo::MessageReceiver {
public:
FuzzInterface_FuzzArgsSyncResp_HandleSyncResponse(
bool* result)
: result_(result) {
DCHECK(!*result_);
}
bool Accept(mojo::Message* message) override;
private:
bool* result_;DISALLOW_COPY_AND_ASSIGN(FuzzInterface_FuzzArgsSyncResp_HandleSyncResponse);
};
class FuzzInterface_FuzzArgsSyncResp_ForwardToCallback
: public mojo::MessageReceiver {
public:
FuzzInterface_FuzzArgsSyncResp_ForwardToCallback(
FuzzInterface::FuzzArgsSyncRespCallback callback
) : callback_(std::move(callback)) {
}
bool Accept(mojo::Message* message) override;
private:
FuzzInterface::FuzzArgsSyncRespCallback callback_;
DISALLOW_COPY_AND_ASSIGN(FuzzInterface_FuzzArgsSyncResp_ForwardToCallback);
};
FuzzInterfaceProxy::FuzzInterfaceProxy(mojo::MessageReceiverWithResponder* receiver)
: receiver_(receiver) {
}
void FuzzInterfaceProxy::FuzzBasic(
) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT0("mojom", "fuzz::mojom::FuzzInterface::FuzzBasic");
#endif
const bool kExpectsResponse = false;
const bool kIsSync = false;
const uint32_t kFlags =
((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
((kIsSync) ? mojo::Message::kFlagIsSync : 0);
mojo::Message message(
internal::kFuzzInterface_FuzzBasic_Name, kFlags, 0, 0, nullptr);
mojo::internal::MessageFragment<
::fuzz::mojom::internal::FuzzInterface_FuzzBasic_Params_Data> params(
message);
params.Allocate();
#if defined(ENABLE_IPC_FUZZER)
message.set_interface_name(FuzzInterface::Name_);
message.set_method_name("FuzzBasic");
#endif
// This return value may be ignored as false implies the Connector has
// encountered an error, which will be visible through other means.
ignore_result(receiver_->Accept(&message));
}
void FuzzInterfaceProxy::FuzzBasicResp(
FuzzBasicRespCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT0("mojom", "fuzz::mojom::FuzzInterface::FuzzBasicResp");
#endif
const bool kExpectsResponse = true;
const bool kIsSync = false;
const uint32_t kFlags =
((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
((kIsSync) ? mojo::Message::kFlagIsSync : 0);
mojo::Message message(
internal::kFuzzInterface_FuzzBasicResp_Name, kFlags, 0, 0, nullptr);
mojo::internal::MessageFragment<
::fuzz::mojom::internal::FuzzInterface_FuzzBasicResp_Params_Data> params(
message);
params.Allocate();
#if defined(ENABLE_IPC_FUZZER)
message.set_interface_name(FuzzInterface::Name_);
message.set_method_name("FuzzBasicResp");
#endif
std::unique_ptr<mojo::MessageReceiver> responder(
new FuzzInterface_FuzzBasicResp_ForwardToCallback(
std::move(callback)));
ignore_result(receiver_->AcceptWithResponder(&message, std::move(responder)));
}
bool FuzzInterfaceProxy::FuzzBasicSyncResp(
) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT_BEGIN0("mojom", "fuzz::mojom::FuzzInterface::FuzzBasicSyncResp");
#endif
const bool kExpectsResponse = true;
const bool kIsSync = true;
const uint32_t kFlags =
((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
((kIsSync) ? mojo::Message::kFlagIsSync : 0);
mojo::Message message(
internal::kFuzzInterface_FuzzBasicSyncResp_Name, kFlags, 0, 0, nullptr);
mojo::internal::MessageFragment<
::fuzz::mojom::internal::FuzzInterface_FuzzBasicSyncResp_Params_Data> params(
message);
params.Allocate();
#if defined(ENABLE_IPC_FUZZER)
message.set_interface_name(FuzzInterface::Name_);
message.set_method_name("FuzzBasicSyncResp");
#endif
bool result = false;
std::unique_ptr<mojo::MessageReceiver> responder(
new FuzzInterface_FuzzBasicSyncResp_HandleSyncResponse(
&result));
ignore_result(receiver_->AcceptWithResponder(&message, std::move(responder)));
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT_END0("mojom", "fuzz::mojom::FuzzInterface::FuzzBasicSyncResp");
#endif
return result;
}
void FuzzInterfaceProxy::FuzzBasicSyncResp(
FuzzBasicSyncRespCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT0("mojom", "fuzz::mojom::FuzzInterface::FuzzBasicSyncResp");
#endif
const bool kExpectsResponse = true;
const bool kIsSync = false;
const uint32_t kFlags =
((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
((kIsSync) ? mojo::Message::kFlagIsSync : 0);
mojo::Message message(
internal::kFuzzInterface_FuzzBasicSyncResp_Name, kFlags, 0, 0, nullptr);
mojo::internal::MessageFragment<
::fuzz::mojom::internal::FuzzInterface_FuzzBasicSyncResp_Params_Data> params(
message);
params.Allocate();
#if defined(ENABLE_IPC_FUZZER)
message.set_interface_name(FuzzInterface::Name_);
message.set_method_name("FuzzBasicSyncResp");
#endif
std::unique_ptr<mojo::MessageReceiver> responder(
new FuzzInterface_FuzzBasicSyncResp_ForwardToCallback(
std::move(callback)));
ignore_result(receiver_->AcceptWithResponder(&message, std::move(responder)));
}
void FuzzInterfaceProxy::FuzzArgs(
FuzzStructPtr in_a, FuzzStructPtr in_b) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1(
"mojom", "fuzz::mojom::FuzzInterface::FuzzArgs", "input_parameters",
[&](perfetto::TracedValue context){
auto dict = std::move(context).WriteDictionary();
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem("a"), in_a,
"<value of type FuzzStructPtr>");
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem("b"), in_b,
"<value of type FuzzStructPtr>");
});
#endif
const bool kExpectsResponse = false;
const bool kIsSync = false;
const uint32_t kFlags =
((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
((kIsSync) ? mojo::Message::kFlagIsSync : 0);
mojo::Message message(
internal::kFuzzInterface_FuzzArgs_Name, kFlags, 0, 0, nullptr);
mojo::internal::MessageFragment<
::fuzz::mojom::internal::FuzzInterface_FuzzArgs_Params_Data> params(
message);
params.Allocate();
mojo::internal::MessageFragment<
typename decltype(params->a)::BaseType> a_fragment(
params.message());
mojo::internal::Serialize<::fuzz::mojom::FuzzStructDataView>(
in_a, a_fragment);
params->a.Set(
a_fragment.is_null() ? nullptr : a_fragment.data());
MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
params->a.is_null(),
mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
"null a in FuzzInterface.FuzzArgs request");
mojo::internal::MessageFragment<
typename decltype(params->b)::BaseType> b_fragment(
params.message());
mojo::internal::Serialize<::fuzz::mojom::FuzzStructDataView>(
in_b, b_fragment);
params->b.Set(
b_fragment.is_null() ? nullptr : b_fragment.data());
#if defined(ENABLE_IPC_FUZZER)
message.set_interface_name(FuzzInterface::Name_);
message.set_method_name("FuzzArgs");
#endif
// This return value may be ignored as false implies the Connector has
// encountered an error, which will be visible through other means.
ignore_result(receiver_->Accept(&message));
}
void FuzzInterfaceProxy::FuzzArgsResp(
FuzzStructPtr in_a, FuzzStructPtr in_b, FuzzArgsRespCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1(
"mojom", "fuzz::mojom::FuzzInterface::FuzzArgsResp", "input_parameters",
[&](perfetto::TracedValue context){
auto dict = std::move(context).WriteDictionary();
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem("a"), in_a,
"<value of type FuzzStructPtr>");
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem("b"), in_b,
"<value of type FuzzStructPtr>");
});
#endif
const bool kExpectsResponse = true;
const bool kIsSync = false;
const uint32_t kFlags =
((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
((kIsSync) ? mojo::Message::kFlagIsSync : 0);
mojo::Message message(
internal::kFuzzInterface_FuzzArgsResp_Name, kFlags, 0, 0, nullptr);
mojo::internal::MessageFragment<
::fuzz::mojom::internal::FuzzInterface_FuzzArgsResp_Params_Data> params(
message);
params.Allocate();
mojo::internal::MessageFragment<
typename decltype(params->a)::BaseType> a_fragment(
params.message());
mojo::internal::Serialize<::fuzz::mojom::FuzzStructDataView>(
in_a, a_fragment);
params->a.Set(
a_fragment.is_null() ? nullptr : a_fragment.data());
MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
params->a.is_null(),
mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
"null a in FuzzInterface.FuzzArgsResp request");
mojo::internal::MessageFragment<
typename decltype(params->b)::BaseType> b_fragment(
params.message());
mojo::internal::Serialize<::fuzz::mojom::FuzzStructDataView>(
in_b, b_fragment);
params->b.Set(
b_fragment.is_null() ? nullptr : b_fragment.data());
#if defined(ENABLE_IPC_FUZZER)
message.set_interface_name(FuzzInterface::Name_);
message.set_method_name("FuzzArgsResp");
#endif
std::unique_ptr<mojo::MessageReceiver> responder(
new FuzzInterface_FuzzArgsResp_ForwardToCallback(
std::move(callback)));
ignore_result(receiver_->AcceptWithResponder(&message, std::move(responder)));
}
bool FuzzInterfaceProxy::FuzzArgsSyncResp(
FuzzStructPtr param_a, FuzzStructPtr param_b) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT_BEGIN1(
"mojom", "fuzz::mojom::FuzzInterface::FuzzArgsSyncResp", "input_parameters",
[&](perfetto::TracedValue context){
auto dict = std::move(context).WriteDictionary();
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem("a"), param_a,
"<value of type FuzzStructPtr>");
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem("b"), param_b,
"<value of type FuzzStructPtr>");
});
#endif
const bool kExpectsResponse = true;
const bool kIsSync = true;
const uint32_t kFlags =
((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
((kIsSync) ? mojo::Message::kFlagIsSync : 0);
mojo::Message message(
internal::kFuzzInterface_FuzzArgsSyncResp_Name, kFlags, 0, 0, nullptr);
mojo::internal::MessageFragment<
::fuzz::mojom::internal::FuzzInterface_FuzzArgsSyncResp_Params_Data> params(
message);
params.Allocate();
mojo::internal::MessageFragment<
typename decltype(params->a)::BaseType> a_fragment(
params.message());
mojo::internal::Serialize<::fuzz::mojom::FuzzStructDataView>(
param_a, a_fragment);
params->a.Set(
a_fragment.is_null() ? nullptr : a_fragment.data());
MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
params->a.is_null(),
mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
"null a in FuzzInterface.FuzzArgsSyncResp request");
mojo::internal::MessageFragment<
typename decltype(params->b)::BaseType> b_fragment(
params.message());
mojo::internal::Serialize<::fuzz::mojom::FuzzStructDataView>(
param_b, b_fragment);
params->b.Set(
b_fragment.is_null() ? nullptr : b_fragment.data());
#if defined(ENABLE_IPC_FUZZER)
message.set_interface_name(FuzzInterface::Name_);
message.set_method_name("FuzzArgsSyncResp");
#endif
bool result = false;
std::unique_ptr<mojo::MessageReceiver> responder(
new FuzzInterface_FuzzArgsSyncResp_HandleSyncResponse(
&result));
ignore_result(receiver_->AcceptWithResponder(&message, std::move(responder)));
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT_END0("mojom", "fuzz::mojom::FuzzInterface::FuzzArgsSyncResp");
#endif
return result;
}
void FuzzInterfaceProxy::FuzzArgsSyncResp(
FuzzStructPtr in_a, FuzzStructPtr in_b, FuzzArgsSyncRespCallback callback) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1(
"mojom", "fuzz::mojom::FuzzInterface::FuzzArgsSyncResp", "input_parameters",
[&](perfetto::TracedValue context){
auto dict = std::move(context).WriteDictionary();
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem("a"), in_a,
"<value of type FuzzStructPtr>");
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem("b"), in_b,
"<value of type FuzzStructPtr>");
});
#endif
const bool kExpectsResponse = true;
const bool kIsSync = false;
const uint32_t kFlags =
((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
((kIsSync) ? mojo::Message::kFlagIsSync : 0);
mojo::Message message(
internal::kFuzzInterface_FuzzArgsSyncResp_Name, kFlags, 0, 0, nullptr);
mojo::internal::MessageFragment<
::fuzz::mojom::internal::FuzzInterface_FuzzArgsSyncResp_Params_Data> params(
message);
params.Allocate();
mojo::internal::MessageFragment<
typename decltype(params->a)::BaseType> a_fragment(
params.message());
mojo::internal::Serialize<::fuzz::mojom::FuzzStructDataView>(
in_a, a_fragment);
params->a.Set(
a_fragment.is_null() ? nullptr : a_fragment.data());
MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
params->a.is_null(),
mojo::internal::VALIDATION_ERROR_UNEXPECTED_NULL_POINTER,
"null a in FuzzInterface.FuzzArgsSyncResp request");
mojo::internal::MessageFragment<
typename decltype(params->b)::BaseType> b_fragment(
params.message());
mojo::internal::Serialize<::fuzz::mojom::FuzzStructDataView>(
in_b, b_fragment);
params->b.Set(
b_fragment.is_null() ? nullptr : b_fragment.data());
#if defined(ENABLE_IPC_FUZZER)
message.set_interface_name(FuzzInterface::Name_);
message.set_method_name("FuzzArgsSyncResp");
#endif
std::unique_ptr<mojo::MessageReceiver> responder(
new FuzzInterface_FuzzArgsSyncResp_ForwardToCallback(
std::move(callback)));
ignore_result(receiver_->AcceptWithResponder(&message, std::move(responder)));
}
void FuzzInterfaceProxy::FuzzAssociated(
::mojo::PendingAssociatedReceiver<FuzzDummyInterface> in_receiver) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1(
"mojom", "fuzz::mojom::FuzzInterface::FuzzAssociated", "input_parameters",
[&](perfetto::TracedValue context){
auto dict = std::move(context).WriteDictionary();
perfetto::WriteIntoTracedValueWithFallback(
dict.AddItem("receiver"), in_receiver,
"<value of type ::mojo::PendingAssociatedReceiver<FuzzDummyInterface>>");
});
#endif
const bool kExpectsResponse = false;
const bool kIsSync = false;
const uint32_t kFlags =
((kExpectsResponse) ? mojo::Message::kFlagExpectsResponse : 0) |
((kIsSync) ? mojo::Message::kFlagIsSync : 0);
mojo::Message message(
internal::kFuzzInterface_FuzzAssociated_Name, kFlags, 0, 0, nullptr);
mojo::internal::MessageFragment<
::fuzz::mojom::internal::FuzzInterface_FuzzAssociated_Params_Data> params(
message);
params.Allocate();
mojo::internal::Serialize<::fuzz::mojom::FuzzDummyInterfaceAssociatedRequestDataView>(
in_receiver, ¶ms->receiver, ¶ms.message());
MOJO_INTERNAL_DLOG_SERIALIZATION_WARNING(
!mojo::internal::IsHandleOrInterfaceValid(params->receiver),
mojo::internal::VALIDATION_ERROR_UNEXPECTED_INVALID_INTERFACE_ID,
"invalid receiver in FuzzInterface.FuzzAssociated request");
#if defined(ENABLE_IPC_FUZZER)
message.set_interface_name(FuzzInterface::Name_);
message.set_method_name("FuzzAssociated");
#endif
// This return value may be ignored as false implies the Connector has
// encountered an error, which will be visible through other means.
ignore_result(receiver_->Accept(&message));
}
class FuzzInterface_FuzzBasicResp_ProxyToResponder {
public:
static FuzzInterface::FuzzBasicRespCallback CreateCallback(
uint64_t request_id,
bool is_sync,
std::unique_ptr<mojo::MessageReceiverWithStatus>* responder) {
std::unique_ptr<FuzzInterface_FuzzBasicResp_ProxyToResponder> proxy(
new FuzzInterface_FuzzBasicResp_ProxyToResponder(
request_id, is_sync, responder));
return base::BindOnce(&FuzzInterface_FuzzBasicResp_ProxyToResponder::Run,
std::move(proxy));
}
~FuzzInterface_FuzzBasicResp_ProxyToResponder() {
#if DCHECK_IS_ON()
if (responder_) {
// If we're being destroyed without being run, we want to ensure the
// binding endpoint has been closed. This checks for that asynchronously.
// We pass a bound generated callback to handle the response so that any
// resulting DCHECK stack will have useful interface type information.
responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
}
#endif
// If the Callback was dropped then deleting the responder will close
// the pipe so the calling application knows to stop waiting for a reply.
responder_ = nullptr;
}
private:
FuzzInterface_FuzzBasicResp_ProxyToResponder(
uint64_t request_id,
bool is_sync,
std::unique_ptr<mojo::MessageReceiverWithStatus>* responder)
: request_id_(request_id),
is_sync_(is_sync),
responder_(std::move(*responder)) {
}
#if DCHECK_IS_ON()
static void OnIsConnectedComplete(bool connected) {
DCHECK(!connected)
<< "FuzzInterface::FuzzBasicRespCallback was destroyed without "
<< "first either being run or its corresponding binding being closed. "
<< "It is an error to drop response callbacks which still correspond "
<< "to an open interface pipe.";
}
#endif
void Run(
);
uint64_t request_id_;
bool is_sync_;
std::unique_ptr<mojo::MessageReceiverWithStatus> responder_;
DISALLOW_COPY_AND_ASSIGN(FuzzInterface_FuzzBasicResp_ProxyToResponder);
};
bool FuzzInterface_FuzzBasicResp_ForwardToCallback::Accept(
mojo::Message* message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1("mojom", "fuzz::mojom::FuzzInterface::FuzzBasicRespCallback",
"message", message->name());
#endif
DCHECK(message->is_serialized());
internal::FuzzInterface_FuzzBasicResp_ResponseParams_Data* params =
reinterpret_cast<
internal::FuzzInterface_FuzzBasicResp_ResponseParams_Data*>(
message->mutable_payload());
bool success = true;
FuzzInterface_FuzzBasicResp_ResponseParamsDataView input_data_view(params, message);
if (!success) {
ReportValidationErrorForMessage(
message,
mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
FuzzInterface::Name_, 1, true);
return false;
}
if (!callback_.is_null())
std::move(callback_).Run();
return true;
}
void FuzzInterface_FuzzBasicResp_ProxyToResponder::Run(
) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT_BEGIN0("mojom", "(Impl)fuzz::mojom::FuzzInterface::FuzzBasicRespCallback");
#endif
const uint32_t kFlags = mojo::Message::kFlagIsResponse |
((is_sync_) ? mojo::Message::kFlagIsSync : 0);
mojo::Message message(
internal::kFuzzInterface_FuzzBasicResp_Name, kFlags, 0, 0, nullptr);
mojo::internal::MessageFragment<
::fuzz::mojom::internal::FuzzInterface_FuzzBasicResp_ResponseParams_Data> params(
message);
params.Allocate();
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT_END1("mojom", "(Impl)fuzz::mojom::FuzzInterface::FuzzBasicRespCallback", "message",
message.name());
#endif
#if defined(ENABLE_IPC_FUZZER)
message.set_interface_name(FuzzInterface::Name_);
message.set_method_name("FuzzBasicResp");
#endif
message.set_request_id(request_id_);
ignore_result(responder_->Accept(&message));
// TODO(darin): Accept() returning false indicates a malformed message, and
// that may be good reason to close the connection. However, we don't have a
// way to do that from here. We should add a way.
responder_ = nullptr;
}
class FuzzInterface_FuzzBasicSyncResp_ProxyToResponder {
public:
static FuzzInterface::FuzzBasicSyncRespCallback CreateCallback(
uint64_t request_id,
bool is_sync,
std::unique_ptr<mojo::MessageReceiverWithStatus>* responder) {
std::unique_ptr<FuzzInterface_FuzzBasicSyncResp_ProxyToResponder> proxy(
new FuzzInterface_FuzzBasicSyncResp_ProxyToResponder(
request_id, is_sync, responder));
return base::BindOnce(&FuzzInterface_FuzzBasicSyncResp_ProxyToResponder::Run,
std::move(proxy));
}
~FuzzInterface_FuzzBasicSyncResp_ProxyToResponder() {
#if DCHECK_IS_ON()
if (responder_) {
// If we're being destroyed without being run, we want to ensure the
// binding endpoint has been closed. This checks for that asynchronously.
// We pass a bound generated callback to handle the response so that any
// resulting DCHECK stack will have useful interface type information.
responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
}
#endif
// If the Callback was dropped then deleting the responder will close
// the pipe so the calling application knows to stop waiting for a reply.
responder_ = nullptr;
}
private:
FuzzInterface_FuzzBasicSyncResp_ProxyToResponder(
uint64_t request_id,
bool is_sync,
std::unique_ptr<mojo::MessageReceiverWithStatus>* responder)
: request_id_(request_id),
is_sync_(is_sync),
responder_(std::move(*responder)) {
}
#if DCHECK_IS_ON()
static void OnIsConnectedComplete(bool connected) {
DCHECK(!connected)
<< "FuzzInterface::FuzzBasicSyncRespCallback was destroyed without "
<< "first either being run or its corresponding binding being closed. "
<< "It is an error to drop response callbacks which still correspond "
<< "to an open interface pipe.";
}
#endif
void Run(
);
uint64_t request_id_;
bool is_sync_;
std::unique_ptr<mojo::MessageReceiverWithStatus> responder_;
DISALLOW_COPY_AND_ASSIGN(FuzzInterface_FuzzBasicSyncResp_ProxyToResponder);
};
bool FuzzInterface_FuzzBasicSyncResp_ForwardToCallback::Accept(
mojo::Message* message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1("mojom", "fuzz::mojom::FuzzInterface::FuzzBasicSyncRespCallback",
"message", message->name());
#endif
DCHECK(message->is_serialized());
internal::FuzzInterface_FuzzBasicSyncResp_ResponseParams_Data* params =
reinterpret_cast<
internal::FuzzInterface_FuzzBasicSyncResp_ResponseParams_Data*>(
message->mutable_payload());
bool success = true;
FuzzInterface_FuzzBasicSyncResp_ResponseParamsDataView input_data_view(params, message);
if (!success) {
ReportValidationErrorForMessage(
message,
mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
FuzzInterface::Name_, 2, true);
return false;
}
if (!callback_.is_null())
std::move(callback_).Run();
return true;
}
void FuzzInterface_FuzzBasicSyncResp_ProxyToResponder::Run(
) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT_BEGIN0("mojom", "(Impl)fuzz::mojom::FuzzInterface::FuzzBasicSyncRespCallback");
#endif
const uint32_t kFlags = mojo::Message::kFlagIsResponse |
((is_sync_) ? mojo::Message::kFlagIsSync : 0);
mojo::Message message(
internal::kFuzzInterface_FuzzBasicSyncResp_Name, kFlags, 0, 0, nullptr);
mojo::internal::MessageFragment<
::fuzz::mojom::internal::FuzzInterface_FuzzBasicSyncResp_ResponseParams_Data> params(
message);
params.Allocate();
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT_END1("mojom", "(Impl)fuzz::mojom::FuzzInterface::FuzzBasicSyncRespCallback", "message",
message.name());
#endif
#if defined(ENABLE_IPC_FUZZER)
message.set_interface_name(FuzzInterface::Name_);
message.set_method_name("FuzzBasicSyncResp");
#endif
message.set_request_id(request_id_);
ignore_result(responder_->Accept(&message));
// TODO(darin): Accept() returning false indicates a malformed message, and
// that may be good reason to close the connection. However, we don't have a
// way to do that from here. We should add a way.
responder_ = nullptr;
}
bool FuzzInterface_FuzzBasicSyncResp_HandleSyncResponse::Accept(
mojo::Message* message) {
DCHECK(message->is_serialized());
internal::FuzzInterface_FuzzBasicSyncResp_ResponseParams_Data* params =
reinterpret_cast<internal::FuzzInterface_FuzzBasicSyncResp_ResponseParams_Data*>(
message->mutable_payload());
bool success = true;
FuzzInterface_FuzzBasicSyncResp_ResponseParamsDataView input_data_view(params, message);
if (!success) {
ReportValidationErrorForMessage(
message,
mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
FuzzInterface::Name_, 2, true);
return false;
}
mojo::internal::SyncMessageResponseSetup::SetCurrentSyncResponseMessage(
message);
*result_ = true;
return true;
}
class FuzzInterface_FuzzArgsResp_ProxyToResponder {
public:
static FuzzInterface::FuzzArgsRespCallback CreateCallback(
uint64_t request_id,
bool is_sync,
std::unique_ptr<mojo::MessageReceiverWithStatus>* responder) {
std::unique_ptr<FuzzInterface_FuzzArgsResp_ProxyToResponder> proxy(
new FuzzInterface_FuzzArgsResp_ProxyToResponder(
request_id, is_sync, responder));
return base::BindOnce(&FuzzInterface_FuzzArgsResp_ProxyToResponder::Run,
std::move(proxy));
}
~FuzzInterface_FuzzArgsResp_ProxyToResponder() {
#if DCHECK_IS_ON()
if (responder_) {
// If we're being destroyed without being run, we want to ensure the
// binding endpoint has been closed. This checks for that asynchronously.
// We pass a bound generated callback to handle the response so that any
// resulting DCHECK stack will have useful interface type information.
responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
}
#endif
// If the Callback was dropped then deleting the responder will close
// the pipe so the calling application knows to stop waiting for a reply.
responder_ = nullptr;
}
private:
FuzzInterface_FuzzArgsResp_ProxyToResponder(
uint64_t request_id,
bool is_sync,
std::unique_ptr<mojo::MessageReceiverWithStatus>* responder)
: request_id_(request_id),
is_sync_(is_sync),
responder_(std::move(*responder)) {
}
#if DCHECK_IS_ON()
static void OnIsConnectedComplete(bool connected) {
DCHECK(!connected)
<< "FuzzInterface::FuzzArgsRespCallback was destroyed without "
<< "first either being run or its corresponding binding being closed. "
<< "It is an error to drop response callbacks which still correspond "
<< "to an open interface pipe.";
}
#endif
void Run(
);
uint64_t request_id_;
bool is_sync_;
std::unique_ptr<mojo::MessageReceiverWithStatus> responder_;
DISALLOW_COPY_AND_ASSIGN(FuzzInterface_FuzzArgsResp_ProxyToResponder);
};
bool FuzzInterface_FuzzArgsResp_ForwardToCallback::Accept(
mojo::Message* message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1("mojom", "fuzz::mojom::FuzzInterface::FuzzArgsRespCallback",
"message", message->name());
#endif
DCHECK(message->is_serialized());
internal::FuzzInterface_FuzzArgsResp_ResponseParams_Data* params =
reinterpret_cast<
internal::FuzzInterface_FuzzArgsResp_ResponseParams_Data*>(
message->mutable_payload());
bool success = true;
FuzzInterface_FuzzArgsResp_ResponseParamsDataView input_data_view(params, message);
if (!success) {
ReportValidationErrorForMessage(
message,
mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
FuzzInterface::Name_, 4, true);
return false;
}
if (!callback_.is_null())
std::move(callback_).Run();
return true;
}
void FuzzInterface_FuzzArgsResp_ProxyToResponder::Run(
) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT_BEGIN0("mojom", "(Impl)fuzz::mojom::FuzzInterface::FuzzArgsRespCallback");
#endif
const uint32_t kFlags = mojo::Message::kFlagIsResponse |
((is_sync_) ? mojo::Message::kFlagIsSync : 0);
mojo::Message message(
internal::kFuzzInterface_FuzzArgsResp_Name, kFlags, 0, 0, nullptr);
mojo::internal::MessageFragment<
::fuzz::mojom::internal::FuzzInterface_FuzzArgsResp_ResponseParams_Data> params(
message);
params.Allocate();
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT_END1("mojom", "(Impl)fuzz::mojom::FuzzInterface::FuzzArgsRespCallback", "message",
message.name());
#endif
#if defined(ENABLE_IPC_FUZZER)
message.set_interface_name(FuzzInterface::Name_);
message.set_method_name("FuzzArgsResp");
#endif
message.set_request_id(request_id_);
ignore_result(responder_->Accept(&message));
// TODO(darin): Accept() returning false indicates a malformed message, and
// that may be good reason to close the connection. However, we don't have a
// way to do that from here. We should add a way.
responder_ = nullptr;
}
class FuzzInterface_FuzzArgsSyncResp_ProxyToResponder {
public:
static FuzzInterface::FuzzArgsSyncRespCallback CreateCallback(
uint64_t request_id,
bool is_sync,
std::unique_ptr<mojo::MessageReceiverWithStatus>* responder) {
std::unique_ptr<FuzzInterface_FuzzArgsSyncResp_ProxyToResponder> proxy(
new FuzzInterface_FuzzArgsSyncResp_ProxyToResponder(
request_id, is_sync, responder));
return base::BindOnce(&FuzzInterface_FuzzArgsSyncResp_ProxyToResponder::Run,
std::move(proxy));
}
~FuzzInterface_FuzzArgsSyncResp_ProxyToResponder() {
#if DCHECK_IS_ON()
if (responder_) {
// If we're being destroyed without being run, we want to ensure the
// binding endpoint has been closed. This checks for that asynchronously.
// We pass a bound generated callback to handle the response so that any
// resulting DCHECK stack will have useful interface type information.
responder_->IsConnectedAsync(base::BindOnce(&OnIsConnectedComplete));
}
#endif
// If the Callback was dropped then deleting the responder will close
// the pipe so the calling application knows to stop waiting for a reply.
responder_ = nullptr;
}
private:
FuzzInterface_FuzzArgsSyncResp_ProxyToResponder(
uint64_t request_id,
bool is_sync,
std::unique_ptr<mojo::MessageReceiverWithStatus>* responder)
: request_id_(request_id),
is_sync_(is_sync),
responder_(std::move(*responder)) {
}
#if DCHECK_IS_ON()
static void OnIsConnectedComplete(bool connected) {
DCHECK(!connected)
<< "FuzzInterface::FuzzArgsSyncRespCallback was destroyed without "
<< "first either being run or its corresponding binding being closed. "
<< "It is an error to drop response callbacks which still correspond "
<< "to an open interface pipe.";
}
#endif
void Run(
);
uint64_t request_id_;
bool is_sync_;
std::unique_ptr<mojo::MessageReceiverWithStatus> responder_;
DISALLOW_COPY_AND_ASSIGN(FuzzInterface_FuzzArgsSyncResp_ProxyToResponder);
};
bool FuzzInterface_FuzzArgsSyncResp_ForwardToCallback::Accept(
mojo::Message* message) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1("mojom", "fuzz::mojom::FuzzInterface::FuzzArgsSyncRespCallback",
"message", message->name());
#endif
DCHECK(message->is_serialized());
internal::FuzzInterface_FuzzArgsSyncResp_ResponseParams_Data* params =
reinterpret_cast<
internal::FuzzInterface_FuzzArgsSyncResp_ResponseParams_Data*>(
message->mutable_payload());
bool success = true;
FuzzInterface_FuzzArgsSyncResp_ResponseParamsDataView input_data_view(params, message);
if (!success) {
ReportValidationErrorForMessage(
message,
mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
FuzzInterface::Name_, 5, true);
return false;
}
if (!callback_.is_null())
std::move(callback_).Run();
return true;
}
void FuzzInterface_FuzzArgsSyncResp_ProxyToResponder::Run(
) {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT_BEGIN0("mojom", "(Impl)fuzz::mojom::FuzzInterface::FuzzArgsSyncRespCallback");
#endif
const uint32_t kFlags = mojo::Message::kFlagIsResponse |
((is_sync_) ? mojo::Message::kFlagIsSync : 0);
mojo::Message message(
internal::kFuzzInterface_FuzzArgsSyncResp_Name, kFlags, 0, 0, nullptr);
mojo::internal::MessageFragment<
::fuzz::mojom::internal::FuzzInterface_FuzzArgsSyncResp_ResponseParams_Data> params(
message);
params.Allocate();
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT_END1("mojom", "(Impl)fuzz::mojom::FuzzInterface::FuzzArgsSyncRespCallback", "message",
message.name());
#endif
#if defined(ENABLE_IPC_FUZZER)
message.set_interface_name(FuzzInterface::Name_);
message.set_method_name("FuzzArgsSyncResp");
#endif
message.set_request_id(request_id_);
ignore_result(responder_->Accept(&message));
// TODO(darin): Accept() returning false indicates a malformed message, and
// that may be good reason to close the connection. However, we don't have a
// way to do that from here. We should add a way.
responder_ = nullptr;
}
bool FuzzInterface_FuzzArgsSyncResp_HandleSyncResponse::Accept(
mojo::Message* message) {
DCHECK(message->is_serialized());
internal::FuzzInterface_FuzzArgsSyncResp_ResponseParams_Data* params =
reinterpret_cast<internal::FuzzInterface_FuzzArgsSyncResp_ResponseParams_Data*>(
message->mutable_payload());
bool success = true;
FuzzInterface_FuzzArgsSyncResp_ResponseParamsDataView input_data_view(params, message);
if (!success) {
ReportValidationErrorForMessage(
message,
mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
FuzzInterface::Name_, 5, true);
return false;
}
mojo::internal::SyncMessageResponseSetup::SetCurrentSyncResponseMessage(
message);
*result_ = true;
return true;
}
// static
bool FuzzInterfaceStubDispatch::Accept(
FuzzInterface* impl,
mojo::Message* message) {
switch (message->header()->name) {
case internal::kFuzzInterface_FuzzBasic_Name: {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1(
"mojom",
"(Impl)fuzz::mojom::FuzzInterface::FuzzBasic",
"message", message->name());
#endif
static constexpr uint32_t kMessageHash = base::MD5Hash32Constexpr(
"(Impl)fuzz::mojom::FuzzInterface::FuzzBasic");
base::TaskAnnotator::ScopedSetIpcHash scoped_ipc_hash(kMessageHash);
DCHECK(message->is_serialized());
internal::FuzzInterface_FuzzBasic_Params_Data* params =
reinterpret_cast<internal::FuzzInterface_FuzzBasic_Params_Data*>(
message->mutable_payload());
bool success = true;
FuzzInterface_FuzzBasic_ParamsDataView input_data_view(params, message);
if (!success) {
ReportValidationErrorForMessage(
message,
mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
FuzzInterface::Name_, 0, false);
return false;
}
// A null |impl| means no implementation was bound.
DCHECK(impl);
impl->FuzzBasic();
return true;
}
case internal::kFuzzInterface_FuzzBasicResp_Name: {
break;
}
case internal::kFuzzInterface_FuzzBasicSyncResp_Name: {
break;
}
case internal::kFuzzInterface_FuzzArgs_Name: {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1(
"mojom",
"(Impl)fuzz::mojom::FuzzInterface::FuzzArgs",
"message", message->name());
#endif
static constexpr uint32_t kMessageHash = base::MD5Hash32Constexpr(
"(Impl)fuzz::mojom::FuzzInterface::FuzzArgs");
base::TaskAnnotator::ScopedSetIpcHash scoped_ipc_hash(kMessageHash);
DCHECK(message->is_serialized());
internal::FuzzInterface_FuzzArgs_Params_Data* params =
reinterpret_cast<internal::FuzzInterface_FuzzArgs_Params_Data*>(
message->mutable_payload());
bool success = true;
FuzzStructPtr p_a{};
FuzzStructPtr p_b{};
FuzzInterface_FuzzArgs_ParamsDataView input_data_view(params, message);
if (success && !input_data_view.ReadA(&p_a))
success = false;
if (success && !input_data_view.ReadB(&p_b))
success = false;
if (!success) {
ReportValidationErrorForMessage(
message,
mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
FuzzInterface::Name_, 3, false);
return false;
}
// A null |impl| means no implementation was bound.
DCHECK(impl);
impl->FuzzArgs(
std::move(p_a),
std::move(p_b));
return true;
}
case internal::kFuzzInterface_FuzzArgsResp_Name: {
break;
}
case internal::kFuzzInterface_FuzzArgsSyncResp_Name: {
break;
}
case internal::kFuzzInterface_FuzzAssociated_Name: {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1(
"mojom",
"(Impl)fuzz::mojom::FuzzInterface::FuzzAssociated",
"message", message->name());
#endif
static constexpr uint32_t kMessageHash = base::MD5Hash32Constexpr(
"(Impl)fuzz::mojom::FuzzInterface::FuzzAssociated");
base::TaskAnnotator::ScopedSetIpcHash scoped_ipc_hash(kMessageHash);
DCHECK(message->is_serialized());
internal::FuzzInterface_FuzzAssociated_Params_Data* params =
reinterpret_cast<internal::FuzzInterface_FuzzAssociated_Params_Data*>(
message->mutable_payload());
bool success = true;
::mojo::PendingAssociatedReceiver<FuzzDummyInterface> p_receiver{};
FuzzInterface_FuzzAssociated_ParamsDataView input_data_view(params, message);
if (success) {
p_receiver =
input_data_view.TakeReceiver<decltype(p_receiver)>();
}
if (!success) {
ReportValidationErrorForMessage(
message,
mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
FuzzInterface::Name_, 6, false);
return false;
}
// A null |impl| means no implementation was bound.
DCHECK(impl);
impl->FuzzAssociated(
std::move(p_receiver));
return true;
}
}
return false;
}
// static
bool FuzzInterfaceStubDispatch::AcceptWithResponder(
FuzzInterface* impl,
mojo::Message* message,
std::unique_ptr<mojo::MessageReceiverWithStatus> responder) {
const bool message_is_sync = message->has_flag(mojo::Message::kFlagIsSync);
const uint64_t request_id = message->request_id();
ALLOW_UNUSED_LOCAL(message_is_sync);
ALLOW_UNUSED_LOCAL(request_id);
switch (message->header()->name) {
case internal::kFuzzInterface_FuzzBasic_Name: {
break;
}
case internal::kFuzzInterface_FuzzBasicResp_Name: {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1(
"mojom",
"(Impl)fuzz::mojom::FuzzInterface::FuzzBasicResp",
"message", message->name());
#endif
static constexpr uint32_t kMessageHash = base::MD5Hash32Constexpr(
"(Impl)fuzz::mojom::FuzzInterface::FuzzBasicResp");
base::TaskAnnotator::ScopedSetIpcHash scoped_ipc_hash(kMessageHash);
internal::FuzzInterface_FuzzBasicResp_Params_Data* params =
reinterpret_cast<
internal::FuzzInterface_FuzzBasicResp_Params_Data*>(
message->mutable_payload());
bool success = true;
FuzzInterface_FuzzBasicResp_ParamsDataView input_data_view(params, message);
if (!success) {
ReportValidationErrorForMessage(
message,
mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
FuzzInterface::Name_, 1, false);
return false;
}
FuzzInterface::FuzzBasicRespCallback callback =
FuzzInterface_FuzzBasicResp_ProxyToResponder::CreateCallback(
message->request_id(), message_is_sync, &responder);
// A null |impl| means no implementation was bound.
DCHECK(impl);
impl->FuzzBasicResp(std::move(callback));
return true;
}
case internal::kFuzzInterface_FuzzBasicSyncResp_Name: {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1(
"mojom",
"(Impl)fuzz::mojom::FuzzInterface::FuzzBasicSyncResp",
"message", message->name());
#endif
static constexpr uint32_t kMessageHash = base::MD5Hash32Constexpr(
"(Impl)fuzz::mojom::FuzzInterface::FuzzBasicSyncResp");
base::TaskAnnotator::ScopedSetIpcHash scoped_ipc_hash(kMessageHash);
internal::FuzzInterface_FuzzBasicSyncResp_Params_Data* params =
reinterpret_cast<
internal::FuzzInterface_FuzzBasicSyncResp_Params_Data*>(
message->mutable_payload());
bool success = true;
FuzzInterface_FuzzBasicSyncResp_ParamsDataView input_data_view(params, message);
if (!success) {
ReportValidationErrorForMessage(
message,
mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
FuzzInterface::Name_, 2, false);
return false;
}
FuzzInterface::FuzzBasicSyncRespCallback callback =
FuzzInterface_FuzzBasicSyncResp_ProxyToResponder::CreateCallback(
message->request_id(), message_is_sync, &responder);
// A null |impl| means no implementation was bound.
DCHECK(impl);
impl->FuzzBasicSyncResp(std::move(callback));
return true;
}
case internal::kFuzzInterface_FuzzArgs_Name: {
break;
}
case internal::kFuzzInterface_FuzzArgsResp_Name: {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1(
"mojom",
"(Impl)fuzz::mojom::FuzzInterface::FuzzArgsResp",
"message", message->name());
#endif
static constexpr uint32_t kMessageHash = base::MD5Hash32Constexpr(
"(Impl)fuzz::mojom::FuzzInterface::FuzzArgsResp");
base::TaskAnnotator::ScopedSetIpcHash scoped_ipc_hash(kMessageHash);
internal::FuzzInterface_FuzzArgsResp_Params_Data* params =
reinterpret_cast<
internal::FuzzInterface_FuzzArgsResp_Params_Data*>(
message->mutable_payload());
bool success = true;
FuzzStructPtr p_a{};
FuzzStructPtr p_b{};
FuzzInterface_FuzzArgsResp_ParamsDataView input_data_view(params, message);
if (success && !input_data_view.ReadA(&p_a))
success = false;
if (success && !input_data_view.ReadB(&p_b))
success = false;
if (!success) {
ReportValidationErrorForMessage(
message,
mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
FuzzInterface::Name_, 4, false);
return false;
}
FuzzInterface::FuzzArgsRespCallback callback =
FuzzInterface_FuzzArgsResp_ProxyToResponder::CreateCallback(
message->request_id(), message_is_sync, &responder);
// A null |impl| means no implementation was bound.
DCHECK(impl);
impl->FuzzArgsResp(
std::move(p_a),
std::move(p_b), std::move(callback));
return true;
}
case internal::kFuzzInterface_FuzzArgsSyncResp_Name: {
#if BUILDFLAG(MOJO_TRACE_ENABLED)
TRACE_EVENT1(
"mojom",
"(Impl)fuzz::mojom::FuzzInterface::FuzzArgsSyncResp",
"message", message->name());
#endif
static constexpr uint32_t kMessageHash = base::MD5Hash32Constexpr(
"(Impl)fuzz::mojom::FuzzInterface::FuzzArgsSyncResp");
base::TaskAnnotator::ScopedSetIpcHash scoped_ipc_hash(kMessageHash);
internal::FuzzInterface_FuzzArgsSyncResp_Params_Data* params =
reinterpret_cast<
internal::FuzzInterface_FuzzArgsSyncResp_Params_Data*>(
message->mutable_payload());
bool success = true;
FuzzStructPtr p_a{};
FuzzStructPtr p_b{};
FuzzInterface_FuzzArgsSyncResp_ParamsDataView input_data_view(params, message);
if (success && !input_data_view.ReadA(&p_a))
success = false;
if (success && !input_data_view.ReadB(&p_b))
success = false;
if (!success) {
ReportValidationErrorForMessage(
message,
mojo::internal::VALIDATION_ERROR_DESERIALIZATION_FAILED,
FuzzInterface::Name_, 5, false);
return false;
}
FuzzInterface::FuzzArgsSyncRespCallback callback =
FuzzInterface_FuzzArgsSyncResp_ProxyToResponder::CreateCallback(
message->request_id(), message_is_sync, &responder);
// A null |impl| means no implementation was bound.
DCHECK(impl);
impl->FuzzArgsSyncResp(
std::move(p_a),
std::move(p_b), std::move(callback));
return true;
}
case internal::kFuzzInterface_FuzzAssociated_Name: {
break;
}
}
return false;
}
static const std::pair<uint32_t, mojo::internal::GenericValidationInfo> kFuzzInterfaceValidationInfo[] = {
{internal::kFuzzInterface_FuzzBasic_Name,
{&internal::FuzzInterface_FuzzBasic_Params_Data::Validate,
nullptr /* no response */}},
{internal::kFuzzInterface_FuzzBasicResp_Name,
{&internal::FuzzInterface_FuzzBasicResp_Params_Data::Validate,
&internal::FuzzInterface_FuzzBasicResp_ResponseParams_Data::Validate}},
{internal::kFuzzInterface_FuzzBasicSyncResp_Name,
{&internal::FuzzInterface_FuzzBasicSyncResp_Params_Data::Validate,
&internal::FuzzInterface_FuzzBasicSyncResp_ResponseParams_Data::Validate}},
{internal::kFuzzInterface_FuzzArgs_Name,
{&internal::FuzzInterface_FuzzArgs_Params_Data::Validate,
nullptr /* no response */}},
{internal::kFuzzInterface_FuzzArgsResp_Name,
{&internal::FuzzInterface_FuzzArgsResp_Params_Data::Validate,
&internal::FuzzInterface_FuzzArgsResp_ResponseParams_Data::Validate}},
{internal::kFuzzInterface_FuzzArgsSyncResp_Name,
{&internal::FuzzInterface_FuzzArgsSyncResp_Params_Data::Validate,
&internal::FuzzInterface_FuzzArgsSyncResp_ResponseParams_Data::Validate}},
{internal::kFuzzInterface_FuzzAssociated_Name,
{&internal::FuzzInterface_FuzzAssociated_Params_Data::Validate,
nullptr /* no response */}},
};
bool FuzzInterfaceRequestValidator::Accept(mojo::Message* message) {
const char* name = ::fuzz::mojom::FuzzInterface::Name_;
return mojo::internal::ValidateRequestGeneric(message, name, kFuzzInterfaceValidationInfo);
}
bool FuzzInterfaceResponseValidator::Accept(mojo::Message* message) {
const char* name = ::fuzz::mojom::FuzzInterface::Name_;
return mojo::internal::ValidateResponseGeneric(message, name, kFuzzInterfaceValidationInfo);
}
} // namespace mojom
} // namespace fuzz
namespace mojo {
// static
bool StructTraits<::fuzz::mojom::FuzzDummyStruct::DataView, ::fuzz::mojom::FuzzDummyStructPtr>::Read(
::fuzz::mojom::FuzzDummyStruct::DataView input,
::fuzz::mojom::FuzzDummyStructPtr* output) {
bool success = true;
::fuzz::mojom::FuzzDummyStructPtr result(::fuzz::mojom::FuzzDummyStruct::New());
if (success)
result->dummy = input.dummy();
*output = std::move(result);
return success;
}
// static
bool StructTraits<::fuzz::mojom::FuzzStruct::DataView, ::fuzz::mojom::FuzzStructPtr>::Read(
::fuzz::mojom::FuzzStruct::DataView input,
::fuzz::mojom::FuzzStructPtr* output) {
bool success = true;
::fuzz::mojom::FuzzStructPtr result(::fuzz::mojom::FuzzStruct::New());
if (success)
result->fuzz_bool = input.fuzz_bool();
if (success)
result->fuzz_int8 = input.fuzz_int8();
if (success)
result->fuzz_uint8 = input.fuzz_uint8();
if (success)
result->fuzz_int16 = input.fuzz_int16();
if (success)
result->fuzz_uint16 = input.fuzz_uint16();
if (success)
result->fuzz_int32 = input.fuzz_int32();
if (success)
result->fuzz_uint32 = input.fuzz_uint32();
if (success)
result->fuzz_int64 = input.fuzz_int64();
if (success)
result->fuzz_uint64 = input.fuzz_uint64();
if (success)
result->fuzz_float = input.fuzz_float();
if (success)
result->fuzz_double = input.fuzz_double();
if (success && !input.ReadFuzzString(&result->fuzz_string))
success = false;
if (success && !input.ReadFuzzBoolArray(&result->fuzz_bool_array))
success = false;
if (success && !input.ReadFuzzPrimitiveArray(&result->fuzz_primitive_array))
success = false;
if (success && !input.ReadFuzzPrimitiveMap(&result->fuzz_primitive_map))
success = false;
if (success && !input.ReadFuzzArrayMap(&result->fuzz_array_map))
success = false;
if (success && !input.ReadFuzzUnionMap(&result->fuzz_union_map))
success = false;
if (success && !input.ReadFuzzUnionArray(&result->fuzz_union_array))
success = false;
if (success && !input.ReadFuzzStructArray(&result->fuzz_struct_array))
success = false;
if (success && !input.ReadFuzzNullableArray(&result->fuzz_nullable_array))
success = false;
if (success && !input.ReadFuzzComplex(&result->fuzz_complex))
success = false;
*output = std::move(result);
return success;
}
// static
bool UnionTraits<::fuzz::mojom::FuzzUnion::DataView, ::fuzz::mojom::FuzzUnionPtr>::Read(
::fuzz::mojom::FuzzUnion::DataView input,
::fuzz::mojom::FuzzUnionPtr* output) {
using UnionType = ::fuzz::mojom::FuzzUnion;
using Tag = UnionType::Tag;
switch (input.tag()) {
case Tag::FUZZ_BOOL: {
*output = UnionType::NewFuzzBool(input.fuzz_bool());
break;
}
case Tag::FUZZ_INT8: {
*output = UnionType::NewFuzzInt8(input.fuzz_int8());
break;
}
case Tag::FUZZ_UINT8: {
*output = UnionType::NewFuzzUint8(input.fuzz_uint8());
break;
}
case Tag::FUZZ_INT16: {
*output = UnionType::NewFuzzInt16(input.fuzz_int16());
break;
}
case Tag::FUZZ_UINT16: {
*output = UnionType::NewFuzzUint16(input.fuzz_uint16());
break;
}
case Tag::FUZZ_INT32: {
*output = UnionType::NewFuzzInt32(input.fuzz_int32());
break;
}
case Tag::FUZZ_UINT32: {
*output = UnionType::NewFuzzUint32(input.fuzz_uint32());
break;
}
case Tag::FUZZ_INT64: {
*output = UnionType::NewFuzzInt64(input.fuzz_int64());
break;
}
case Tag::FUZZ_UINT64: {
*output = UnionType::NewFuzzUint64(input.fuzz_uint64());
break;
}
case Tag::FUZZ_FLOAT: {
*output = UnionType::NewFuzzFloat(input.fuzz_float());
break;
}
case Tag::FUZZ_DOUBLE: {
*output = UnionType::NewFuzzDouble(input.fuzz_double());
break;
}
case Tag::FUZZ_STRING: {
std::string result_fuzz_string;
if (!input.ReadFuzzString(&result_fuzz_string))
return false;
*output = UnionType::NewFuzzString(
std::move(result_fuzz_string));
break;
}
case Tag::FUZZ_BOOL_ARRAY: {
std::vector<bool> result_fuzz_bool_array;
if (!input.ReadFuzzBoolArray(&result_fuzz_bool_array))
return false;
*output = UnionType::NewFuzzBoolArray(
std::move(result_fuzz_bool_array));
break;
}
case Tag::FUZZ_PRIMITIVE_ARRAY: {
std::vector<int8_t> result_fuzz_primitive_array;
if (!input.ReadFuzzPrimitiveArray(&result_fuzz_primitive_array))
return false;
*output = UnionType::NewFuzzPrimitiveArray(
std::move(result_fuzz_primitive_array));
break;
}
case Tag::FUZZ_STRUCT_ARRAY: {
std::vector<::fuzz::mojom::FuzzDummyStructPtr> result_fuzz_struct_array;
if (!input.ReadFuzzStructArray(&result_fuzz_struct_array))
return false;
*output = UnionType::NewFuzzStructArray(
std::move(result_fuzz_struct_array));
break;
}
case Tag::FUZZ_PRIMITIVE_MAP: {
base::flat_map<std::string, int8_t> result_fuzz_primitive_map;
if (!input.ReadFuzzPrimitiveMap(&result_fuzz_primitive_map))
return false;
*output = UnionType::NewFuzzPrimitiveMap(
std::move(result_fuzz_primitive_map));
break;
}
case Tag::FUZZ_ARRAY_MAP: {
base::flat_map<std::string, std::vector<std::string>> result_fuzz_array_map;
if (!input.ReadFuzzArrayMap(&result_fuzz_array_map))
return false;
*output = UnionType::NewFuzzArrayMap(
std::move(result_fuzz_array_map));
break;
}
case Tag::FUZZ_STRUCT_MAP: {
base::flat_map<std::string, ::fuzz::mojom::FuzzDummyStructPtr> result_fuzz_struct_map;
if (!input.ReadFuzzStructMap(&result_fuzz_struct_map))
return false;
*output = UnionType::NewFuzzStructMap(
std::move(result_fuzz_struct_map));
break;
}
case Tag::FUZZ_UNION_MAP: {
base::flat_map<::fuzz::mojom::FuzzEnum, ::fuzz::mojom::FuzzUnionPtr> result_fuzz_union_map;
if (!input.ReadFuzzUnionMap(&result_fuzz_union_map))
return false;
*output = UnionType::NewFuzzUnionMap(
std::move(result_fuzz_union_map));
break;
}
case Tag::FUZZ_COMPLEX: {
base::Optional<std::vector<base::flat_map<::fuzz::mojom::FuzzEnum, base::flat_map<int8_t, base::Optional<std::vector<::fuzz::mojom::FuzzUnionPtr>>>>>> result_fuzz_complex;
if (!input.ReadFuzzComplex(&result_fuzz_complex))
return false;
*output = UnionType::NewFuzzComplex(
std::move(result_fuzz_complex));
break;
}
default:
return false;
}
return true;
}
} // namespace mojo
#if defined(__clang__)
#pragma clang diagnostic pop
#endif | [
"user@email.ru"
] | user@email.ru |
361abf9b1573338203e6eabf873f8e7ada3eedc0 | 051b773a44602b683cf3eebf95334659f698e388 | /src/CLogo.h | 66f88bc0bf2da6af6369832c94a03a9b62241dff | [] | no_license | sergei-svistunov/YandexFotkiSaver | e686fb2bc153e536d822fe7741ce0f9ff503a54c | 5dabfb92a1441efea1751e0c810aa35c0e0fa299 | refs/heads/master | 2020-05-09T17:38:03.091840 | 2011-09-19T11:15:35 | 2011-09-19T11:15:35 | 2,410,353 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 276 | h | /*
* CLogo.h
*
* Created on: 21.09.2009
* Author: svistunov
*/
#ifndef CLOGO_H_
#define CLOGO_H_
#include "global.h"
class CLogo {
public:
CLogo();
virtual ~CLogo();
void Draw(void);
private:
void PrintData(void);
GLuint _Texture;
};
#endif /* CLOGO_H_ */
| [
"sergei-svistunov@yandex.ru"
] | sergei-svistunov@yandex.ru |
ecf453648de50f0249f3666824b63234273d3519 | 81c0edd1283331f9585bb229eeb03ec67d09704d | /libraries/audio/codecs/mpadec_codec.cpp | 00482a1f5155bd9171a7b94e16a3bb867cf9c0d0 | [] | no_license | ronj/invent | d2f503d919653dd1c058d7f06629a2bc6106376e | cd4ccc15384e9a35a713d64acf9aa8859e5c0256 | refs/heads/master | 2021-01-15T16:56:35.291700 | 2014-12-14T14:24:51 | 2014-12-14T14:24:51 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,316 | cpp | #include "mpadec_codec.h"
#include "mpadec_info.h"
#include "data-access/data_access.h"
#include <mp3dec.h>
namespace virtual_io {
size_t read(unsigned char* aData, std::size_t aSize, void* aUserData)
{
IDataAccess* io = static_cast<IDataAccess*>(aUserData);
return io->read(aData, aSize);
}
size_t seek(size_t aOffset, int aWhence, void* aUserData)
{
IDataAccess* io = static_cast<IDataAccess*>(aUserData);
if (!io->seekable())
return -1;
switch (aWhence) {
case SEEK_SET:
// offset remains unchanged
break;
case SEEK_CUR:
aOffset += io->offset();
break;
case SEEK_END:
//aOffset += io->length();
break;
}
return io->seek(aOffset);
}
void close(void* aUserData)
{
IDataAccess* io = static_cast<IDataAccess*>(aUserData);
io->close();
}
} // !namespace virtual_io
class MPADECCodec::Impl
{
public:
Impl(std::unique_ptr<IDataAccess> aDataAccess)
: iDecoder(mp3dec_init())
, iDataAccess(std::move(aDataAccess))
{
if (!iDecoder)
{
throw std::bad_alloc();
}
iDataAccess->open();
iConfig = { MPADEC_CONFIG_FULL_QUALITY, MPADEC_CONFIG_AUTO,
MPADEC_CONFIG_FLOAT, MPADEC_CONFIG_LITTLE_ENDIAN,
MPADEC_CONFIG_REPLAYGAIN_NONE, TRUE, TRUE, TRUE, 0.0 };
mp3dec_virtual_io_t vio = { virtual_io::read, virtual_io::seek, virtual_io::close };
apiWrapper(mp3dec_configure, iDecoder, &iConfig);
apiWrapper(mp3dec_init_file, iDecoder, 0, FALSE, vio, iDataAccess.get());
apiWrapper(mp3dec_get_info, iDecoder, iInfo.nativeHandle(), MPADEC_INFO_STREAM);
}
~Impl()
{
cleanup();
}
std::size_t decode(float* aSamples, std::size_t aSampleCount) const
{
unsigned int bufferUsedSize = 0;
mp3dec_decode(iDecoder,
reinterpret_cast<uint8_t*>(aSamples),
aSampleCount * sizeof(float),
&bufferUsedSize);
return bufferUsedSize / sizeof(float);
}
std::size_t encode(const float*, std::size_t) const
{
throw std::logic_error("Not implemented");
}
const IAudioInfo& info() const
{
return iInfo;
}
private:
template <typename Method, typename... Args>
void apiWrapper(Method&& method, Args... arguments)
{
int returnValue = MP3DEC_RETCODE_OK;
if ((returnValue = method(arguments...)) != MP3DEC_RETCODE_OK)
{
cleanup();
if (returnValue == MP3DEC_RETCODE_NOT_MPEG_STREAM)
{
throw FormatNotSupportedException();
}
throw std::logic_error(mp3dec_error(returnValue));
}
}
void cleanup()
{
if (iDecoder)
{
mp3dec_uninit(iDecoder);
}
}
private:
mp3dec_t iDecoder = nullptr;
mpadec_config_t iConfig;
MPADECInfo iInfo;
std::unique_ptr<IDataAccess> iDataAccess;
};
MPADECCodec::MPADECCodec(std::unique_ptr<IDataAccess> aDataAccess)
: iImpl(new Impl(std::move(aDataAccess)))
{
}
MPADECCodec::~MPADECCodec()
{
}
std::size_t MPADECCodec::decode(float* aSamples, std::size_t aSampleCount) const
{
return iImpl->decode(aSamples, aSampleCount);
}
std::size_t MPADECCodec::encode(const float* aSamples, std::size_t aSampleCount) const
{
return iImpl->encode(aSamples, aSampleCount);
}
const IAudioInfo& MPADECCodec::info() const
{
return iImpl->info();
}
std::vector<std::string> MPADECCodec::supportedExtensions()
{
return { "mp1", "mp2", "mp3" };
}
std::vector<std::string> MPADECCodec::supportedMimeTypes()
{
return { "audio/mpeg", "audio/mpa", "audio/mpa-robust" };
}
| [
"ron.jaegers@gmail.com"
] | ron.jaegers@gmail.com |
753286e178b2dea3b674718b1c459524bf13ad98 | 685943092ea2e317d383f8ee5793d279bbe4d080 | /Iron_Magnet_and_Wall.cpp | e0ff028e94214305773c4f0dd770f8f4d2d9fdde | [] | no_license | jitendrashukladx/competitiveProgrammingC- | 677fadd74f44fe8930194316d8f47a251b55d479 | 608c70c5d0fe328922011551aae98691b71b4e8f | refs/heads/master | 2023-01-14T14:38:59.858569 | 2020-11-26T05:33:03 | 2020-11-26T05:33:03 | 316,133,334 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,497 | cpp | #include <bits/stdc++.h>
using namespace std;
#define FASTIO ios_base::sync_with_stdio(false),cin.tie(NULL), cout.tie(NULL)
#define REP(i, start, end) for(auto i = start; i < end; i++)
//#define FORJ(start, end) for(auto j = start; j < end; j++)
int main(){
FASTIO;
int t;
cin >> t;
while(t--){
int n, k;
string fem;
cin >> n >> k;
cin >> fem;
int i=0,j=0,ans=0,c=0, P;
REP(l, 0, n) {
if(fem[l] == 'M') {
i = l;
break;
}
}
REP(l, 0, n) {
if(fem[l] == 'I') {
j = l;
break;
}
}
while(i < n && j < n){
if(fem[i] == 'M'){
if(fem[j] == 'I'){
REP(l, i+1, j){
if(fem[l] == ':') c++;
}
P = k + 1 - abs(i-j) - c;
if(P > 0){
ans++;
i++; j++; c=0;
} else if (P < 0) {
if(i > j) j++;
else if (j > i) i++;
}
} else if (fem[j] == 'X'){
j++; i = j;
} else j++;
} else if (fem[i] == 'X') {
i++; j = i;
}
else i++;
}
cout << ans << endl;
}
return 0;
} | [
"jitendrashukladx@gmail.com"
] | jitendrashukladx@gmail.com |
3baa7a34103cfbe2146488f686aa7d4802d6ad35 | d0fb46aecc3b69983e7f6244331a81dff42d9595 | /slb/include/alibabacloud/slb/model/DescribeVServerGroupsResult.h | c96b152cd7a765ba8ff5b451424fc7b12c668ebb | [
"Apache-2.0"
] | permissive | aliyun/aliyun-openapi-cpp-sdk | 3d8d051d44ad00753a429817dd03957614c0c66a | e862bd03c844bcb7ccaa90571bceaa2802c7f135 | refs/heads/master | 2023-08-29T11:54:00.525102 | 2023-08-29T03:32:48 | 2023-08-29T03:32:48 | 115,379,460 | 104 | 82 | NOASSERTION | 2023-09-14T06:13:33 | 2017-12-26T02:53:27 | C++ | UTF-8 | C++ | false | false | 1,943 | h | /*
* Copyright 2009-2017 Alibaba Cloud 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 ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPSRESULT_H_
#define ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPSRESULT_H_
#include <string>
#include <vector>
#include <utility>
#include <alibabacloud/core/ServiceResult.h>
#include <alibabacloud/slb/SlbExport.h>
namespace AlibabaCloud
{
namespace Slb
{
namespace Model
{
class ALIBABACLOUD_SLB_EXPORT DescribeVServerGroupsResult : public ServiceResult
{
public:
struct VServerGroup
{
struct AssociatedObjects
{
struct Listener
{
int port;
std::string protocol;
};
struct Rule
{
std::string ruleId;
std::string domain;
std::string url;
std::string ruleName;
};
std::vector<Listener> listeners;
std::vector<Rule> rules;
};
std::string vServerGroupId;
AssociatedObjects associatedObjects;
std::string vServerGroupName;
};
DescribeVServerGroupsResult();
explicit DescribeVServerGroupsResult(const std::string &payload);
~DescribeVServerGroupsResult();
std::vector<VServerGroup> getVServerGroups()const;
protected:
void parse(const std::string &payload);
private:
std::vector<VServerGroup> vServerGroups_;
};
}
}
}
#endif // !ALIBABACLOUD_SLB_MODEL_DESCRIBEVSERVERGROUPSRESULT_H_ | [
"sdk-team@alibabacloud.com"
] | sdk-team@alibabacloud.com |
1024e08350ddf7484bed18bf7d696bae9f12b37f | 974783200595a97433bb5992c323e861873c9979 | /simplegame/SimpleGame/SimpleGame/Untitled1.cpp | f11e6be0e9f9bc5e6e80e3cbef0047943525ccc9 | [] | no_license | hailongeric/whilzard_ctf_train | b511d422b6d71a54d127aa5f98ec90064b5fcacd | 1f1670e3cc08de16394f453657561507dfec7f00 | refs/heads/master | 2020-05-17T19:40:00.130127 | 2019-04-28T15:07:41 | 2019-04-28T15:07:41 | 183,919,769 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,830 | cpp | #include<stdio.h>
#include<string.h>
signed int test(char *input_0)
{
signed int i; // ebx
unsigned int v2; // edx
const char *input; // esi
int ch_i; // ecx
unsigned int v5; // esi
int v6; // ecx
unsigned int v7; // ecx
int v8; // esi
int v9; // edi
int *v10; // ebx
signed int v11; // ecx
int *v12; // edx
unsigned int aim; // [esp+Ch] [ebp-Ch]
signed int v15; // [esp+10h] [ebp-8h]
const char *input_1; // [esp+14h] [ebp-4h]
int dword_403020[] ={0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0, 0, 0x0F, 0x0F, 0x0F, 0, 0, 0, 0,0x0F, 0,0x0F,0x0F, 0x0F, 0,0x0F, 0x0F,0x0F, 0x0F, 0, 0, 0x0F, 0, 0, 0, 0, 0x0F, 0x0F, 0x0F, 0,0x0F, 0, 0x0F, 0, 0, 0x0F, 0, 0x0F,0x0F, 0x0F, 0x0F, 0,0x0F, 0x0F, 0, 0
,0x0F, 0, 0x0F,0x0F, 0, 0,0x0F, 0, 0, 0, 0, 0x0F, 0x0F, 0x0F, 0, 0, 0, 0,0x0F, 0,0x0F, 0x0F, 0x0F, 0x0F, 0x0F,0x0F, 0x0F, 0x0F, 0x0F, 0x0F, 0, 0, 0};
char *dword_403170="dssdwasawawaaswddw";
char unk_4021A0[]={0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 9, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 9, 0, 0, 0, 0, 0
, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6
,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0
,0, 0, 0, 0, 0, 0, 0, 0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
,0, 6, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3
,0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, 0, 0, 0, 0, 0, 0
,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0
,0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 8, 0
,0, 0, 8, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
,5, 0, 0, 0, 5, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 5, 0, 0, 0, 5, 0, 0
,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 2, 0, 0, 0, 2, 0, 0, 0, 2
,0, 0, 0, 2, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0
,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 7, 0, 0, 0, 0, 0
,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 7, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,0, 0, 0, 0, 0, 4, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0 ,0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,0, 0x42, 0, 0, 0, 0x42, 0, 0, 0, 0x42, 0, 0, 0, 0x42, 0, 0, 0, 0x48, 0, 0 ,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0 ,0, 0, 0, 0, 0, 0, 0, 0, 0 , 0 , 0, 0};
input_1 = input_0;
i = 0;
aim = 0;
input = input_0;
while ( 1 )
{
ch_i = input[i];
if ( ch_i != dword_403170[i / 2] )
return -1;
switch ( ch_i )
{
case 'a':
v7 = 'd' - input[i + 1];
goto LABEL_14;
case 'd':
v7 = input[i + 1] - '^';
LABEL_14:
v8 = input[i + 2];
if ( v8 != dword_403170[(i + 2) / 2] )
return -1;
if ( v8 == 's' )
{
v5 = input_1[i + 3] - 95;
}
else
{
if ( v8 != 'w' )
return -1;
v5 = 99 - input_1[i + 3];
}
LABEL_19:
if ( v5 > 5 || v7 > 5 )
return -1;
v15 = 0;
v9 = v5 + v7 + 8 * v5;
v10 = (int *)((char *)&unk_4021A0 + 64 * (i / 4));
do
{
v11 = 0;
v12 = v10;
do
{
if ( *v12 )
{
if ( dword_403020[v9 + v11] )
return -1;
dword_403020[v9 + v11] = *v12;
}
++v11;
++v12;
}
while ( v11 < 4 );
v10 += 4;
v9 += 9;
++v15;
}
while ( v15 < 4 );
input = input_1;
aim += 4;
i = aim;
if ( aim >= strlen(input_1) )
return 1;
break;
case 's':
v5 = input[i + 1] - 95;
goto LABEL_6;
case 'w':
v5 = 99 - input[i + 1];
LABEL_6:
v6 = input_1[i + 2];
if ( v6 != dword_403170[(i + 2) / 2] )
return -1;
if ( v6 == 97 )
{
v7 = 'd' - input_1[i + 3];
}
else
{
if ( v6 != 'd' )
return -1;
v7 = input_1[i + 3] - 94;
}
goto LABEL_19;
default:
return -1;
}
}
}
int main(){
char my[40];
scanf("%s",my);
test(my);
return 0;
}
| [
"hlnan16@fudan.edu.cn"
] | hlnan16@fudan.edu.cn |
69b0164c073aa3b2bb6d886a48a3bf2d3aa38e84 | cd9313c4dfe06d831016919233e2d2886ddca8a7 | /boj1644.cpp | acc29e9df9591a59701217785cc30f118381fde4 | [] | no_license | HJPyo/C | b198efa19f7484cc5b13e3e83798cdac99b6cd20 | 47d49f3aea1bc928fec5bcb344197c3dfecf5dd1 | refs/heads/main | 2023-04-12T15:04:44.844842 | 2021-05-11T09:13:07 | 2021-05-11T09:13:07 | 328,389,106 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 521 | cpp | #include<stdio.h>
#include<vector>
#define MAX 4444444
using namespace std;
int n, IsPrime[MAX] = {0,0};
vector<int>prime_num;
int main()
{
for(int i = 2; i < MAX; i++){
if(IsPrime[i] == 1) continue;
prime_num.push_back(i);
for(int j = i<<1; j < MAX; j+=i){
IsPrime[j] = 1;
}
}
scanf("%d", &n);
int L = 0, R = 0, now = 0, cnt = 1 - IsPrime[n];
while(prime_num[R] <= n){
if(now == n) cnt++;
if(now >= n) now -= prime_num[L++];
else if(now < n) now += prime_num[R++];
}
printf("%d", cnt);
}
| [
"bunker12383@gmail.com"
] | bunker12383@gmail.com |
fe55b57e4a357d5041ed819513064413f8d71a07 | f0885c9e2d8506d92440b2114c7737bd95e5a75a | /include/GC/Camera.h | 0edde6548c879a5780b869d15ee69a9682836712 | [] | no_license | Diivon/Glc | 8783caa8c3deddaa5f31b30c4a227a5489767664 | 9c0196dded2989b8aa4f2ab09c4cf3988d287834 | refs/heads/master | 2021-01-13T16:17:58.208244 | 2017-06-05T08:32:42 | 2017-06-05T08:32:42 | 81,225,489 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,423 | h | #pragma once
/*
gc/Camera provides Class for Camera object
Nearest analog is camera from our real world,
actually it is viewport, which limited visible part of scene
*/
#include "Vec2.h"
#include "Debug.h"
#include "SemanticHelpers.h"
#include <SFML/Graphics.hpp>
namespace gc
{
class Camera
{
::sf::View _view;
friend class Renderer;
public:
float followSpeed;
inline Camera() noexcept;
inline Camera(const Vec2 & pos, const Vec2 & size) noexcept;
inline Camera & moveTo(float x, float y) noexcept; //set
inline Camera & moveTo(const Vec2 & pos) noexcept; //set
inline Camera & moveOn(float dx, float dy) noexcept; //change
inline Camera & moveOn(const Vec2 & dp) noexcept;
inline Camera & setSize(float w, float h) noexcept; //set
inline Camera & setSize(const Vec2 & size) noexcept;
inline Camera & changeSize(float dw, float dh) noexcept;//change
inline Camera & changeSize(const Vec2 & ds) noexcept;
inline Camera & setRotation(float r) noexcept; //set
inline Camera & rotate(float dr) noexcept; //change
inline Camera & zoom(float z) noexcept; //change (deprecated)
inline Camera & follow(Vec2 const & pos) noexcept;
//getters
inline Vec2 getCenter() const noexcept;
inline Vec2 getSize() const noexcept;
inline const float getRotation() const noexcept;
inline const sf::View & getView() const noexcept{return _view;}
};
/*----------------------------------------------IMPLEMENTATION--------------------------------------------*/
#pragma region GC_CAMERA
inline Camera::Camera() noexcept :
_view()
{}
inline Camera::Camera(const Vec2 & pos, const Vec2 & size) noexcept :
_view(pos, size)
{}
inline Camera & Camera::moveTo(float x, float y) noexcept {
_view.setCenter(x, y);
return *this;
}
inline Camera & Camera::moveTo(const Vec2 & pos) noexcept {
_view.setCenter(pos);
return *this;
}
inline Camera & Camera::moveOn(float dx, float dy) noexcept {
_view.move(dx, dy);
return *this;
}
inline Camera & Camera::moveOn(const Vec2 & dp) noexcept {
_view.move(dp);
return *this;
}
inline Camera & Camera::setSize(float w, float h) noexcept {
_view.setSize(w, h);
return *this;
}
inline Camera & Camera::setSize(const Vec2 & size) noexcept {
_view.setSize(size);
return *this;
}
inline Camera & Camera::changeSize(float dw, float dh) noexcept {
auto size = _view.getSize();
_view.setSize(size.x + dw, size.y + dh);
return *this;
}
inline Camera & Camera::changeSize(const Vec2 & ds) noexcept {
auto size = _view.getSize();
_view.setSize(size.x + ds.x, size.y + ds.y);
return *this;
}
inline Camera & Camera::setRotation(float r) noexcept {
_view.setRotation(r);
return *this;
}
inline Camera & Camera::rotate(float dr) noexcept {
_view.rotate(dr);
return *this;
}
inline Camera & Camera::zoom(float z) noexcept {
_view.zoom(z);
return *this;
}
inline Camera & Camera::follow(Vec2 const & pos) noexcept{
auto distance = pos - this->getCenter();
if (distance.getLength() < 50) return *this;
Vec2 newPos = distance.normalize() / this->followSpeed;
_view.move(newPos);
return *this;
}
inline Vec2 Camera::getCenter() const noexcept {
return _view.getCenter();
}
inline Vec2 Camera::getSize() const noexcept {
return _view.getSize();
}
inline const float Camera::getRotation() const noexcept {
return _view.getRotation();
}
#pragma endregion
} | [
"Diivon@mail.ru"
] | Diivon@mail.ru |
89f286c7a5d98a7bc411f9c9fd53b744c74a318f | dc856c5165940305c3f52ae883aa4ae0c2c9d8aa | /app/cpp/mysimplegimp/src/core/transformations/morphological_operator.cpp | 40de9c234b33724a43b78015d2475318167930e7 | [
"MIT"
] | permissive | jaroslaw-wieczorek/lpo-image-processing | 7c6ad22206dfbac62a4655c0351d5430d26cc34a | 505494cff99cc8e054106998f86b599f0509880b | refs/heads/master | 2023-06-07T02:30:21.304399 | 2021-07-02T17:21:08 | 2021-07-02T17:21:08 | 382,389,023 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,084 | cpp | #include "morphological_operator.h"
MorphologicalOperator::MorphologicalOperator(PNM* img) :
Transformation(img)
{
}
MorphologicalOperator::MorphologicalOperator(PNM* img, ImageViewer* iv) :
Transformation(img, iv)
{
}
// abstract
const int MorphologicalOperator::morph(math::matrix<float>, math::matrix<bool>)
{
return 0;
}
math::matrix<bool> MorphologicalOperator::getSE(int size, SE shape)
{
switch (shape)
{
case Square: return seSquare(size);
case Cross: return seCross(size);
case XCross: return seXCross(size);
case VLine: return seVLine(size);
case HLine: return seHLine(size);
default: return seSquare(size);
}
}
math::matrix<bool> MorphologicalOperator::seSquare(int size)
{
math::matrix<bool> ret(size, size);
// set true in each field
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
ret[i][j] = true;
}
}
return ret;
}
math::matrix<bool> MorphologicalOperator::seCross(int size)
{
math::matrix<bool> ret(size, size);
int half = size / 2;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
if (i == half || j == half)
{
ret[i][j] = true;
}
else
{
ret[i][j] = false;
}
}
}
return ret;
}
math::matrix<bool> MorphologicalOperator::seXCross(int size)
{
math::matrix<bool> ret(size, size);
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
if (i == j)
{
ret[i][j] = true;
}
else
{
ret[i][j] = false;
}
}
}
return ret;
}
math::matrix<bool> MorphologicalOperator::seVLine(int size)
{
math::matrix<bool> ret(size, size);
int half = size / 2;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
if (j == half)
{
ret[i][j] = true;
}
else
{
ret[i][j] = false;
}
}
}
return ret;
}
math::matrix<bool> MorphologicalOperator::seHLine(int size)
{
math::matrix<bool> ret(size, size);
int half = size / 2;
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
if (i == half)
{
ret[i][j] = true;
}
else
{
ret[i][j] = false;
}
}
}
return ret;
}
PNM* MorphologicalOperator::transform()
{
int size = getParameter("size").toInt();
SE shape = (MorphologicalOperator::SE) getParameter("shape").toInt();
PNM* newImage = new PNM(image->width(), image->height(), QImage::Format_RGB32);
int width = image->width();
int height = image->height();
int half = int(size / 2);
if (image->format() == QImage::Format_Mono)
{
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
math::matrix<float> L_matrix = getWindow(x, y, size, LChannel, RepeatEdge);
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
L_matrix[i][j] = qGray(getPixel((x - half) + i, (y - half) + j, RepeatEdge));
}
}
int l = morph(L_matrix, getSE(size, shape));
newImage->setPixel(x, y, l);
}
}
}
else
{
for (int x = 0; x < width; x++)
{
for (int y = 0; y < height; y++)
{
math::matrix<float> R_matrix = getWindow(x, y, size, RChannel, RepeatEdge);
math::matrix<float> G_matrix = getWindow(x, y, size, GChannel, RepeatEdge);
math::matrix<float> B_matrix = getWindow(x, y, size, BChannel, RepeatEdge);
QRgb pixel = image->pixel(x,y);
int r = qRed(pixel);
int g = qGreen(pixel);
int b = qBlue(pixel);
for (int i = 0; i < size; i++)
{
for (int j = 0; j < size; j++)
{
R_matrix[i][j] = qRed(getPixel((x - half) + j, (y - half) + i, RepeatEdge));
B_matrix[i][j] = qBlue(getPixel((x - half) + j, (y - half) + i, RepeatEdge));
G_matrix[i][j] = qGreen(getPixel((x - half) + j, (y - half) + i, RepeatEdge));
}
}
r = morph(R_matrix, getSE(size, shape));
g = morph(G_matrix, getSE(size, shape));
b = morph(B_matrix, getSE(size, shape));
QColor newPixel = QColor(r,g,b);
newImage->setPixel(x, y, newPixel.rgb());
}
}
}
return newImage;
}
| [
"jarwie@st.amu.edu.pl"
] | jarwie@st.amu.edu.pl |
eb08c7d4ed29c93984c855bf57d4d70b134505eb | 748ae5463007deeeadb37a0cab797e251fc7b41f | /aadcUser/frAIburg_Planner/PlannerFilter.cpp | fa3e7828e61769fc4cd5edecf9c71302a1ab8888 | [
"BSD-3-Clause"
] | permissive | PhilJd/frAIburg | 30682c866728a6b64545b5194b753fad62674f18 | 7585999953486bceb945f1eb7a96cbe94ea72186 | refs/heads/master | 2021-04-25T12:47:24.859040 | 2019-03-23T10:29:02 | 2019-03-23T10:29:02 | 110,755,031 | 10 | 3 | null | null | null | null | UTF-8 | C++ | false | false | 40,121 | cpp | /**********************************************************************
Copyright (c) 2017, team frAIburg
Licensed under BSD-3.
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 <organization> 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 <COPYRIGHT HOLDER> 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.
**********************************************************************/
/* This filter deals with incoming and outgoing information, commands the globa
planner to compute new trajectories and feeds control set point to speed and
steering
controller */
#include "PlannerFilter.h"
using namespace frAIburg::map;
ADTF_FILTER_PLUGIN(ADTF_FILTER_DESC, OID_ADTF_FILTER_DEF, PlannerFilter)
/* string arrays below for debugging; MAKE SURE IT'S SYNCHED with enums in
* nonpin_types.h*/
const char* planner_status_string[] = {"PS_STAT_OBSTACLE", "PS_DYN_OBSTACLE",
"PS_SUCCESSFUL", "PS_FAILED",
"PS_NO_LANES", "PS_COMPLETED"};
PlannerFilter::PlannerFilter(const tChar* __info)
: cFilter(__info),
LOG_DEBUG_(true),
DELTA_T_REPLAN_(0.05),
behav_completed_sent_(true),
maneuver_planner_(&trajectory_planner_.path_planner_),
speed_curr_(0.),
isPositionInit_(false),
v_tracking_curr_(0.),
v_tracking_prev_(0.),
processed_new_lanevec_(true) {
pose_curr_.x = 0.;
pose_curr_.y = 0.;
pose_curr_.heading = 0.;
pose_prev_ = pose_curr_;
maneuver_planner_.setBehaviour(STOP, BT_UNKNOWN, -1, ST_STOP,
&behaviour_curr_);
setAllProperties();
}
/******************* Main thread loop ************************************/
tResult PlannerFilter::Run(tInt nActivationCode, const tVoid* pvUserData,
tInt szUserDataSize,
ucom::IException** __exception_ptr) {
if (running_ok_) {
// add goal point visualisation
// if (LOG_DEBUG_) {
// ManeuverGoal& goal = trajectory_planner_.path_planner_.
// goal_global_;
// if (goal.isGoalSet(behaviour_curr_.behaviour_id)) {
// addPointToMap(DEBUG_POINT, goal.getGoalInLocalFrame(pose_curr_).x,
// goal.getGoalInLocalFrame(pose_curr_).y,
// goal.getGoalInLocalFrame(pose_curr_).heading);
// }
// }
// update behaviour and replan
if (isPositionInit_) {
//printf("Pf: update behaviour curr\n");
behaviour_curr_ = maneuver_planner_.getUpdatedBehaviour();
/*if (behaviour_curr_.behaviour_id != maneuver_planner_.behaviour_curr_.behaviour_id) {
printf("WARNING! STATES HAVE DIVERGED!!! (PF: %i MP: %i)\n", behaviour_curr_.behaviour_id,
maneuver_planner_.behaviour_curr_.behaviour_id);
}*/
if (isReplanNecessary()) {
//printf("Pf: isReplanNecessary true \n");
actOnCurrentBehaviour(); // maybe something goes missing here?
}
// set lights
setLightForBehaviour();
CheckTransmitObstaclePosition();
}
// update maneuver status
if (behaviour_curr_.behaviour_id != FOLLOW_LANE) {
__synchronized_obj(update_pose_mutex_);
maneuver_planner_.is_maneuver_finished_ =
trajectory_planner_.isManeuverFinished(pose_curr_, speed_curr_,
behaviour_curr_);
if (maneuver_planner_.is_maneuver_finished_) {
//printf("Pf: entered maneuver finished, try to transmit:\n");
doManeuverFinishedActions();
//printf("Pf: entered maneuver finished, update behaviour:\n");
//behaviour_curr_ = maneuver_planner_.getUpdatedBehaviour(); // new 7.11
//maneuver_planner_.is_maneuver_finished_ = false; // also new 5.11
//printf("Pf: entered maneuver finished, behaviour updated\n");
}
}
// update time stamp for drawing paths
trajectory_planner_.path_planner_.updateTimestamp(
_clock->GetStreamTime());
maneuver_planner_.updateTimestamp(_clock->GetStreamTime());
}
RETURN_NOERROR;
}
/********************* Main thread loop for external
* triggers/events*************/
tResult PlannerFilter::OnPinEvent(IPin* source, tInt event_code, tInt param1,
tInt param2, IMediaSample* media_sample) {
RETURN_IF_POINTER_NULL(media_sample);
RETURN_IF_POINTER_NULL(source);
if (event_code == IPinEventSink::PE_MediaSampleReceived) {
/* ----- process lanes only if in lanefollow-mode and
last lane of batch has been received */
if (tLaneElement_vert_input_pin_.isSource(source)) {
processLaneElement(media_sample);
/* ----- update car's speed and position in global frame
get and transmit v_tracking to speed controller*/
} else if (tPos_input_pin_.isSource(source)) {
if (!processPose(media_sample)) {
printf("PlannerFilter couldn't update pose from mediasample");
RETURN_NOERROR;
}
isPositionInit_ = true;
transmitGoalpoint(
getGoalpoint()); // todo: return reference instead tPoint
/* ----- update distance driven since last planning
check if maneuver finished
replan if necessary */
correctRepositioningJump();
} else if (ds_input_pin_.isSource(source) && isPositionInit_) {
float ds;
if (processDeltaDistance(media_sample, &ds)) {
trajectory_planner_.updateDistance(ds);
trajectory_planner_.speed_planner_.updateCarState(ds,
speed_curr_);
}
// send 0 to init. motor
if (_clock->GetStreamTime() - init_time_ > 4. * 1e6) {
transmitVTracking(getSpeedValue());
} else {
transmitVTracking(0.);
}
// ----- update current behaviour and act
} else if (behaviour_input_pin_.isSource(source)) {
processBehaviour(media_sample);
}
}
RETURN_NOERROR;
}
bool PlannerFilter::isReplanNecessary() {
switch (behaviour_curr_.behaviour_id) {
case FOLLOW_LANE:
case FOLLOW_LANE_TO_CLEAR:
case FOLLOW_CAR:
case GO_TO_OBJECT:
case STOP_AT_OBJECT:
case PARK_AT_OBJECT:
case GO_STRAIGHT:
case TURN_LEFT:
case TURN_RIGHT:
case CHANGELANE_TO_LEFT:
case CHANGELANE_TO_RIGHT:
//case GO_BACKWARDS:
case DEMO_GO_TO_PERSON:
case DEMO_GO_TO_INIT:
case PULL_RIGHT_BWD:
return true;
default:
return (!maneuver_planner_.isBehaviourEqual(
maneuver_planner_.behaviour_curr_,
trajectory_planner_.behaviour_curr_));
}
}
planner_status PlannerFilter::actOnCurrentBehaviour() {
/* Requests global planner to plan path depending on requested behaviour */
// enable ultrasonic before lanechange; deactive when finished
if (behaviour_curr_.behaviour_id == FOLLOW_LANE_TO_CLEAR /*||
behaviour_curr_.behaviour_id == CHANGELANE_TO_LEFT*/) //CHANGELANE_TO_LEFT
TransmitEnableUSRight(true);
__synchronized_obj(update_pose_mutex_);
if (behaviour_curr_.behaviour_id == FOLLOW_LANE ||
behaviour_curr_.behaviour_id == FOLLOW_LANE_TO_CLEAR ||
behaviour_curr_.behaviour_id == GO_BACKWARDS ||
behaviour_curr_.behaviour_id == FOLLOW_CAR ||
behaviour_curr_.behaviour_id == CHANGELANE_TO_LEFT ||
behaviour_curr_.behaviour_id == CHANGELANE_TO_RIGHT) {
return doFollowLane();
// GO_TO/STOP_AT_OBJECT: give lanes if possible
} else if ((behaviour_curr_.behaviour_id == STOP_AT_OBJECT ||
behaviour_curr_.behaviour_id == GO_TO_OBJECT) ||
behaviour_curr_.behaviour_id == GO_AROUND_OBJECT) {
return doObjectApproach(); // todo: hand over lane_vec
} else if (behaviour_curr_.behaviour_id == TURN_LEFT ||
behaviour_curr_.behaviour_id == TURN_RIGHT ||
behaviour_curr_.behaviour_id == GO_STRAIGHT) {
return doCrossing();
} else if (behaviour_curr_.behaviour_id == STOP_AT_PARKING_INFRONT ||
behaviour_curr_.behaviour_id == PARK_AT_OBJECT) {
doParking();
} /*else if (behaviour_curr_.behaviour_id == DEMO_GO_TO_INIT ||
behaviour_curr_.behaviour_id == DEMO_GO_TO_PERSON) {
doDemoTask();
}*/
else { // todo: switch, list all behaviours!
// pull_out and other behaviours
return trajectory_planner_.requestTrajectories(
behaviour_curr_, pose_curr_, speed_curr_, NULL);
}
return PS_SUCCESSFUL;
}
planner_status PlannerFilter::doParking() {
if (behaviour_curr_.behaviour_id == STOP_AT_PARKING_INFRONT) {
return trajectory_planner_.requestTrajectories(
behaviour_curr_, pose_curr_, speed_curr_, NULL);
} else if (behaviour_curr_.behaviour_id == PARK_AT_OBJECT) {
TransmitEnableParkingRearView(true);
TransmitEnableFrontView(false);
return trajectory_planner_.requestTrajectories(
behaviour_curr_, pose_curr_, speed_curr_, &lane_vert_vec_);
}
return PS_SUCCESSFUL;
}
planner_status PlannerFilter::doCrossing() {
__synchronized_obj(update_lane_mutex_);
processed_new_lanevec_ = true;
return trajectory_planner_.requestTrajectories(
behaviour_curr_, pose_curr_, speed_curr_, &lane_vert_vec_);
}
planner_status PlannerFilter::doFollowLane() {
static bool is_lane_timeout = false;
static tTimeStamp time_first_timeout = _clock->GetStreamTime();
planner_status return_status = PS_SUCCESSFUL;
if (!processed_new_lanevec_) {
__synchronized_obj(update_lane_mutex_);
return_status = trajectory_planner_.requestTrajectories(
behaviour_curr_, pose_curr_, speed_curr_, &lane_vert_vec_);
processed_new_lanevec_ = true;
if (return_status == PS_NO_LANES || return_status == PS_FAILED) {
if (is_lane_timeout == false)
time_first_timeout = _clock->GetStreamTime();
is_lane_timeout = true;
printf("Start timeout\n");
} else
is_lane_timeout = false;
if (is_lane_timeout &&
(_clock->GetStreamTime() - time_first_timeout) > 1. * 1e6) {
printf(
"PlannerFilter: lane timeout triggered after %f sec. without "
"lane.\n",
1e-6 * (_clock->GetStreamTime() - time_first_timeout));
return_status = PS_NO_LANES;
} else {
return_status = PS_SUCCESSFUL;
}
}
return return_status;
}
planner_status PlannerFilter::doObjectApproach() {
if (behaviour_curr_.behaviour_id == STOP_AT_OBJECT ||
behaviour_curr_.behaviour_id == GO_TO_OBJECT) {
if (!processed_new_lanevec_) {
__synchronized_obj(update_lane_mutex_);
trajectory_planner_.requestTrajectories(
behaviour_curr_, pose_curr_, speed_curr_, &lane_vert_vec_);
processed_new_lanevec_ = true;
} else {
trajectory_planner_.requestTrajectories(behaviour_curr_, pose_curr_,
speed_curr_, NULL);
}
return PS_SUCCESSFUL;
} else if (behaviour_curr_.behaviour_id == GO_AROUND_OBJECT) {
return trajectory_planner_.requestTrajectories(
behaviour_curr_, pose_curr_, speed_curr_, NULL);
}
return PS_SUCCESSFUL;
}
// planner_status PlannerFilter::doDemoTask() {
// }
/* Based on current behaviour, this method gets speed value from either
SpeedPlanner or sets it directly (e.g. for following car) */
float PlannerFilter::getSpeedValue() {
//const float ACC_CENTRIPETAL_MAX = 0.5;
if (maneuver_planner_.behaviour_statemachine_.behaviour_id == STOP) {
v_tracking_curr_ = 0.;
return v_tracking_curr_;
}
v_tracking_prev_ = v_tracking_curr_;
switch (maneuver_planner_.behaviour_curr_.behaviour_id) {
case STOP_AT_PARKING_INFRONT:
case PULL_RIGHT_FWD:
v_tracking_curr_ = 0.3;
break;
case PULL_RIGHT_BWD:
case PARK_AT_OBJECT:
case GO_BACKWARDS:
v_tracking_curr_ = -0.25;
if (maneuver_planner_.is_maneuver_finished_) {
v_tracking_curr_ = 0.;
}
break;
case STOP_AT_OBJECT:
if (maneuver_planner_.is_maneuver_finished_) {
v_tracking_curr_ = 0.;
} else {
v_tracking_curr_ =
trajectory_planner_.speed_planner_.getVTracking();
if (speed_curr_ < 0.05)
v_tracking_curr_ = 0.1;
}
return v_tracking_curr_;
default:
v_tracking_curr_ =
trajectory_planner_.speed_planner_.getVTracking();
if (maneuver_planner_.behaviour_curr_.behaviour_id == FOLLOW_LANE ||
(maneuver_planner_.behaviour_curr_.behaviour_id) == CHANGELANE_TO_LEFT) {
v_tracking_curr_ = std::max(0.05f, v_tracking_curr_);
}
break;
}
// limit velocity in curves:
/*if (speed_curr_ > 0.8*SPEED_HIGH_) {
// A 1m radius we want to drive with 0.7m/s for better crossing detection
float curvature_steering = fabs(last_goal_.y)/
(2*(pow(last_goal_.x, 2.0) + pow(last_goal_.y, 2.0)));
float acc_centripetal = speed_curr_*speed_curr_*curvature_steering;
if (acc_centripetal > ACC_CENTRIPETAL_MAX && curvature_steering != 0.) {
v_tracking_curr_ =
std::min(1.0*v_tracking_curr_,
0.5*(v_tracking_curr_+sqrt(ACC_CENTRIPETAL_MAX/curvature_steering)));
printf("Limited speed due to high centripetal forces\n");
}
}*/
return v_tracking_curr_;
}
tPoint PlannerFilter::getGoalpoint() {
tPoint goal;
float lookahead = 0.2;
//float anchor_offset;
bool use_backward_anchor = false;
if (maneuver_planner_.behaviour_curr_.behaviour_id == GO_BACKWARDS) {
goal.x = 1.;
goal.y = 0.;
return goal;
}
//printf("Pf behaviour curr is %i\n", behaviour_curr_.behaviour_id);
//printf("MP behaviour curr is %i\n", maneuver_planner_.behaviour_curr_.behaviour_id);
if (maneuver_planner_.behaviour_curr_.behaviour_id == PARK_AT_OBJECT ||
maneuver_planner_.behaviour_curr_.behaviour_id == PULL_RIGHT_BWD /*||
maneuver_planner_.behaviour_curr_.behaviour_id == GO_BACKWARDS*/) { //behaviour_curr_.behaviour_id == GO_BACKWARDS
printf("Use backward goal point");
//anchor_offset = CAR_ANCHOR_OFFSET_BWD_;
lookahead = 0.2;
use_backward_anchor = true;
//printf("goal rel to anchor is %f %f\n", goal.x, goal.y);
} else {
lookahead = 0.2;
//if (maneuver_planner_.behaviour_curr_.behaviour_id == FOLLOW_LANE &&
// speed_curr_ > 1.5 * SPEED_LOW_) {
//lookahead = 0.3;
// adaptive lookahead; damping for high speeds:
lookahead += 0.1 * (fabs(speed_curr_) / SPEED_HIGH_);
//}
use_backward_anchor = false;
}
if (trajectory_planner_.path_planner_.gp_gen_.getUpdatedGoal(
pose_curr_, lookahead, &goal, use_backward_anchor)) {
//anchor_offset = CAR_ANCHOR_OFFSET_;
last_goal_ = goal;
return goal;
} else {
return last_goal_;
}
}
void PlannerFilter::correctRepositioningJump() {
const float JUMP_DELTA_L = 0.1;
__synchronized_obj(update_pose_mutex_);
float dx_global_prev = pose_curr_.x - pose_prev_.x;
float dy_global_prev = pose_curr_.y - pose_prev_.y;
if ((pow(dx_global_prev, 2) + pow(dy_global_prev, 2)) > JUMP_DELTA_L*JUMP_DELTA_L) {
trajectory_planner_.path_planner_.gp_gen_.
updateInitialPoseAfterJump(dx_global_prev, dy_global_prev);
trajectory_planner_.path_planner_.goal_global_.
updateGoalPoseAfterJump(dx_global_prev, dy_global_prev);
if (LOG_DEBUG_)
printf("PlannerFilter detected repos. jump by dx dy %f %f\n",
dx_global_prev, dy_global_prev);
}
pose_prev_ = pose_curr_;
}
void PlannerFilter::setLightForBehaviour() {
const float DT_RESPONSE = 0.1;
static tTimeStamp time_since_change = _clock->GetStreamTime();
static bool change_detected = false;
tTimeStamp current_time = _clock->GetStreamTime();
// break lights for stopping
if (fabs(v_tracking_curr_) < fabs(v_tracking_prev_) && fabs(speed_curr_) > 0.1) {
if (!change_detected) {
time_since_change = current_time;
change_detected = true;
} else if (current_time - time_since_change > DT_RESPONSE*1e6) {
TransmitLightCommand(BRAKE_LIGHTS, true);
}
} else {
TransmitLightCommand(BRAKE_LIGHTS, false);
}
// hazard lights for emergency break
if ((maneuver_planner_.behaviour_emergency_.behaviour_id == EM_ENABLED &&
current_time-maneuver_planner_.behaviour_emergency_.timestamp > 3.*1e6) ||
maneuver_planner_.behaviour_curr_.behaviour_id == GO_BACKWARDS) {
printf("Set hazard lights\n");
TransmitLightCommand(HAZZARD_LIGHTS, true);
} else {
TransmitLightCommand(HAZZARD_LIGHTS, false);
}
// turning lights for lane changing
switch (maneuver_planner_.behaviour_curr_.behaviour_id) {
case CHANGELANE_TO_LEFT:
case TURN_LEFT:
case PULL_RIGHT_BWD:
printf("Set turn light left\n");
TransmitLightCommand(TURN_SIGNAL_LEFT, true);
break;
case CHANGELANE_TO_RIGHT:
case TURN_RIGHT:
case PULL_RIGHT_FWD:
TransmitLightCommand(TURN_SIGNAL_RIGHT, true);
break;
default:
TransmitLightCommand(TURN_SIGNAL_LEFT, false);
TransmitLightCommand(TURN_SIGNAL_RIGHT, false);
break;
}
}
void PlannerFilter::doManeuverFinishedActions() {
if (behaviour_curr_.behaviour_id == PARK_AT_OBJECT) {
TransmitEnableParkingRearView(false);
TransmitEnableFrontView(true);
} else if (behaviour_curr_.behaviour_id == FOLLOW_LANE_TO_CLEAR) {
TransmitEnableUSRight(false);
}
transmitPlannerStatus(PS_COMPLETED);
}
void PlannerFilter::CheckTransmitObstaclePosition() {
static tPose car_pose_last_transmit = pose_curr_;
if ((maneuver_planner_.behaviour_emergency_.behaviour_id == EM_ENABLED &&
(_clock->GetStreamTime()-maneuver_planner_.behaviour_emergency_.timestamp) > 3.*1e6) ||
(maneuver_planner_.behaviour_curr_.behaviour_id = CHANGELANE_TO_LEFT)) {
float dist_last_transmit = sqrt(pow(pose_curr_.x - car_pose_last_transmit.x, 2) +
pow(pose_curr_.y - car_pose_last_transmit.y, 2));
if (dist_last_transmit > 1.) {
// get closest obstacle, otherwise return default position in front
tMapID coll_id = trajectory_planner_.path_planner_.getClosestCollidingIDWithBox(0.4, 0.);
tSptrMapElement coll_obj = map_->GetElement(coll_id);
TransmitJuryObstacle(coll_obj);
car_pose_last_transmit = pose_curr_;
}
}
}
/**************************************************************************
Routines for I/O processing
**************************************************************************/
void PlannerFilter::transmitPlannerStatus(const planner_status& status) {
// static bool isLaneFollowInit = false;
// send PS_COMPLETE only once; PS_FAILED etc. can be send
// repeatedly, though
if (status == PS_SUCCESSFUL) return;
if (maneuver_planner_.behaviour_curr_.behaviour_id == FOLLOW_LANE) {
printf(
"PlannerFilter wants to transmit PS_COMPLETED after lane follow. "
"THIS SHOULD NOT HAPPEN! \n");
return;
}
behaviour_state_child_enum childstate = maneuver_planner_.behaviour_state_child_;
if ((childstate != BS_NORMALDRIVING_STATEMACHINE &&
maneuver_planner_.behaviour_finished_.behaviour_id != maneuver_planner_.behaviour_statemachine_.behaviour_id) //&&
//(childstate != BS_PULLRIGHT_BWD) &&
//(childstate != BS_PARKING_STOP)) {
){
//printf("Dont transmit planner status for childstate %i \n", childstate);
return;
}
if (status == PS_COMPLETED) {
if (behav_completed_sent_) {
//printf("Completed already sent\n");
return;
}
else {
behav_completed_sent_ = true;
// printf("set behav_completed_sent_ true \n");
}
}
//if (behaviour_curr_.behaviour_id == STOP_AT_OBJECT) {
// maneuver_planner_.behaviour_statemachine_.behaviour_id = STOP;}
if (LOG_DEBUG_) {
printf("Planner transmit: %s\n", planner_status_string[status]);
fflush(stdout);
}
// if (LOG_DEBUG_) {printf("Behaviour status: %s\n",
// behaviour_type_string[behaviour_curr_.behaviour_id]);}
vector<const tVoid*> vals = boost::assign::list_of((const tVoid*)&status);
status_output_pin_.Transmit(vals, _clock->GetStreamTime());
}
bool PlannerFilter::processBehaviour(IMediaSample* media_sample) {
/* Receive integer ID of enum element; some enums are combined with an
ID of a map object (e.g. for behaviour "stop_at_object")*/
tBehaviour* pSampleData = NULL;
if (IS_OK(behaviour_input_pin_.ReadNoID_start(
media_sample, (const tVoid**)&pSampleData, sizeof(tBehaviour)))) {
/* If interrupted by emergency filter, keep prev. state:
ToDO: Use list/queue instead */
tBehaviour* target_behaviour = NULL;
switch (pSampleData->behaviour_id) {
case EM_ENABLED:
case EM_DISABLED:
case EM_OBSTACLE_AHEAD:
//std::cout << "Received behaviour from EM" << pSampleData->behaviour_id << std::endl;
target_behaviour = &maneuver_planner_.behaviour_emergency_;
break;
case DEMO_GO_TO_PERSON:
case DEMO_GO_TO_INIT:
target_behaviour = &maneuver_planner_.behaviour_demo_;
break;
default: // state machine
//std::cout << "Received behaviour from SM " << pSampleData->behaviour_id << std::endl;
//printf("received behaviour %i\n", pSampleData->behaviour_id);
target_behaviour = &maneuver_planner_.behaviour_statemachine_;
behav_completed_sent_ = false;
//printf("PlannerFIlter received behaviour %i from state machine\n", pSampleData->behaviour_id);
break;
}
maneuver_planner_.setBehaviour(*pSampleData, target_behaviour);
// fflush(stdout);
// if (LOG_DEBUG_) {printf("Planner: Received behaviour %s and ID %i\n",
// behaviour_type_string[pSampleData->behaviour_id],
// pSampleData->object_id);
// fflush(stdout);}
behaviour_input_pin_.ReadNoID_end(media_sample,
(const tVoid**)pSampleData);
return true;
}
printf("PlannerFilter::processBehaviour failed \n");
return false;
}
bool PlannerFilter::processLaneElement(IMediaSample* media_sample) {
tLaneElement* pSampleData = NULL;
__synchronized_obj(update_lane_mutex_);
// add incoming data to buffer vector;
if (IS_OK(tLaneElement_vert_input_pin_.ReadNoID_start(
media_sample, (const tVoid**)&pSampleData, sizeof(tLaneElement)))) {
if ((*pSampleData).idx == 0) {
lane_vert_vec_.resize((*pSampleData).count);
// printf("received first lane out of %i \n", (*pSampleData).count);
}
if (lane_vert_vec_.size() > (*pSampleData).idx) {
lane_vert_vec_[(*pSampleData).idx].coeff.clear();
lane_vert_vec_[(*pSampleData).idx].coeff.push_back(
(*pSampleData).coeff0);
lane_vert_vec_[(*pSampleData).idx].coeff.push_back(
(*pSampleData).coeff1);
lane_vert_vec_[(*pSampleData).idx].coeff.push_back(
(*pSampleData).coeff2);
lane_vert_vec_[(*pSampleData).idx].dist = (*pSampleData).dist;
lane_vert_vec_[(*pSampleData).idx].no_of_samples =
(*pSampleData).no_of_samples;
if ((*pSampleData).idx == (*pSampleData).count - 1) {
processed_new_lanevec_ = false;
// printf("processLaneElement received last element\n");
}
// printf("received lane with idx %i \n", (*pSampleData).idx);
} else {
printf("Couldn't add received lane, idx out of bounds \n");
}
tLaneElement_vert_input_pin_.ReadNoID_end(media_sample,
(const tVoid**)pSampleData);
}
return true;
}
bool PlannerFilter::processPose(IMediaSample* media_sample) {
tPosition* pSampleData = NULL;
if (IS_OK(tPos_input_pin_.ReadNoID_start(
media_sample, (const tVoid**)&pSampleData, sizeof(tPosition)))) {
__synchronized_obj(update_pose_mutex_);
pose_curr_.x = pSampleData->f32x;
pose_curr_.y = pSampleData->f32y;
pose_curr_.heading = fmod(pSampleData->f32heading, 2*PI);
if (pose_curr_.heading < 0.)
pose_curr_.heading += 2*PI;
speed_curr_ = pSampleData->f32speed;
tPos_input_pin_.ReadNoID_end(media_sample, (const tVoid**)pSampleData);
// if (LOG_DEBUG_) {printf("Current pose is x=%f y=%f phi=%f\n",
// pose_curr_.x, pose_curr_.y, pose_curr_.heading);}
return true;
}
printf("PlannerFilter::processPose failed \n");
return false;
}
void PlannerFilter::transmitGoalpoint(const tPoint& goal_pnt) {
/* update goal point based on car movement since path creation */
//if (fabs(speed_curr_) <= SPEED_STOPPED_)
// return;
vector<const tVoid*> vals = boost::assign::list_of(
(const tVoid*)&goal_pnt.x)((const tVoid*)&goal_pnt.y);
goalpoint_output_pin_.Transmit(vals, _clock->GetStreamTime());
}
void PlannerFilter::transmitVTracking(float v_tracking) {
/* sample and send tracking point v to the speed controller */
tTimeStamp time = _clock->GetStreamTime();
vector<const tVoid*> vals =
boost::assign::list_of((const tVoid*)&v_tracking)((const tVoid*)&time);
vtracking_output_pin_.Transmit(vals, time);
}
bool PlannerFilter::processDeltaDistance(IMediaSample* media_sample,
float* ds) {
tSignalValue* sample_data = NULL;
if (IS_OK(ds_input_pin_.ReadNoID_start(
media_sample, (const tVoid**)&sample_data, sizeof(tSignalValue)))) {
*ds = sample_data->f32Value;
ds_input_pin_.ReadNoID_end(media_sample, (const tVoid**)sample_data);
return true;
}
printf("PlannerFilter::processDeltaDistance failed \n");
return false;
}
void PlannerFilter::TransmitEnableParkingRearView(const tBool enable_rear) {
vector<const tVoid*> vals =
boost::assign::list_of((const tVoid*)&enable_rear);
if (IS_FAILED(enable_parking_rear_view_output_pin_.Transmit(
vals, _clock->GetStreamTime()))) {
LOG_ERROR("Failed sending enable rear view.");
}
}
void PlannerFilter::TransmitEnableFrontView(const tBool enable_front) {
if (IS_FAILED(enable_front_view_output_pin_.Transmit<tBool>(
enable_front, _clock->GetStreamTime()))) {
LOG_ERROR("Failed sending enable front view.");
}
}
tResult PlannerFilter::TransmitLightCommand(tInt32 light_id, tBool switch_bool) {
vector<const void*> vals1 = boost::assign::list_of((const void*)&light_id)(
(const void*)&switch_bool);
if (IS_FAILED(light_controller_output_pin_.Transmit(
vals1, _clock->GetStreamTime()))) {
LOG_ERROR_PRINTF("Pf: failed sending light command\n");
}
RETURN_NOERROR;
}
void PlannerFilter::TransmitEnableUSRight(const tBool enable_us_right) {
static bool last_transmit = true;
if (enable_us_right == last_transmit) return;
last_transmit = enable_us_right;
if (IS_FAILED(enable_us_right_output_pin_.Transmit<tBool>(
enable_us_right, _clock->GetStreamTime()))) {
LOG_ERROR("Failed sending enable us right.");
}
}
void PlannerFilter::TransmitJuryObstacle(const tSptrMapElement & el_obstacle)
{
tMapPoint center;
if (!el_obstacle) {
center.set<0>(pose_curr_.x + 0.5*cos(pose_curr_.heading));
center.set<1>(pose_curr_.y + 0.5*sin(pose_curr_.heading));
} else {
center = el_obstacle->GetGlobalPolyCenter();
}
jury_obstacle_output_pin_.Transmit<float, float>(
center.get<0>(), center.get<1>(), _clock->GetStreamTime());
printf("PlannerFilter transmitted obstacle to jury with x y (%f %f)", center.get<0>(), center.get<1>());
// if (1) {
// LOG_ERROR("Failed sending enable jury_obstacle.");
// }
}
/**************************************************************************
Routines for setting up ADTF
**************************************************************************/
tResult PlannerFilter::Init(tInitStage stage, __exception) {
RETURN_IF_FAILED(cFilter::Init(stage, __exception_ptr))
// in StageFirst you can create and register your static pins.
tResult nResult = ERR_NOERROR;
if (stage == StageFirst) {
nResult = CreateOutputPins(__exception_ptr);
if (IS_FAILED(nResult))
THROW_ERROR_DESC(nResult, "Failed to create Output Pins");
nResult = CreateInputPins(__exception_ptr);
if (IS_FAILED(nResult))
THROW_ERROR_DESC(nResult, "Failed to create Input Pins");
} else if (stage == StageNormal) {
// In this stage you would do further initialisation and/or create your
// dynamic pins. Please take a look at the demo_dynamicpin example for
// further reference.
} else if (stage == StageGraphReady) {
// All pin connections have been established in this stage so you can
// query your pins about their media types and additional meta data.
// Please take a look at the demo_imageproc example for further
// reference.
map_ = frAIburg::map::getInstance();
trajectory_planner_.path_planner_.setMap(map_);
nResult = SetPinIDs();
if (IS_FAILED(nResult)) THROW_ERROR_DESC(nResult, "Failed to set IDs");
InitTimer(); // init and start timer after a dely
}
RETURN_NOERROR;
}
// ____________________________________________________________________________
tResult PlannerFilter::Shutdown(tInitStage stage, __exception) {
if (stage == StageGraphReady) {
DeleteTimer();
} else if (stage == StageNormal) {
} else if (stage == StageFirst) {
}
// call the base class implementation
return cFilter::Shutdown(stage, __exception_ptr);
}
// ____________________________________________________________________________
tResult PlannerFilter::CreateInputPins(__exception) {
slim::register_pin_func func = &PlannerFilter::RegisterPin;
// This pin also handles the lanes that come from parking
RETURN_IF_FAILED(tLaneElement_vert_input_pin_.FirstStageCreate(
this, func, "VerticalLane", "tLaneElement"));
RETURN_IF_FAILED(tLaneElement_horiz_input_pin_.FirstStageCreate(
this, func, "HorizontalLane", "tLaneElement"));
RETURN_IF_FAILED(
tPos_input_pin_.FirstStageCreate(this, func, "Position", "tPosition"));
RETURN_IF_FAILED(
ds_input_pin_.FirstStageCreate(this, func, "delta_s", "tSignalValue"));
RETURN_IF_FAILED(behaviour_input_pin_.FirstStageCreate(
this, func, "behaviour", "tBehaviour"));
RETURN_NOERROR;
}
// ____________________________________________________________________________
tResult PlannerFilter::CreateOutputPins(__exception) {
slim::register_pin_func func = &PlannerFilter::RegisterPin;
RETURN_IF_FAILED(vtracking_output_pin_.FirstStageCreate(this, func, "v_set",
"tSignalValue"));
RETURN_IF_FAILED(goalpoint_output_pin_.FirstStageCreate(
this, func, "goal_point", "tPoint"));
RETURN_IF_FAILED(status_output_pin_.FirstStageCreate(
this, func, "planner_status", "tPlannerStatus"));
RETURN_IF_FAILED(enable_parking_rear_view_output_pin_.FirstStageCreate(
this, func, "enable_parking_rear_view", "tBoolSignalValue"));
RETURN_IF_FAILED(enable_front_view_output_pin_.FirstStageCreate(
this, func, "enable_front_view", "tBoolSignalValue"));
RETURN_IF_FAILED(light_controller_output_pin_.FirstStageCreate(
this, func, "light_output", "tLightCommand"));
RETURN_IF_FAILED(enable_us_right_output_pin_.FirstStageCreate(
this, func, "enable_us_right", "tBoolSignalValue"));
RETURN_IF_FAILED(jury_obstacle_output_pin_.FirstStageCreate(
this, func, "jury_obstacle", "tObstacle"));
RETURN_NOERROR;
}
// ____________________________________________________________________________
tResult PlannerFilter::SetPinIDs() {
vector<string> ids1 =
boost::assign::list_of("f32Value")("ui32ArduinoTimestamp");
RETURN_IF_FAILED(vtracking_output_pin_.StageGraphReadySetIDOrder(ids1));
vector<string> ids2 = boost::assign::list_of("x")("y");
RETURN_IF_FAILED(goalpoint_output_pin_.StageGraphReadySetIDOrder(ids2));
vector<string> ids3 = boost::assign::list_of("status");
RETURN_IF_FAILED(status_output_pin_.StageGraphReadySetIDOrder(ids3));
// camera on/off
vector<string> id_enable_front_view = boost::assign::list_of("bValue");
RETURN_IF_FAILED(enable_front_view_output_pin_.StageGraphReadySetIDOrder(
id_enable_front_view));
vector<string> id_enable_rear_view = boost::assign::list_of("bValue");
RETURN_IF_FAILED(
enable_parking_rear_view_output_pin_.StageGraphReadySetIDOrder(
id_enable_rear_view));
// light command
vector<string> id5s = boost::assign::list_of("light_id")("switch_bool");
RETURN_IF_FAILED(
light_controller_output_pin_.StageGraphReadySetIDOrder(id5s));
// enable ultrasonic right
RETURN_IF_FAILED(
enable_us_right_output_pin_.StageGraphReadySetIDOrder(
id_enable_rear_view));
vector<string> id6s = boost::assign::list_of("f32x")("f32y");
RETURN_IF_FAILED(jury_obstacle_output_pin_.StageGraphReadySetIDOrder(id6s));
RETURN_NOERROR;
}
// ____________________________________________________________________________
tResult PlannerFilter::Start(__exception) {
RETURN_IF_FAILED(cFilter::Start(__exception_ptr));
last_time_ = _clock->GetStreamTime();
init_time_ = _clock->GetStreamTime();
running_ok_ = true;
getAllProperties();
TransmitEnableUSRight(false);
RETURN_NOERROR;
}
// ____________________________________________________________________________
tResult PlannerFilter::Stop(__exception) {
running_ok_ = false;
RETURN_IF_FAILED(cFilter::Stop(__exception_ptr));
RETURN_NOERROR;
}
void PlannerFilter::getAllProperties(void) {
LOG_DEBUG_ = GetPropertyBool("Filter communication: debug mode");
trajectory_planner_.setDebugMode(LOG_DEBUG_);
trajectory_planner_.path_planner_.setDebugMode(
GetPropertyBool("Path planner: debug mode"));
trajectory_planner_.path_planner_.spline_.setDebugMode(
GetPropertyBool("Path planner: debug mode"));
trajectory_planner_.speed_planner_.setDebugMode(
GetPropertyBool("Speed planner: debug mode"));
trajectory_planner_.path_planner_.gp_gen_.setDebugMode(
GetPropertyBool("Goal point generation: debug mode"));
}
// ____________________________________________________________________________
void PlannerFilter::setAllProperties(void) {
SetPropertyBool("Filter communication: debug mode", false);
SetPropertyBool("Path planner: debug mode", false);
SetPropertyBool("Speed planner: debug mode", false);
SetPropertyBool("Goal point generation: debug mode", false);
// SetPropertyBool("Draw current path", true);
}
tResult PlannerFilter::UpdateProperties(ucom::IException** __exception_ptr) {
RETURN_IF_FAILED(cFilter::UpdateProperties(__exception_ptr));
getAllProperties();
RETURN_NOERROR;
}
/**************************************************************************
Helper routines
**************************************************************************/
void PlannerFilter::addPointToMap(MapElementType type, tMapData x, tMapData y,
tMapData angle) {
frAIburg::map::GlobalMap* map = frAIburg::map::getInstance();
if (!map) return;
std::vector<tMapPoint> v1 = boost::assign::list_of(tMapPoint(x, y));
// el1.
tSptrMapElement el_sign(
new MapElement(type, v1, _clock->GetStreamTime(), angle));
el_sign->EnableTimeOfLife(0.1 * 1e6);
el_sign->user_tag_ui_ = "GP";
//printf("Added pnt %f %f to map \n", x, y);
map->AddElement(el_sign); // add ele new to map
}
// ____________________________________________________________________________
void PlannerFilter::InitTimer() {
timer_ = NULL;
tUInt32 nFlags = 0;
// Create our cyclic timer.
cString strTimerName = OIGetInstanceName();
strTimerName += ".rttimerStateMachineTimer";
tTimeStamp tmPeriod = 1e6 * DELTA_T_REPLAN_;
tTimeStamp tmstartdelay = 1e6 * 0.2;
timer_ = _kernel->TimerCreate(tmPeriod,
tmstartdelay, // dely for the first start
static_cast<IRunnable*>(this), // call run
NULL, NULL, 0, nFlags, strTimerName);
if (!timer_) {
LOG_ERROR("PlannerFilter unable to create timer");
}
}
// ____________________________________________________________________________
void PlannerFilter::DeleteTimer() {
if (timer_) {
running_ok_ = false;
_kernel->TimerDestroy(timer_);
timer_ = NULL;
}
}
| [
"jundp@informatik.uni-freiburg.de"
] | jundp@informatik.uni-freiburg.de |
76c2cea1fb179014b47f23fcdcf0abd444afd267 | fa0c642ba67143982d3381f66c029690b6d2bd17 | /Source/Module/Script/ScriptModule.cpp | f6101269e300aa9830bb7b13dbc8c0824fe6a316 | [
"MIT"
] | permissive | blockspacer/EasyGameEngine | 3f605fb2d5747ab250ef8929b0b60e5a41cf6966 | da0b0667138573948cbd2e90e56ece5c42cb0392 | refs/heads/master | 2023-05-05T20:01:31.532452 | 2021-06-01T13:35:54 | 2021-06-01T13:35:54 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,289 | cpp | //! @file ScriptModule.cpp
//! @author LiCode
//! @version 1.1.0.613
//! @date 2011/01/17
//! Copyright ...
#include "EGEScript.h"
//----------------------------------------------------------------------------
// ScriptModule Helpful Functions Implementation
//----------------------------------------------------------------------------
const _charw* GetScriptTypeName( _SCRIPT type )
{
switch ( type )
{
case _SCRIPT_PYTHON: return L"Python";
case _SCRIPT_JAVA_SCRIPT: return L"JavaScript";
case _SCRIPT_LUA: return L"Lua";
default:
return L"Unknown";
}
}
//----------------------------------------------------------------------------
// ScriptModule Implementation
//----------------------------------------------------------------------------
ScriptModule::ScriptModule( ) : BaseClass( L"Script", Version( SCRIPT_FILEVER ) )
{
}
ScriptModule::~ScriptModule( )
{
Finalize( );
GetModuleManager( )->UnregisterModule( this );
}
_ubool ScriptModule::InitInternalScriptModule( _SCRIPT type )
{
switch ( type )
{
#if (_SCRIPT_USE_PYTHON_ == 1)
case _SCRIPT_PYTHON: mInternalScriptSystem = new _pySystem( ); break;
#elif (_SCRIPT_USE_JS_ == 1)
case _SCRIPT_JAVA_SCRIPT: mInternalScriptSystem = new _jscSystem( ); break;
#elif (_SCRIPT_USE_LUA_ == 1)
case _SCRIPT_LUA: mInternalScriptSystem = new _luaSystem( ); break;
#endif
default:
WLOG_ERROR_1( L"The script module does not support '%s' script", GetScriptTypeName( type ) );
return _false;
}
// Initialize internal script system
if ( mInternalScriptSystem->Initialize( ) == _false )
return _false;
gInternalScriptSystem = mInternalScriptSystem.GetPtr( );
return _true;
}
_ubool ScriptModule::Initialize( _SCRIPT type )
{
WLOG_TRACE( L"Create script module ..." );
// Initialize script helper
if ( _scriptHelper::Initialize( ) == _false )
return _false;
// Initialize internal script module
if ( InitInternalScriptModule( type ) == _false )
return _false;
// Initialize resource manager
gScriptResourceManager = &mResourceManager;
if ( mResourceManager.Initialize( ) == _false )
return _false;
WLOG_TRACE( L"Create script module DONE" );
return _true;
}
_void ScriptModule::Finalize( )
{
WLOG_TRACE( L"Release script module ..." );
// Finalize internal components
mResourceManager.Finalize( );
// Release internal script system
mInternalScriptSystem.Clear( );
// Finalize script helper
_scriptHelper::Finalize( );
WLOG_TRACE( L"Release script module DONE" );
// Clear global modules
gInternalScriptSystem = &NullScript::GetInstance( ).GetScriptSystem( );
gScriptResourceManager = &NullScript::GetInstance( ).GetScriptResourceManager( );
gScriptModule = &NullScript::GetInstance( ).GetScriptModule( );
}
_void ScriptModule::Tick( _dword limited_elapse, _dword elapse )
{
gInternalScriptSystem->Tick( limited_elapse, elapse );
}
_void ScriptModule::HandleEvent( EventBase& event )
{
}
_dword ScriptModule::GetTotalMemSize( ) const
{
return gInternalScriptSystem->GetTotalMemSize( );
}
_ubool ScriptModule::SetRemoteDebugger( const Address& address )
{
return gInternalScriptSystem->SetRemoteDebugger( address );
}
const Address& ScriptModule::GetRemoteDebugger( ) const
{
return gInternalScriptSystem->GetRemoteDebugger( );
} | [
"zopenge@126.com"
] | zopenge@126.com |
42b69711185791a3f7903d8cdd51c9c526e86c63 | c782ef24626b66d609b5742b59b2f38774a44540 | /src/mobility/NodeFactory.cc | 716303bda1428289bb9f5c4fbffe0d1308e03752 | [] | no_license | olafur/inetmanet | de06aaa676f1a50a04a3d45f442ddfead2bd80ca | 39b72d1462a6cfbf2c475f6945dca3252924bad9 | refs/heads/master | 2021-01-18T06:14:28.506755 | 2010-08-02T13:26:08 | 2010-08-02T13:26:08 | 797,860 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,834 | cc | //
// Copyright (C) 2008 Olafur Ragnar Helgason, Laboratory for Communication
// Networks, KTH, Stockholm
// (C) Kristjan Valur Jonsson, Reykjavik University, Reykjavik
//
// This program is free software; you can redistribute it and/or
// modify it under the terms of the GNU General Public License version 3
// as published by the Free Software Foundation.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
// GNU General Public License for more details.
//
// You should have received a copy of the GNU General Public License
// along with this program; if not see <http://www.gnu.org/licenses/>.
//
#include "NodeFactory.h"
#include "cstringtokenizer.h"
#include <fstream>
#include <sstream>
#include <vector>
// Class TraceEntryParser ------------------------------------------------
bool TraceEntryParser::parse(const string line)
{
// Returns a vector of the words in the line
// (default delimiter is " ")
cStringTokenizer tokenizer(line.c_str());
vector<string> entries = tokenizer.asVector();
if(entries.size() < 3) {
ev<<"less than three entries in trace line"<<endl;
return false;
}
_time = entries[0];
_cmd = entries[1];
_nodeID = entries[2];
if(_cmd == "create"){
if(entries.size() != 6){
ev<<"create line must have 6 entries"<<endl;
return false;
}
_eCmd = CREATE;
_x = entries[3];
_y = entries[4];
_z = entries[5];
return true;
}
if(_cmd == "destroy"){
_eCmd = DESTROY;
return true;
}
if(_cmd == "setdest"){
if(entries.size() != 8){
ev<<"setdest line must have 8 entries"<<endl;
return false;
}
_eCmd = SETDEST;
_x = entries[3];
_y = entries[4];
_z = entries[5];
_speed = entries[6];
_timeAtDest = entries[7];
return true;
}
return true;
}
//#define __NODE_FACTORY_DEBUG__
// The module class needs to be registered with OMNeT++
Define_Module(NodeFactory);
//
// Constructor
//
// Initialize event messages
//
NodeFactory::NodeFactory()
{
m_generateCount = 0;
m_initializedCount = 0;
m_destroyedCount = 0;
m_totalLifetime = 0.0;
_defaultNodeNamePrefix = "";
}
//
// initialize
//
// Override of virtual base class method.
// Initialize simulation at startup.
//
void NodeFactory::initialize()
{
// Read parameters from the ini file
hasPar("scenarioSizeX") ? m_scenarioSizeX = par("scenarioSizeX") : m_scenarioSizeX = 1000;
hasPar("scenarioSizeY") ? m_scenarioSizeY = par("scenarioSizeY") : m_scenarioSizeY = 1000;
hasPar("traceFile") ? m_traceFile = string((const char *)par("traceFile")) : m_traceFile = "";
hasPar("defaultNodeNamePrefix") ? _defaultNodeNamePrefix = string((const char *)par("defaultNodeNamePrefix")) : _defaultNodeNamePrefix = "";
hasPar("defaultNodeTypename") ? _defaultNodeTypename = string((const char*)par("defaultNodeTypename")) : _defaultNodeTypename = "";
if(_defaultNodeTypename != ""){
_defaultNodeType = cModuleType::get( _defaultNodeTypename.c_str() );
} else {
_defaultNodeType = 0;
}
// Trace file must be defined. Display error if not.
if ( m_traceFile == "" ){
throw cRuntimeError("No trace file given for NodeFactory.");
} else {
readSetdestTrace();
}
if ( ev.isGUI() )
{
WATCH(m_initializedCount);
WATCH(m_generateCount);
WATCH(m_destroyedCount);
}
}
void NodeFactory::finish()
{
// Dispose of any remaining dynamically created modules.
// If GOU is on we do not delete them but let them stay on the display
if ( !ev.isGUI() ){
for( unsigned int i=0; i < m_createdItems.size(); i++ )
{
NodeFactoryItem* item = (NodeFactoryItem*)m_createdItems.at(i);
if ( item == NULL )
continue;
m_totalLifetime = simTime() - item->getCreateTime();
item->getModule()->callFinish();
item->getModule()->deleteModule();
delete item;
item = 0;
m_destroyedCount++;
}
}
}
/**
* The factory only handles create and destroy events, that is events scheduled in response
* to scripted events read from a trace file.
*
* The simulation is terminated after the last node has been destroyed, when no nodes
* remain to be instantiated.
*/
void NodeFactory::handleMessage(cMessage *msg)
{
//if ( msg->getKind() == CREATE_EVENT_KIND )
if ( msg->getKind() == CREATE )
{
CreateEvent *te = check_and_cast<CreateEvent*>(msg);
createNode(te);
delete msg;
}
else if ( msg->getKind() == DESTROY )
{
DestroyEvent *te = check_and_cast<DestroyEvent*>(msg);
// Destroy node returns the number of nodes left to instantiate in the simulation.
destroyNode(te);
delete msg;
}
}
void NodeFactory::createNode( CreateEvent *event )
{
// Get the module type object from the given class name
cModuleType *moduleType = 0;
if(event->getType() != 0 && string(event->getType()) != ""){
moduleType = cModuleType::get( event->getType() );
}
std::stringstream convert;
convert<<event->getNodeID();
string nodeID = convert.str();
string objectName = _defaultNodeNamePrefix + nodeID;
// create module
cModule* module = 0;
ev << "Creating module " << objectName << endl;
if(moduleType != 0){
module = moduleType->create( objectName.c_str(), this->getParentModule() );
} else {
if(_defaultNodeType == 0){
throw cRuntimeError("No default node type given and no module type given in create");
}
module = _defaultNodeType->create( objectName.c_str(), this->getParentModule() );
}
// Call buildInside to create the module.
module->buildInside();
// Set initial position in mobility sub-module
cModule* mobility = module->getSubmodule("mobility");
bool hasMobility = false;
if(mobility != 0)
{
hasMobility = true;
if ( mobility->hasPar("x") )
mobility->par("x") = event->getX();
if ( mobility->hasPar("y") )
mobility->par("y") = event->getY();
if ( mobility->hasPar("z") )
mobility->par("z") = 0;
}
// create activation message
module->scheduleStart( simTime() );
module->callInitialize();
// Populate the mobility module of the created nodes with the cached events read from
// the initial trace file.
if ( _pendingWaypointsLists[event->getNodeID()].size() != 0 )
{
if(!hasMobility){
throw cRuntimeError("Waypoints exist for a node with no mobility sub-module.");
}
cModuleType* mobilityType = mobility->getModuleType();
cModuleType* traceMobilityType = cModuleType::get("inet.mobility.TraceMobility");
if(mobilityType != traceMobilityType)
throw cRuntimeError("Node does not have mobility module of type inet.mobility.TraceMobility");
waypointEventsList waypointList = _pendingWaypointsLists[event->getNodeID()];
TraceMobility *tm = check_and_cast<TraceMobility*>(mobility);
tm->initializeTrace( &waypointList );
_pendingWaypointsLists.erase( event->getNodeID() );
}
// Store the created module in our dynamic objects list.
NodeFactoryItem *item = new NodeFactoryItem( module, event->getNodeID(), simTime() );
m_createdItems.push_back( item );
m_generateCount++;
}
/**
* Search through the createdItems list and destroy the node in our dynamic collection
* whose id matches that of the DestroyEvent.
*
* @todo This search could be more elegant.
*/
int NodeFactory::destroyNode( DestroyEvent *event )
{
cModule *module;
NodeFactoryItem *item;
CREATED_ITEMS_VECTOR_TYPE::iterator iter;
bool deleted = false;
for( iter = m_createdItems.begin(); iter != m_createdItems.end(); iter++ )
{
item = (*iter);
if ( item == NULL )
continue;
if ( item->getId() == event->getNodeID() )
{
m_totalLifetime += simTime() - item->getCreateTime();
module = item->getModule();
module->callFinish();
module->deleteModule();
delete item;
m_createdItems.erase(iter);
deleted = true;
break;
}
}
if(deleted)
m_destroyedCount++;
else
throw cRuntimeError("destroy error: Node %d has not been created (or already destroyed)", event->getNodeID());
// Return the number of node which are active or yet to be activated.
return ( m_initializedCount - m_destroyedCount );
}
void NodeFactory::readSetdestTrace()
{
ifstream tracefilestream;
tracefilestream.open(m_traceFile.c_str());
if(!tracefilestream.is_open()){
string err = string("Could not open tracefile '") + m_traceFile + string("'");
throw cRuntimeError(err.c_str());
}
string line;
TraceEntryParser tep;
TraceEvent *curEvent = NULL;
int linecount = 1;
while(!std::getline(tracefilestream, line).eof()){
if(!tep.parse(line)){
ev<<"Error parsing tracefile entry in line "<<linecount<<endl;
throw cRuntimeError("Error parsing tracefile entry");
}
switch(tep.command())
{
case CREATE:
{
int id = atoi(tep.nodeID().c_str());
if(_nodeIDs.count(id) != 0){
throw cRuntimeError("Create error: Node %s already exists", tep.nodeID().c_str());
}
if(tep.x() < 0 || tep.x() > m_scenarioSizeX){
throw cRuntimeError("Create: Node x coordinate out of bounds");
}
if(tep.y() < 0 || tep.y() > m_scenarioSizeY){
throw cRuntimeError("Create: Node y coordinate out of bounds");
}
curEvent = new CreateEvent();
curEvent->setKind(CREATE);
m_initializedCount++;
curEvent->setTime( tep.time() );
curEvent->setNodeID( atoi(tep.nodeID().c_str()) );
((CreateEvent*)curEvent)->setX( tep.x() );
((CreateEvent*)curEvent)->setY( tep.y() );
((CreateEvent*)curEvent)->setZ( tep.z() );
((CreateEvent*)curEvent)->setType( 0 );
_nodeIDs.insert(id);
scheduleAt(curEvent->getTime(), curEvent);
}
break;
case SETDEST:
{
if(tep.x() < 0 || tep.x() > m_scenarioSizeX){
throw cRuntimeError("setdest: Node x coordinate out of bounds");
}
if(tep.y() < 0 || tep.y() > m_scenarioSizeY){
throw cRuntimeError("setdest: Node y coordinate out of bounds");
}
WAYPOINT_EVENT curWaypointEvent;
curWaypointEvent.time = tep.time();
curWaypointEvent.id = atoi(tep.nodeID().c_str());
curWaypointEvent.speed = tep.speed();
curWaypointEvent.x = tep.x();
curWaypointEvent.y = tep.y();
curWaypointEvent.z = tep.z();
curWaypointEvent.timeAtDest = tep.timeAtDest();
waypointEventsList el;
if(_pendingWaypointsLists.count(curWaypointEvent.id) != 0)
el = _pendingWaypointsLists[curWaypointEvent.id];
el.push_back(curWaypointEvent);
_pendingWaypointsLists[curWaypointEvent.id] = el;
}
break;
case DESTROY:
{
int id = atoi(tep.nodeID().c_str());
if(_nodeIDs.count(id) != 1){
error("Destroy error: Node %s not existing or already destroyed", tep.nodeID().c_str());
}
_nodeIDs.erase(id);
curEvent = new DestroyEvent();
curEvent->setKind(DESTROY);
curEvent->setTime( tep.time() );
curEvent->setNodeID( atoi(tep.nodeID().c_str()) );
scheduleAt(curEvent->getTime(), curEvent);
}
break;
default:
throw cRuntimeError("Unknown command in tracefile");
break;
}
linecount++;
}
tracefilestream.close();
}
| [
"olafur.helgason@ee.kth.se"
] | olafur.helgason@ee.kth.se |
7fb0cd3e92a6086d1745f999d894113289fa3dbd | 98f30e2e3fcf6694e57f718724c25d7fb6e26988 | /sysfs.H | d073d77670e4318b1f8ab37865786ed4c65a1bf3 | [
"Apache-2.0"
] | permissive | williamli80/phosphor-hwmon | 1e32d77fccbbd4569ec0174012608904617908c3 | 1f1b41ed8e1be794e51559abf14db9dad3e2bcdc | refs/heads/master | 2021-01-15T14:50:26.848477 | 2016-08-29T20:36:41 | 2016-08-29T20:37:18 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 650 | h | #ifndef __SYSFS_H
#define __SYSFS_H
#include <fstream>
#include <string>
template <typename T>
void read_sysfs(const std::string& path, T& val)
{
std::ifstream s(path);
s >> val;
}
template <typename T>
void write_sysfs(const std::string& path, const T& val)
{
std::ofstream s(path);
s << val;
}
const std::string make_sysfs_path(const std::string& path,
const std::string& type,
const std::string& id,
const std::string& entry)
{
using namespace std::literals;
return path + "/"s + type + id + "_"s + entry;
}
#endif
| [
"patrick@stwcx.xyz"
] | patrick@stwcx.xyz |
9ad427921a8cc422700d9100258f1d1a35b8a05a | 31ac07ecd9225639bee0d08d00f037bd511e9552 | /externals/OCCTLib/inc/Handle_StepShape_ExtrudedAreaSolid.hxx | 63e004eb75b77cb5e7445fa8609d3d71175de672 | [] | no_license | litao1009/SimpleRoom | 4520e0034e4f90b81b922657b27f201842e68e8e | 287de738c10b86ff8f61b15e3b8afdfedbcb2211 | refs/heads/master | 2021-01-20T19:56:39.507899 | 2016-07-29T08:01:57 | 2016-07-29T08:01:57 | 64,462,604 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 850 | hxx | // This file is generated by WOK (CPPExt).
// Please do not edit this file; modify original file instead.
// The copyright and license terms as defined for the original file apply to
// this header file considered to be the "object code" form of the original source.
#ifndef _Handle_StepShape_ExtrudedAreaSolid_HeaderFile
#define _Handle_StepShape_ExtrudedAreaSolid_HeaderFile
#ifndef _Standard_HeaderFile
#include <Standard.hxx>
#endif
#ifndef _Standard_DefineHandle_HeaderFile
#include <Standard_DefineHandle.hxx>
#endif
#ifndef _Handle_StepShape_SweptAreaSolid_HeaderFile
#include <Handle_StepShape_SweptAreaSolid.hxx>
#endif
class Standard_Transient;
class Handle(Standard_Type);
class Handle(StepShape_SweptAreaSolid);
class StepShape_ExtrudedAreaSolid;
DEFINE_STANDARD_HANDLE(StepShape_ExtrudedAreaSolid,StepShape_SweptAreaSolid)
#endif
| [
"litao1009@gmail.com"
] | litao1009@gmail.com |
b42cbdbe49e334ae018864b31bd84b2c43dd0754 | 98ef9f82f45320df070f670eac258c8365113642 | /solution1-100/4. Median of Two Sorted Arrays.cc | 93666cfa2e9e12bda8f432c1be0b1b70c250b693 | [] | no_license | FrankWork/LeetCode | abbf6125b57e143073f89daf5cbcbd8ff67bb78b | 6ec0c0d43cf4e8ef968051a4d125c4965d58e4f5 | refs/heads/master | 2021-01-22T07:27:43.963950 | 2018-11-12T08:44:18 | 2018-11-12T08:44:18 | 39,978,490 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,220 | cc | /*
There are two sorted arrays nums1 and nums2 of size m and n respectively. Find the median of the two sorted arrays. The overall run time complexity should be O(log (m+n)).
*/
#include <iostream>
#include <vector>
using namespace std;
/**
[] [1] 1
[] [1,2] 1.5
[1] [1] 1
[1,1] [1,1] 1
[] [2,3] 2.5
*/
class Solution {
public:
double findMedianSortedArrays(vector<int>& nums1, vector<int>& nums2) {
int i=0,j=0;
vector<int> nums;
while(i< nums1.size() && j< nums2.size()){
if(nums1[i] < nums2[j])
nums.push_back(nums1[i++]);
else
nums.push_back(nums2[j++]);
}
while(i< nums1.size()){
nums.push_back(nums1[i++]);
}
while(j< nums2.size()){
nums.push_back(nums2[j++]);
}
int n = nums.size();
int m = n/2;
double ret;
if(n%2==0){
int sum= nums[m-1];
sum += nums[m];
ret = sum/2.0;
}else{
ret = nums[m];
}
return ret;
}
};
int main(){
vector<int> nums = {1,1};
vector<int> nums2={1,2};
Solution so;
cout << so.findMedianSortedArrays(nums,nums2);
}
| [
"lzh00776@163.com"
] | lzh00776@163.com |
a83a897165ff64f97c48e799bf96a0b80739970a | 1911d6f70cbaaaedf0321ed66224edcb97ed5767 | /libccmyext/src/CSlideWindow.h | 0b2707f731043a4588520796fc648b5e509e66eb | [] | no_license | marszaya/huihe | bab451cde0c365defde50cbec2fffe6c8c5cfc0b | d1ac3b292ae588aea73a95cabf44f720c5f4437f | refs/heads/master | 2021-01-19T22:33:03.491040 | 2014-01-22T08:24:23 | 2014-01-22T08:24:23 | null | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 1,391 | h | #pragma once
#include "cocos2d.h"
#include "CWindowBase.h"
#include <vector>
#include <map>
#include <string>
using namespace std;
USING_NS_CC;
//幻灯片播放
class CCESlideWindow: public CCWindowBase
{
public:
struct INDEX_ITEM
{
int refCnt;
CCNode* target;
};
typedef map<string, INDEX_ITEM> TEYP_INDEX_MAP;
protected:
vector<CCNode*> m_slides;
TEYP_INDEX_MAP m_index;
float m_dt;
bool m_play;
int m_cur;
public:
CCESlideWindow(void);
virtual ~CCESlideWindow(void);
static CCESlideWindow* create();
bool initCCESlideWindow();
//增加一个
int addSlide(CCNode* slide, const string& id);
//删除一个
int delSlide(const string& id);
CCNode* getSlide(const string& id);
inline void setDt(float dt)
{
m_dt = dt;
if(m_play)
{
stopPlay();
startPlay();
}
}
inline int startPlay()
{
if(!m_play)
{
this->schedule(schedule_selector(CCESlideWindow::updateCallBack) , m_dt);
m_play = true;
}
return 0;
}
inline int stopPlay()
{
if(m_play)
{
this->unschedule(schedule_selector(CCESlideWindow::updateCallBack));
m_play = false;
}
return 0;
}
int gotoSlide(const string& id)
{
int ret = findSlide(id);
if(ret < 0)
return -1;
m_cur = ret;
if(m_play)
{
stopPlay();
startPlay();
}
}
void updateCallBack(float dt);
protected:
int findSlide(const string& id);
int showCurSlide();
};
| [
"zaya@qq.com"
] | zaya@qq.com |
70d2a65c6c9a9bb5bdf65d0d8728aa9ec51e2e96 | c8b39acfd4a857dc15ed3375e0d93e75fa3f1f64 | /Engine/Plugins/Experimental/AlembicImporter/Source/ThirdParty/Alembic/openexr/OpenEXR/IlmImfTest/testIsComplete.h | 18f0ca9f6074e1fdfe3662ff3c3ef935662f70f9 | [
"MIT",
"LicenseRef-scancode-proprietary-license",
"BSD-3-Clause"
] | permissive | windystrife/UnrealEngine_NVIDIAGameWorks | c3c7863083653caf1bc67d3ef104fb4b9f302e2a | b50e6338a7c5b26374d66306ebc7807541ff815e | refs/heads/4.18-GameWorks | 2023-03-11T02:50:08.471040 | 2022-01-13T20:50:29 | 2022-01-13T20:50:29 | 124,100,479 | 262 | 179 | MIT | 2022-12-16T05:36:38 | 2018-03-06T15:44:09 | C++ | UTF-8 | C++ | false | false | 1,875 | h | ///////////////////////////////////////////////////////////////////////////
//
// Copyright (c) 2005-2012, 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.
//
///////////////////////////////////////////////////////////////////////////
#include <string>
void testIsComplete (const std::string &tempDir);
| [
"tungnt.rec@gmail.com"
] | tungnt.rec@gmail.com |
d773d861d923c141a3959438940c316b109e534b | 9bea0681b8ac6354ae1d595e1e51216368ff3c3f | /FsprgEmbeddedStore/FsprgEmbeddedStore.h | b29ef2ec8a2adebca6f24c69e7eaac696f2e418c | [
"MIT"
] | permissive | FastSpring/FsprgEmbeddedStoreWinMFC | 1636f06adab53d56a695f85237117304bc459936 | 582beab813b1b114d47697265e189507de218e56 | refs/heads/master | 2020-04-29T13:24:08.036789 | 2012-09-11T12:57:51 | 2012-09-11T12:57:51 | 1,844,974 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 512 | h | // FsprgEmbeddedStore.h : main header file for the FsprgEmbeddedStore DLL
//
#pragma once
#ifndef __AFXWIN_H__
#error "include 'stdafx.h' before including this file for PCH"
#endif
#include "resource.h" // main symbols
// CFsprgEmbeddedStoreApp
// See FsprgEmbeddedStore.cpp for the implementation of this class
//
class CFsprgEmbeddedStoreApp : public CWinApp
{
public:
CFsprgEmbeddedStoreApp();
// Overrides
public:
virtual BOOL InitInstance();
DECLARE_MESSAGE_MAP()
};
| [
"brumple@comcast.net"
] | brumple@comcast.net |
0617fe20931b7a39b696d954d90b5e8cb74d118d | 93e28d8a7e6321436177496092f09f2c2dfd3714 | /Particle.h | 83df8123246aa3f4b8c9e8412868969bf80772fc | [] | no_license | yuyaolong/particleSystem | 2c3998586a2852b89d71843377a2f8a8819c266a | 56285473ecf52e9536f7c0f175734cb048d85169 | refs/heads/master | 2021-01-17T17:01:52.017426 | 2015-09-21T05:28:19 | 2015-09-21T05:28:19 | 42,786,026 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,230 | h | //
// Particle.h
// assignment2
//
// Created by yuyaolong on 15/9/19.
// Copyright (c) 2015年 yuyaolong. All rights reserved.
//
#ifndef __assignment2__Particle__
#define __assignment2__Particle__
#include <stdio.h>
#include "Vector.h"
class Particle
{
public:
Particle();
Particle(const Vector3d &p, const Vector3d &v, const Vector4d &c, const double m, const double l, const double s, const bool t);
//~Particle();
//Particle(const Particle&);
//Particle& operator= (const Particle& );
void setPosition(const Vector3d&);
void setVelocity(const Vector3d&);
void setColor(const Vector4d&);
void setMass(const double);
void setLifeSpan(const double);
void setPointSize(const double);
void setStopSign(const bool);
const Vector3d& getPosition();
const Vector3d& getVelocity();
const Vector4d& getColor();
const double getMass();
const double getLifeSpan();
const double getPointSize();
const bool getStopSign();
private:
Vector3d position;
Vector3d velocity;
Vector4d color;
double mass;
int lifeSpan;
double pointSize;
bool stopSign;
};
#endif /* defined(__assignment2__Particle__) */
| [
"312337231@qq.com"
] | 312337231@qq.com |
558fd56e45786960c50455160901365db0fd1e47 | a35b30a7c345a988e15d376a4ff5c389a6e8b23a | /boost/math/tr1_c_macros.ipp | 2e2d39d3f5440e77fef5f04014ea82e2bfaceb16 | [] | no_license | huahang/thirdparty | 55d4cc1c8a34eff1805ba90fcbe6b99eb59a7f0b | 07a5d64111a55dda631b7e8d34878ca5e5de05ab | refs/heads/master | 2021-01-15T14:29:26.968553 | 2014-02-06T07:35:22 | 2014-02-06T07:35:22 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 63 | ipp | #include "thirdparty/boost_1_55_0/boost/math/tr1_c_macros.ipp"
| [
"liuhuahang@xiaomi.com"
] | liuhuahang@xiaomi.com |
837da341b663c4d487f47cc790ed13076edc0056 | 1af49694004c6fbc31deada5618dae37255ce978 | /third_party/blink/renderer/modules/cookie_store/cookie_store_manager.h | ffbc4f98f4b053dd38c99e95ab617bfc342d665c | [
"LGPL-2.0-or-later",
"GPL-1.0-or-later",
"MIT",
"Apache-2.0",
"LicenseRef-scancode-warranty-disclaimer",
"LGPL-2.1-only",
"GPL-2.0-only",
"LGPL-2.0-only",
"BSD-2-Clause",
"LicenseRef-scancode-other-copyleft",
"BSD-3-Clause"
] | permissive | sadrulhc/chromium | 59682b173a00269ed036eee5ebfa317ba3a770cc | a4b950c23db47a0fdd63549cccf9ac8acd8e2c41 | refs/heads/master | 2023-02-02T07:59:20.295144 | 2020-12-01T21:32:32 | 2020-12-01T21:32:32 | 317,678,056 | 3 | 0 | BSD-3-Clause | 2020-12-01T21:56:26 | 2020-12-01T21:56:25 | null | UTF-8 | C++ | false | false | 3,480 | h | // Copyright 2019 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#ifndef THIRD_PARTY_BLINK_RENDERER_MODULES_COOKIE_STORE_COOKIE_STORE_MANAGER_H_
#define THIRD_PARTY_BLINK_RENDERER_MODULES_COOKIE_STORE_COOKIE_STORE_MANAGER_H_
#include "third_party/blink/public/mojom/cookie_store/cookie_store.mojom-blink.h"
#include "third_party/blink/renderer/bindings/core/v8/script_promise.h"
#include "third_party/blink/renderer/modules/service_worker/service_worker_registration.h"
#include "third_party/blink/renderer/platform/bindings/script_wrappable.h"
#include "third_party/blink/renderer/platform/heap/handle.h"
#include "third_party/blink/renderer/platform/mojo/heap_mojo_remote.h"
#include "third_party/blink/renderer/platform/mojo/heap_mojo_wrapper_mode.h"
#include "third_party/blink/renderer/platform/supplementable.h"
#include "third_party/blink/renderer/platform/weborigin/kurl.h"
#include "third_party/blink/renderer/platform/wtf/vector.h"
namespace blink {
class CookieStoreGetOptions;
class ExceptionState;
class ScriptPromiseResolver;
class ScriptState;
class CookieStoreManager final : public ScriptWrappable,
public Supplement<ServiceWorkerRegistration> {
DEFINE_WRAPPERTYPEINFO();
public:
static const char kSupplementName[];
// Web Exposed as registration.cookies
static CookieStoreManager* cookies(ServiceWorkerRegistration& registration);
explicit CookieStoreManager(ServiceWorkerRegistration& registration);
~CookieStoreManager() override = default;
ScriptPromise subscribe(
ScriptState* script_state,
const HeapVector<Member<CookieStoreGetOptions>>& subscriptions,
ExceptionState& exception_state);
ScriptPromise unsubscribe(
ScriptState* script_state,
const HeapVector<Member<CookieStoreGetOptions>>& subscription,
ExceptionState& exception_state);
ScriptPromise getSubscriptions(ScriptState* script_state,
ExceptionState& exception_state);
// GarbageCollected
void Trace(Visitor* visitor) const override;
private:
// The non-static callbacks keep CookieStoreManager alive during mojo calls.
//
// The browser-side implementation of the mojo calls assumes the SW
// registration is live. When CookieStoreManager is used from a Window global,
// the CookieStoreManager needs to live through the mojo call, so it can keep
// its ServiceWorkerRegistration alive.
void OnSubscribeResult(ScriptPromiseResolver* resolver, bool backend_result);
void OnGetSubscriptionsResult(
ScriptPromiseResolver* resolver,
Vector<mojom::blink::CookieChangeSubscriptionPtr> backend_result,
bool backend_success);
// SW registration whose cookie change subscriptions are managed by this.
Member<ServiceWorkerRegistration> registration_;
// Wraps a Mojo pipe for managing service worker cookie change subscriptions.
HeapMojoRemote<mojom::blink::CookieStore,
HeapMojoWrapperMode::kWithoutContextObserver>
backend_;
// Default for cookie_url in CookieStoreGetOptions.
//
// This is the Service Worker registration's scope.
const KURL default_cookie_url_;
// The context in which cookies are accessed.
const scoped_refptr<SecurityOrigin> default_top_frame_origin_;
};
} // namespace blink
#endif // THIRD_PARTY_BLINK_RENDERER_MODULES_COOKIE_STORE_COOKIE_STORE_MANAGER_H_
| [
"commit-bot@chromium.org"
] | commit-bot@chromium.org |
3e43ac5e9ff63834efbd49f58e165c85b0ad5f3a | 8dc84558f0058d90dfc4955e905dab1b22d12c08 | /ui/views/controls/button/toggle_button_unittest.cc | 2315f7935b730d4a8440b489dfea1d9408f1a154 | [
"LicenseRef-scancode-unknown-license-reference",
"BSD-3-Clause"
] | permissive | meniossin/src | 42a95cc6c4a9c71d43d62bc4311224ca1fd61e03 | 44f73f7e76119e5ab415d4593ac66485e65d700a | refs/heads/master | 2022-12-16T20:17:03.747113 | 2020-09-03T10:43:12 | 2020-09-03T10:43:12 | 263,710,168 | 1 | 0 | BSD-3-Clause | 2020-05-13T18:20:09 | 2020-05-13T18:20:08 | null | UTF-8 | C++ | false | false | 4,530 | cc | // Copyright (c) 2016 The Chromium Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.
#include "ui/views/controls/button/toggle_button.h"
#include "base/macros.h"
#include "build/build_config.h"
#include "testing/gtest/include/gtest/gtest.h"
#include "ui/events/event_utils.h"
#include "ui/events/test/event_generator.h"
#include "ui/views/test/views_test_base.h"
namespace views {
class TestToggleButton : public ToggleButton {
public:
explicit TestToggleButton(int* counter)
: ToggleButton(nullptr), counter_(counter) {}
~TestToggleButton() override {
// Calling SetInkDropMode() in this subclass allows this class's
// implementation of RemoveInkDropLayer() to be called. The same
// call is made in ~ToggleButton() so this is testing the general technique.
SetInkDropMode(InkDropMode::OFF);
}
using View::Focus;
protected:
// ToggleButton:
void AddInkDropLayer(ui::Layer* ink_drop_layer) override {
++(*counter_);
ToggleButton::AddInkDropLayer(ink_drop_layer);
}
void RemoveInkDropLayer(ui::Layer* ink_drop_layer) override {
ToggleButton::RemoveInkDropLayer(ink_drop_layer);
--(*counter_);
}
private:
int* counter_;
DISALLOW_COPY_AND_ASSIGN(TestToggleButton);
};
class ToggleButtonTest : public ViewsTestBase {
public:
ToggleButtonTest() {}
~ToggleButtonTest() override {}
void SetUp() override {
ViewsTestBase::SetUp();
// Create a widget so that the ToggleButton can query the hover state
// correctly.
widget_.reset(new Widget);
Widget::InitParams params =
CreateParams(Widget::InitParams::TYPE_WINDOW_FRAMELESS);
params.ownership = views::Widget::InitParams::WIDGET_OWNS_NATIVE_WIDGET;
params.bounds = gfx::Rect(0, 0, 650, 650);
widget_->Init(params);
widget_->Show();
button_ = new TestToggleButton(&counter_);
widget_->SetContentsView(button_);
}
void TearDown() override {
widget_.reset();
ViewsTestBase::TearDown();
}
protected:
int counter() const { return counter_; }
Widget* widget() { return widget_.get(); }
TestToggleButton* button() { return button_; }
private:
std::unique_ptr<Widget> widget_;
TestToggleButton* button_ = nullptr;
int counter_ = 0;
DISALLOW_COPY_AND_ASSIGN(ToggleButtonTest);
};
// Starts ink drop animation on a ToggleButton and destroys the button.
// The test verifies that the ink drop layer is removed properly when the
// ToggleButton gets destroyed.
TEST_F(ToggleButtonTest, ToggleButtonDestroyed) {
EXPECT_EQ(0, counter());
gfx::Point center(10, 10);
button()->OnMousePressed(ui::MouseEvent(
ui::ET_MOUSE_PRESSED, center, center, ui::EventTimeForNow(),
ui::EF_LEFT_MOUSE_BUTTON, ui::EF_LEFT_MOUSE_BUTTON));
EXPECT_EQ(1, counter());
delete button();
EXPECT_EQ(0, counter());
}
// Make sure nothing bad happens when the widget is destroyed while the
// ToggleButton has focus (and is showing a ripple).
TEST_F(ToggleButtonTest, ShutdownWithFocus) {
button()->RequestFocus();
EXPECT_EQ(1, counter());
}
// Verify that ToggleButton::accepts_events_ works as expected.
TEST_F(ToggleButtonTest, AcceptEvents) {
EXPECT_FALSE(button()->is_on());
ui::test::EventGenerator generator(widget()->GetNativeWindow());
// Clicking toggles.
generator.ClickLeftButton();
EXPECT_TRUE(button()->is_on());
generator.ClickLeftButton();
EXPECT_FALSE(button()->is_on());
// Spacebar toggles.
button()->RequestFocus();
generator.PressKey(ui::VKEY_SPACE, ui::EF_NONE);
generator.ReleaseKey(ui::VKEY_SPACE, ui::EF_NONE);
EXPECT_TRUE(button()->is_on());
generator.PressKey(ui::VKEY_SPACE, ui::EF_NONE);
generator.ReleaseKey(ui::VKEY_SPACE, ui::EF_NONE);
EXPECT_FALSE(button()->is_on());
// Spacebar and clicking do nothing when not accepting events, but focus is
// not affected.
button()->set_accepts_events(false);
EXPECT_TRUE(button()->HasFocus());
generator.PressKey(ui::VKEY_SPACE, ui::EF_NONE);
generator.ReleaseKey(ui::VKEY_SPACE, ui::EF_NONE);
EXPECT_FALSE(button()->is_on());
generator.ClickLeftButton();
EXPECT_FALSE(button()->is_on());
// Re-enable events and clicking and spacebar resume working.
button()->set_accepts_events(true);
generator.PressKey(ui::VKEY_SPACE, ui::EF_NONE);
generator.ReleaseKey(ui::VKEY_SPACE, ui::EF_NONE);
EXPECT_TRUE(button()->is_on());
generator.ClickLeftButton();
EXPECT_FALSE(button()->is_on());
}
} // namespace views
| [
"arnaud@geometry.ee"
] | arnaud@geometry.ee |
b61bb38c670a7d989005ae62c5c3379cda5f61d0 | 04f5d9d8ce208bd9e74046655a08d2bde5e3b074 | /numbertheory/sequence.cpp | 3cfbf52dadab42b107bc909b421e51bb5065c9f5 | [] | no_license | ABHISHEKSHAH56/code | dd6f58a3218ba5f1c734df1d4f995054913abf55 | 23e284e7df7929e57caa99d7c077adcbf9ee21d1 | refs/heads/main | 2023-08-21T19:44:18.042675 | 2021-10-05T18:12:10 | 2021-10-05T18:12:10 | 391,986,981 | 0 | 1 | null | 2021-10-05T18:12:11 | 2021-08-02T14:46:43 | C++ | UTF-8 | C++ | false | false | 505 | cpp | #include <bits/stdc++.h>
using namespace std;
#define ll long long
void factorization(map<ll,int> & factor,int n)
{
for (ll i = 2; i*i <=n; ++i)
{
while(n%i==0)
{
factor[i]++;
n/=i; //agr 2 ke liye humne dekh liye tha 4 ke liya koi jaruraur t nhi hai
}
}
if (n>1)
{
factor[n]++;
}
}
int main()
{
int t;
cin>>t;
while(t--)
{
ll n;
cin>>n;
map<ll,int> factor;
factorization(factor,n);
for(auto it:factor)
{
cout<<it.first<<"^"<<it.second<<"*";
}
}
} | [
"ak8756110@gmail.com"
] | ak8756110@gmail.com |
75d7bfb10a8121ad159835a70abbf271768c04d6 | c6d1a6d219436b9b5a6719700314347a364b9c07 | /Enemy.h | 4f66da1725b71ef01959618dff99d4992f0ef5e7 | [] | no_license | seniordriver/groupwork | bd67ac3e9a027be68f171abbcd00aa54db76c2fd | 132643d60fff971317b2de7194cb87e8d79b9a39 | refs/heads/master | 2021-01-11T10:16:56.859184 | 2016-12-14T11:44:03 | 2016-12-14T11:44:03 | 72,561,342 | 0 | 2 | null | 2016-12-12T05:13:56 | 2016-11-01T17:48:51 | C++ | UTF-8 | C++ | false | false | 284 | h | #pragma once
#include "cocos2d.h"
#include "ObjectDefine.h"
USING_NS_CC;
using namespace CocosDenshion;
class Enemy {
protected:
int speed;
Sprite* enemy;
int height;
MoveBy* moveAction;
RotateBy* rotateAction;
public:
Enemy();
~Enemy();
virtual Sprite* GetSprite() = 0;
}; | [
"dorafrodo@gmail.com"
] | dorafrodo@gmail.com |
22283188b7d95b4fed42c5b43f053f5542af847d | 578db620afd29cc8942ce9ad6436e9ceb53984bc | /libraries/chain/include/snax/chain/transaction_object.hpp | 87f8fc389812aa62a206dc1eb48e4daea751b9b1 | [
"BSD-3-Clause",
"MIT",
"Apache-2.0"
] | permissive | dendisuhubdy/snax | 5b77f963c84b5c924147dc1fb715bdbda77df77d | a40402c9dc297a87f154ef39d8ebf04e5beeb0c1 | refs/heads/master | 2020-06-06T00:25:58.461651 | 2019-06-05T10:56:56 | 2019-06-05T10:56:56 | 192,587,142 | 0 | 0 | MIT | 2019-12-09T07:14:37 | 2019-06-18T17:45:20 | C++ | UTF-8 | C++ | false | false | 1,923 | hpp | /**
* @file
* @copyright defined in snax/LICENSE.txt
*/
#pragma once
#include <fc/io/raw.hpp>
#include <snax/chain/transaction.hpp>
#include <fc/uint128.hpp>
#include <boost/multi_index/hashed_index.hpp>
#include <boost/multi_index/mem_fun.hpp>
#include "multi_index_includes.hpp"
namespace snax { namespace chain {
using boost::multi_index_container;
using namespace boost::multi_index;
/**
* The purpose of this object is to enable the detection of duplicate transactions. When a transaction is included
* in a block a transaction_object is added. At the end of block processing all transaction_objects that have
* expired can be removed from the index.
*/
class transaction_object : public chainbase::object<transaction_object_type, transaction_object>
{
OBJECT_CTOR(transaction_object)
id_type id;
time_point_sec expiration;
transaction_id_type trx_id;
};
struct by_expiration;
struct by_trx_id;
using transaction_multi_index = chainbase::shared_multi_index_container<
transaction_object,
indexed_by<
ordered_unique< tag<by_id>, BOOST_MULTI_INDEX_MEMBER(transaction_object, transaction_object::id_type, id)>,
ordered_unique< tag<by_trx_id>, BOOST_MULTI_INDEX_MEMBER(transaction_object, transaction_id_type, trx_id)>,
ordered_unique< tag<by_expiration>,
composite_key< transaction_object,
BOOST_MULTI_INDEX_MEMBER( transaction_object, time_point_sec, expiration ),
BOOST_MULTI_INDEX_MEMBER( transaction_object, transaction_object::id_type, id)
>
>
>
>;
typedef chainbase::generic_index<transaction_multi_index> transaction_index;
} }
CHAINBASE_SET_INDEX_TYPE(snax::chain::transaction_object, snax::chain::transaction_multi_index)
FC_REFLECT(snax::chain::transaction_object, (expiration)(trx_id))
| [
"0.0.mad.ant@gmail.com"
] | 0.0.mad.ant@gmail.com |
fb91a33c4a357834a244b87a4e458e8d4bf11172 | 1d535fb08732b17c469027d857259bc4f3e05ce5 | /project3/Source/PluginEditor.cpp | 3d7b407540c202780c99e540868fc5ebdaad9489 | [] | no_license | mwerner1/csc344-wi14 | 8b1558f08ca098e20d8db9d0edbc289a14ce3fb0 | 18bed9b3124f05155151f6fa3cac08f52d85cd59 | refs/heads/master | 2021-01-20T03:54:44.712802 | 2014-03-19T01:57:55 | 2014-03-19T01:57:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,367 | cpp | /*
==============================================================================
This file was auto-generated by the Introjucer!
It contains the basic startup code for a Juce application.
==============================================================================
*/
#include "PluginProcessor.h"
#include "PluginEditor.h"
//==============================================================================
Project3AudioProcessorEditor::Project3AudioProcessorEditor (Project3AudioProcessor* ownerFilter)
: AudioProcessorEditor (ownerFilter),
midiKeyboard (ownerFilter->keyboardState, MidiKeyboardComponent::horizontalKeyboard),
infoLabel (String::empty),
gainLabel ("", "Throughput level:"),
delayLabel ("", "Delay:"),
cutoffLabel ("", "Cutoff Frequency:"),
gainSlider ("gain"),
delaySlider ("delay"),
cutoffSlider("freq")
{
// add some sliders..
addAndMakeVisible (gainSlider);
gainSlider.setSliderStyle (Slider::Rotary);
gainSlider.addListener (this);
gainSlider.setRange (0.0, 1.0, 0.01);
addAndMakeVisible (delaySlider);
delaySlider.setSliderStyle (Slider::Rotary);
delaySlider.addListener (this);
delaySlider.setRange (0.0, 1.0, 0.01);
addAndMakeVisible(cutoffSlider);
cutoffSlider.setSliderStyle(Slider::Rotary);
cutoffSlider.addListener(this);
cutoffSlider.setRange(100.0, 3000.0, 1.0);
// add some labels for the sliders..
gainLabel.attachToComponent (&gainSlider, false);
gainLabel.setFont (Font (11.0f));
delayLabel.attachToComponent (&delaySlider, false);
delayLabel.setFont (Font (11.0f));
cutoffLabel.attachToComponent(&cutoffSlider, false);
cutoffLabel.setFont(Font (11.0f));
// add the midi keyboard component..
addAndMakeVisible (midiKeyboard);
// add a label that will display the current timecode and status..
addAndMakeVisible (infoLabel);
infoLabel.setColour (Label::textColourId, Colours::blue);
// add the triangular resizer component for the bottom-right of the UI
addAndMakeVisible (resizer = new ResizableCornerComponent (this, &resizeLimits));
resizeLimits.setSizeLimits (150, 150, 800, 300);
// set our component's initial size to be the last one that was stored in the filter's settings
setSize (ownerFilter->lastUIWidth,
ownerFilter->lastUIHeight);
startTimer (50);
}
Project3AudioProcessorEditor::~Project3AudioProcessorEditor()
{
}
//==============================================================================
void Project3AudioProcessorEditor::paint (Graphics& g)
{
g.setGradientFill (ColourGradient (Colours::white, 0, 0,
Colours::grey, 0, (float) getHeight(), false));
g.fillAll();
}
void Project3AudioProcessorEditor::resized()
{
infoLabel.setBounds (10, 4, 400, 25);
gainSlider.setBounds (10, 60, 120, 40);
delaySlider.setBounds (140, 60, 120, 40);
cutoffSlider.setBounds(270, 60, 120, 40);
const int keyboardHeight = 70;
midiKeyboard.setBounds (4, getHeight() - keyboardHeight - 4, getWidth() - 8, keyboardHeight);
resizer->setBounds (getWidth() - 16, getHeight() - 16, 16, 16);
getProcessor()->lastUIWidth = getWidth();
getProcessor()->lastUIHeight = getHeight();
}
//==============================================================================
// This timer periodically checks whether any of the filter's parameters have changed...
void Project3AudioProcessorEditor::timerCallback()
{
Project3AudioProcessor* ourProcessor = getProcessor();
AudioPlayHead::CurrentPositionInfo newPos (ourProcessor->lastPosInfo);
if (lastDisplayedPosition != newPos)
displayPositionInfo (newPos);
gainSlider.setValue (ourProcessor->gain, dontSendNotification);
delaySlider.setValue (ourProcessor->delay, dontSendNotification);
delaySlider.setValue(ourProcessor->delay, dontSendNotification);
}
// This is our Slider::Listener callback, when the user drags a slider.
void Project3AudioProcessorEditor::sliderValueChanged (Slider* slider)
{
if (slider == &gainSlider)
{
// It's vital to use setParameterNotifyingHost to change any parameters that are automatable
// by the host, rather than just modifying them directly, otherwise the host won't know
// that they've changed.
getProcessor()->setParameterNotifyingHost (Project3AudioProcessor::gainParam,
(float) gainSlider.getValue());
}
else if (slider == &delaySlider)
{
getProcessor()->setParameterNotifyingHost (Project3AudioProcessor::delayParam,
(float) delaySlider.getValue());
}
else if (slider == &cutoffSlider)
{
getProcessor()->setParameterNotifyingHost(Project3AudioProcessor::cutoffParam,
(float) cutoffSlider.getValue());
}
}
//==============================================================================
// quick-and-dirty function to format a timecode string
static const String timeToTimecodeString (const double seconds)
{
const double absSecs = fabs (seconds);
const int hours = (int) (absSecs / (60.0 * 60.0));
const int mins = ((int) (absSecs / 60.0)) % 60;
const int secs = ((int) absSecs) % 60;
String s (seconds < 0 ? "-" : "");
s << String (hours).paddedLeft ('0', 2) << ":"
<< String (mins) .paddedLeft ('0', 2) << ":"
<< String (secs) .paddedLeft ('0', 2) << ":"
<< String (roundToInt (absSecs * 1000) % 1000).paddedLeft ('0', 3);
return s;
}
// quick-and-dirty function to format a bars/beats string
static const String ppqToBarsBeatsString (double ppq, double /*lastBarPPQ*/, int numerator, int denominator)
{
if (numerator == 0 || denominator == 0)
return "1|1|0";
const int ppqPerBar = (numerator * 4 / denominator);
const double beats = (fmod (ppq, ppqPerBar) / ppqPerBar) * numerator;
const int bar = ((int) ppq) / ppqPerBar + 1;
const int beat = ((int) beats) + 1;
const int ticks = ((int) (fmod (beats, 1.0) * 960.0 + 0.5));
String s;
s << bar << '|' << beat << '|' << ticks;
return s;
}
// Updates the text in our position label.
void Project3AudioProcessorEditor::displayPositionInfo (const AudioPlayHead::CurrentPositionInfo& pos)
{
lastDisplayedPosition = pos;
String displayText;
displayText.preallocateBytes (128);
displayText << String (pos.bpm, 2) << " bpm, "
<< pos.timeSigNumerator << '/' << pos.timeSigDenominator
<< " - " << timeToTimecodeString (pos.timeInSeconds)
<< " - " << ppqToBarsBeatsString (pos.ppqPosition, pos.ppqPositionOfLastBarStart,
pos.timeSigNumerator, pos.timeSigDenominator);
if (pos.isRecording)
displayText << " (recording)";
else if (pos.isPlaying)
displayText << " (playing)";
infoLabel.setText (displayText, dontSendNotification);
}
| [
"mwerner@calpoly.edu"
] | mwerner@calpoly.edu |
e67b2fcf72452da0ab381fcc49b608098a9c2d45 | d09945668f19bb4bc17087c0cb8ccbab2b2dd688 | /yuki/0001-1000/301-400/325.cpp | e360346d10989ef0fd4578d8c472cd533005dbb4 | [] | no_license | kmjp/procon | 27270f605f3ae5d80fbdb28708318a6557273a57 | 8083028ece4be1460150aa3f0e69bdb57e510b53 | refs/heads/master | 2023-09-04T11:01:09.452170 | 2023-09-03T15:25:21 | 2023-09-03T15:25:21 | 30,825,508 | 23 | 2 | null | 2023-08-18T14:02:07 | 2015-02-15T11:25:23 | C++ | UTF-8 | C++ | false | false | 1,569 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef signed long long ll;
#undef _P
#define _P(...) (void)printf(__VA_ARGS__)
#define FOR(x,to) for(x=0;x<(to);x++)
#define FORR(x,arr) for(auto& x:arr)
#define ITR(x,c) for(__typeof(c.begin()) x=c.begin();x!=c.end();x++)
#define ALL(a) (a.begin()),(a.end())
#define ZERO(a) memset(a,0,sizeof(a))
#define MINUS(a) memset(a,0xff,sizeof(a))
//-------------------------------------------------------
int X1,X2,Y1,Y2,D;
ll hoge(ll x1,ll x2,ll y1,ll y2,ll D) {
if(x1+y1>D) return 0;
if(x2+y2<=D) return (y2-y1+1)*(x2-x1+1);
D-=x1+y1;
x2-=x1;
y2-=y1;
ll ret=0;
if(D>y2) {
ret=(D-y2)*(y2+1);
x2 -= D-y2;
D=y2;
}
x2=min(x2,D);
return ret+(D+1+(D+1-x2))*(x2+1)/2;
}
ll range(ll a,ll b,ll D) {
ll l=-D,r=D;
l=max(a,-D);
r=min(b,D);
if(r<l) return 0;
return (r-l)+1;
}
void solve() {
int i,j,k,l,r,x,y; string s;
cin>>X1>>Y1>>X2>>Y2>>D;
ll ret=0;
if(X2<0) X1=-X1,X2=-X2,swap(X1,X2);
if(Y2<0) Y1=-Y1,Y2=-Y2,swap(Y1,Y2);
ret += hoge(max(1,X1),X2,max(1,Y1),Y2,D);
if(X1<0) ret += hoge(1,-X1,max(1,Y1),Y2,D);
if(Y1<0) ret += hoge(max(1,X1),X2,1,-Y1,D);
if(X1<0 && Y1<0) ret += hoge(1,-X1,1,-Y1,D);
if(X1<=0) ret+=range(Y1,Y2,D);
if(Y1<=0) ret+=range(X1,X2,D);
if(X1<=0 && Y1<=0) ret--;
cout<<ret<<endl;
}
int main(int argc,char** argv){
string s;int i;
if(argc==1) ios::sync_with_stdio(false);
FOR(i,argc-1) s+=argv[i+1],s+='\n';
FOR(i,s.size()) ungetc(s[s.size()-1-i],stdin);
solve(); return 0;
}
| [
"kmjp@users.noreply.github.com"
] | kmjp@users.noreply.github.com |
0b3ccf8c757abe7f7424c69da58875559631d012 | ad0e022975ffb0c04ae825afc4786d0e50490ff3 | /include/message_wrap.h | 21d01fa8c6f5158d05214aa3805467a628bde077 | [] | no_license | DistributedRSP/WSP | 13480a88085f15265f23de66d28c102aeed69f3e | 531a8bc6e1f22ca79f50ecdc3b3ba22a2c02b43e | refs/heads/master | 2021-05-03T21:54:52.431659 | 2017-05-06T14:46:13 | 2017-05-06T14:46:13 | 71,571,328 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,866 | h | /**
* @file message_wrap.h
* @brief Wrapped send/recv functions(through thread_id)
*/
#pragma once
#include "query_basic_types.h"
#include "network_node.h"
#include "rdma_resource.h"
#include "thread_cfg.h"
#include "global_cfg.h"
#include "stream_adaptor_interface.h"
#include "stream_query_client.h"
#include "stream_coordinator.h"
#include "metadata_manager.h"
// request or reply
void SendR(thread_cfg* cfg,int r_mid,int r_tid,request_or_reply& r);
request_or_reply RecvR(thread_cfg* cfg);
bool TryRecvR(thread_cfg* cfg,request_or_reply& r);
bool TryTargetRecvR(thread_cfg* cfg, int r_mid, request_or_reply& r);
// dispatch_packet
void SendT(thread_cfg* cfg, int r_mid, int r_tid, stream_dispatch_packet &packet);
//void RecvT(thread_cfg* cfg, int r_mid, stream_dispatch_packet &packet);
bool TryRecvT(thread_cfg* cfg, int r_mid, stream_dispatch_packet &packet);
// vector timestamp
void SendC(thread_cfg* cfg, int r_mid, int r_tid, stream_vector_clock& clock);
bool TryRecvC(thread_cfg* cfg, int r_mid, stream_vector_clock& clock);
// metadata cache packet
void SendM(thread_cfg* cfg, int r_mid, int r_tid, metadata_cache_packet &packet);
bool TryRecvM(thread_cfg* cfg, int r_mid, metadata_cache_packet &packet);
// optimized metadata packet
/* void SendMOpt(thread_cfg* cfg, int r_mid, int r_tid, forward_star_packet &packet); */
/* void RecvMOpt(thread_cfg* cfg, int r_mid, forward_star_packet &packet); */
template<typename T>
void SendObject(thread_cfg* cfg,int r_mid,int r_tid,T& r){
std::stringstream ss;
boost::archive::binary_oarchive oa(ss);
oa << r;
cfg->node->Send(cfg->m_id, r_mid,r_tid,ss.str());
}
template<typename T>
T RecvObject(thread_cfg* cfg){
std::string str;
str=cfg->node->Recv();
std::stringstream s;
s << str;
boost::archive::binary_iarchive ia(s);
T r;
ia >> r;
return r;
}
| [
"imac@imac.ipads-lab.se.sjtu.edu.cn"
] | imac@imac.ipads-lab.se.sjtu.edu.cn |
1c653c3ee9f1910043c411f22e7af8cf14af2a5e | 0eff74b05b60098333ad66cf801bdd93becc9ea4 | /second/download/CMake/CMake-gumtree/Kitware_CMake_repos_basic_block_block_3539.cpp | 21b97a8409546a7159c909c688ba1078fde0c6e8 | [] | no_license | niuxu18/logTracker-old | 97543445ea7e414ed40bdc681239365d33418975 | f2b060f13a0295387fe02187543db124916eb446 | refs/heads/master | 2021-09-13T21:39:37.686481 | 2017-12-11T03:36:34 | 2017-12-11T03:36:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 44 | cpp | (uc != BZ_HDR_B) RETURN(BZ_DATA_ERROR_MAGIC) | [
"993273596@qq.com"
] | 993273596@qq.com |
d75d195330227ca321dc1c0c7f2eb67df8748523 | 589074033d87a96607d725d350459710e10d8922 | /SchoolGirl.h | fc0c61b71044466864b0826403e00437a12d6deb | [] | no_license | cksdud5549/River-City | 1da65849d2de74d642e25ab9ffbd7ed32ddb1d02 | 629550b1103e243f8fa757253da73eba8237781c | refs/heads/master | 2022-12-07T18:06:42.745615 | 2020-09-09T02:38:15 | 2020-09-09T02:38:15 | 293,982,289 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 364 | h | #pragma once
#include "Enemy.h"
class SchoolGirl : public Enemy
{
public:
HRESULT init(float centerX, float centerY, bool isRight)override;
void ImgInit()override;
void update()override;
static void RIdle(void* obj);
static void LIdle(void* obj);
void Move()override;
void BeShot()override;
void AnimReSet()override;
void UpdateCollison()override;
};
| [
"chanyounh9@gmail.com"
] | chanyounh9@gmail.com |
22683843cc98dc580f9f8476fc3942f3e7127731 | 71b484c1a6864fdd158c58f18c716c0a96918842 | /leakV3.1.cpp | e3993e443b8e8a44d68fcddadd5f21add9ea0a90 | [] | no_license | AwaleSajil/Poploon | 66db09dedb11408e0b0cc6861808be7c95e35c1a | fdf357bb6da8ed09c64a7e4a969b8d1f8d4fb8a6 | refs/heads/master | 2020-04-08T03:52:16.566268 | 2018-12-10T15:44:07 | 2018-12-10T15:44:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 19,066 | cpp | #include <stdio.h>
#include <stdlib.h>
#include <graphics.h>
#include <conio.h>
#include <dos.h>
#include <time.h>
#include <math.h>
#define TITLE "Pooploon"
#define SCREEN_WIDTH 800 //1360
#define SCREEN_HEIGHT 600 //700
#define oTARGET_WIDTH 142
#define TARGET_HEIGHT 240
#define ycen 175 //y cordinate center of ellipse
#define xcen -79 // x cordinate center of ellipse
#define sr 65 // radius of smaller balloon
#define br 85 // radius of bigger radius
#define NO_BU 100 /*currently this is the variable that controls how many bubble will be produced*/
#define H_S_LOCATION "HighScore.dat"
#define B_DEL 400
#define TOP_SC 10
typedef struct screen
{
int c:12; // c for counters i.e i,j,k,l,m
int cy:12; // for uncertinity of y
int asize:12; //for storing the size (radius)of bubble in the screen
unsigned int color:4; // 0 to 2^4-1 = 15
}s;
typedef struct score_data
{
char name[51]; //not sure how to input string in graphics mode
unsigned int score;
char date_t[31];
}h_s_d;
typedef struct addtional_info
{
int indi; // indicates how many bullunes are on memory/have been created
int saver1; // for CPU efficency
int ssh; // ssh --> stop scoring high
unsigned int prev_click:1; //for ckhech_w_b function logic
}inf;
// prototype area
void over(int score,char *reason);
int score_keeper(int change);
int check_w_b(s **sp, inf *inf1);
int rnd(int ll, int hl);
int rd();
void late_process(int *late, int score);
int bu_gen(s **sp,inf *inf1);
void target_box();
s *allocate_the_memory();
int welcom();
int c_fptr(FILE *fptr);
int check_h_m_h_s_i_f();
void want_ur_name(h_s_d *h)
{
closegraph();
puts("Enter your name for High Score\n");
fflush(stdin);
scanf("%s",(h->name));
puts("\nThanks, You can press Enter to return to Gaming");
fflush(stdin);
getchar();
initwindow(SCREEN_WIDTH,SCREEN_HEIGHT,TITLE,true,true);
}
int UP_SCORE(s **sp, int t_b)
{
POINT m_po;
int d; //distance
int score;
GetCursorPos(&m_po);
d = sqrt(pow((xcen+sp[t_b]->c) - (m_po.x),2) + pow((ycen+sp[t_b]->cy) - (m_po.y-15),2));
if(d == 0) return ((sp[t_b]->asize));
score = (sp[t_b]->asize)/(d);
return score;
}
int D_h_s_sort() //returns 0 if sucessfull
{
int struct_size, i, j;
h_s_d h1, h2;
struct_size = sizeof(h1);
FILE * fptr = fopen(H_S_LOCATION,"rb+");
if(c_fptr(fptr)) return 1;
fseek(fptr, 0, SEEK_END); //go to end of file
int file_size = ftell(fptr);
rewind(fptr); //go to begining of file
for (i = 0; i < file_size; i += struct_size)
{
for (j = 0; j < file_size - struct_size; j += struct_size)
{
fread(&h1, struct_size, 1, fptr); //rem that poniter itself moved by 1 high score data so no need to move it manually
fread(&h2, struct_size, 1, fptr);
if (h1.score < h2.score)
{
fseek(fptr, -(struct_size * 2), SEEK_CUR);
fwrite(&h2, struct_size, 1, fptr);
fwrite(&h1, struct_size, 1, fptr);
fseek(fptr, -struct_size, SEEK_CUR);
}
else
{
fseek(fptr, -struct_size, SEEK_CUR);
}
}
rewind(fptr);
}
fclose(fptr);
return 0;
}
int save_h_s_iff(int score) //save high score if and only if complex condition satisfy
{
h_s_d h;
time_t the_time = time(NULL);
FILE *fptr = fopen(H_S_LOCATION,"rb+");
if(c_fptr(fptr)) return 0;
h.score = score;
strcpy(h.date_t,ctime(&the_time));
if(check_h_m_h_s_i_f() < 11)
{
want_ur_name(&h);
fseek(fptr,0,SEEK_END); //to continue writing
if(fwrite(&h,sizeof(h),1,fptr) < 1)
{
perror("Could not save high score " H_S_LOCATION);
fclose(fptr);
return 0;
}
fclose(fptr);
return 1; //this function returns 1 if successfull
}
else
{
h_s_d h1;
want_ur_name(&h);
fseek(fptr,-sizeof(h1),SEEK_END);
fwrite(&h, sizeof(h1), 1, fptr);
fclose(fptr);
return 1;
}
fclose(fptr);
return 0;
}
int is_it_h_s(int score)
{
FILE *fptr = fopen(H_S_LOCATION,"rb");
h_s_d h1;
if(c_fptr(fptr)) return 0;
if(check_h_m_h_s_i_f() < TOP_SC)
{
fclose(fptr);
return 1;
}
D_h_s_sort();
fseek(fptr,-sizeof(h1),SEEK_END);
fread(&h1,sizeof(h1),1,fptr);
if(h1.score < score)
{
fclose(fptr);
return 1;
}
fclose(fptr);
return 0;
}
void free_rem_sp(s **sp, int saver1,int iPlus1)
{
int i;
for(i=saver1;i<iPlus1;i++)
{
free(sp[i]);
}
free(sp);
}
int c_fptr(FILE *fptr)
{
if(fptr == NULL)
{
perror("Coulnot Open "H_S_LOCATION);
return 1;
}
return 0;
}
void b_but(int x, int y, char str[], int color)
{
setcolor(color);
outtextxy(x,y,str);
}
int check_h_m_h_s_i_f() //check how many high score data is in the file + it creates the file H_S_LOCATION.dat if absent
{
int i;
h_s_d temp;
FILE *fptr = fopen(H_S_LOCATION,"ab"); // create the file H_S_Location.dat if absent
if(c_fptr(fptr)) exit(1); //checks fptr
fclose(fptr);
fptr = fopen(H_S_LOCATION,"rb");
if(c_fptr(fptr)) exit(1);
for(i=0;fread(&temp,sizeof(temp),1,fptr) == 1;i++); //second opton of this code is to use fseek and ftell divid by sizeof temp fclose(fptr);
fclose(fptr);
return i;
}
void over(int score,char reason[])
{
char g_over[] = "GAME OVER !!!";
char sc[15];
int bkcolor = 0; //black
int localbol = is_it_h_s(score);
if(localbol) bkcolor = 4; //red
setbkcolor(bkcolor);
settextstyle(3,0,8);
outtextxy((getmaxx()/2)-(textwidth(g_over)/2),(getmaxy()/2)-(textheight(g_over)/2),g_over);
sprintf(sc,"Score is %d",score);
settextstyle(3,0,2);
outtextxy((getmaxx()/2)-(textwidth(reason)/2),(getmaxy()/2)-3*(textheight(reason)),reason);
settextstyle(3,0,5);
outtextxy((getmaxx()/2)-(textwidth(sc)/2),(getmaxy()/2)+(textheight(sc)/1.5),sc);
delay(3000);
if(localbol)
save_h_s_iff(score);
return;
}
int score_keeper(int change)
{
static int sc_n=0; //score in numbers
char score[101];
sc_n += change;
sprintf(score,"Score: %d",sc_n);
settextstyle(3,0,3);
b_but(getmaxx()-textwidth(score),textheight(score),score,BLACK);
setcolor(WHITE);
return sc_n;
}
int check_w_b(s **sp, inf *inf1)
{
int i;
static int prev_i;
POINT m_po;
GetCursorPos(&m_po);
for(i=(inf1->saver1);i<(inf1->indi);i++)
{
int t = sp[i]->asize; //max distance
int d = sqrt(pow((xcen+sp[i]->c) - (m_po.x),2) + pow((ycen+sp[i]->cy) - (m_po.y-15),2)); //distance between pointer and bubble center
sp[i]->cy = rnd(-TARGET_HEIGHT/4,TARGET_HEIGHT/4); //randomize y cordinates
if(d<=t && d>=(-t))
{
if(prev_i != i)
inf1->ssh = 0; //reset the stop score high(ssh) if new bullune is on the target
if(sp[i]->color != 15)
{
return (prev_i=i);
}
if(sp[i]->color == 15 && inf1->prev_click == 1)
return (prev_i=i);
}
}
return -1; // i.e no bullunes lie at that position
}
int rnd(int ll, int hl) // for generating random numbers from lower limit ll, to higher limit hl
{
int a;
static int i=0;
time_t raw_time = time(NULL);
srand(raw_time);
(++i)%2 == 0 ? a = M_PI*rand() : ((i++)%3 == 0) ? a = sqrt(2)*rand() : a = sqrt(3)*rand();
return (a%(hl-ll+1) + ll);
}
int rd()
{
if(rnd(0,1))
return br;
else
return sr;
}
void late_process(int *late, int score)
{
if(score<5)
*late = 4;
else if(score<25)
*late = 3;
else if (score<50)
*late = 2;
else if (score<75)
*late = 1;
else if (score<100)
*late = 0;
else
*late = rnd(0,5);
}
int bu_gen(s **sp,inf *inf1)
{
POINT m_po; // declare a variable for mouse position
int i;
int b_t_r; // is boolen variable for knowing if the mouse is witnin the target box
static int page=0, late = 4;
setactivepage(page);
setvisualpage(1-page);
cleardevice();
setlinestyle(0,0,2);
if(!(GetAsyncKeyState(VK_LBUTTON) || GetAsyncKeyState(VK_RBUTTON)))
inf1->prev_click = 0;
for(i=(inf1->saver1);i<(inf1->indi);i++)
{
setcolor(WHITE);
setfillstyle(1,sp[i]->color);
fillellipse(xcen+sp[i]->c,ycen+sp[i]->cy,sp[i]->asize,sp[i]->asize);// bubbles
setcolor(sp[i]->color);
line(xcen+sp[i]->c,ycen+sp[i]->cy+sp[i]->asize,xcen+sp[i]->c,ycen+sp[i]->cy+sp[i]->asize+sr*1.5); //string of bubble
}
GetCursorPos(&m_po);
setfillstyle(1,WHITE); setcolor(RED);
fillellipse(m_po.x,m_po.y-15,5,3); // mouse center pointer
b_t_r = ((m_po.x)>=((SCREEN_WIDTH-oTARGET_WIDTH)/2) && (m_po.x)<=((SCREEN_WIDTH+oTARGET_WIDTH)/2) && (m_po.y-15)>=(ycen-TARGET_HEIGHT/2) && (m_po.y-15)<=(ycen+TARGET_HEIGHT/2));
int t_b = check_w_b(sp,inf1); //check_which_bubble lies in the target area and store it's i value(identifier) of bubble to t_b
if((GetAsyncKeyState(VK_LBUTTON) || GetAsyncKeyState(VK_RBUTTON)) && t_b == -1 && inf1->prev_click == 0)
{
setvisualpage(page);
cleardevice();
over(score_keeper(0),"No Balloon there");
return 0;
}
if((GetAsyncKeyState(VK_LBUTTON) || GetAsyncKeyState(VK_RBUTTON))&&((inf1->ssh)++) == 0)
{
if(GetAsyncKeyState(VK_LBUTTON)&& sp[t_b]->asize == sr && b_t_r && inf1->prev_click==0)
{
setcolor(sp[t_b]->color = 15); //disappear the bubble(white)
score_keeper(UP_SCORE(sp,t_b));
inf1->prev_click = 1;
}
else if(GetAsyncKeyState(VK_RBUTTON) && sp[t_b]->asize == br && b_t_r && inf1->prev_click==0)
{
setcolor(sp[t_b]->color = 15); //disappear the bubble
score_keeper(UP_SCORE(sp,t_b));
inf1->prev_click = 1;
}
else if(!b_t_r)
{
setvisualpage(page);
cleardevice();
over(score_keeper(0),"Your cursor is outside target box");
return 0;
}
else if(inf1->prev_click==0)
{
setvisualpage(page);
cleardevice();
over(score_keeper(0),"Wrong Click for ballon");
return 0;
}
}
page = 1-page;
late_process(&late,score_keeper(0));
delay(late);
return 1;
}
void target_box()
{
setlinestyle(1,0,1);
setcolor(RED);
line(SCREEN_WIDTH/2,ycen-TARGET_HEIGHT/2,SCREEN_WIDTH/2,ycen-TARGET_HEIGHT/2+TARGET_HEIGHT/16); //vertical line obserable
line(SCREEN_WIDTH/2,ycen+TARGET_HEIGHT/2,SCREEN_WIDTH/2,ycen+TARGET_HEIGHT/2-TARGET_HEIGHT/16); //vertical line obserable
line(SCREEN_WIDTH/2-oTARGET_WIDTH/2,ycen,SCREEN_WIDTH/2-oTARGET_WIDTH/2+oTARGET_WIDTH/16,ycen); //horizontal line
line(SCREEN_WIDTH/2+oTARGET_WIDTH/2,ycen,SCREEN_WIDTH/2+oTARGET_WIDTH/2-oTARGET_WIDTH/16,ycen); //horizontal line
setlinestyle(0,0,3);
rectangle((SCREEN_WIDTH-oTARGET_WIDTH)/2, ycen-TARGET_HEIGHT/2,(SCREEN_WIDTH+oTARGET_WIDTH)/2,ycen+TARGET_HEIGHT/2);
}
s *allocate_the_memory()
{
s *ptr = (s *)malloc(28);
if(ptr == NULL)
{
puts("Malloc failed");
delay(1000);
exit(1);
}
return ptr;
}
void new_game()
{
initwindow(SCREEN_WIDTH,SCREEN_HEIGHT,TITLE,true,true);
s *sp[NO_BU+1]; // array to store address ,+1 is not for terminating/ null char but is for error free in comming lines
inf inf1;
inf1.ssh = inf1.saver1 = inf1.prev_click= 0;
int GAP,i;
setlinestyle(SOLID_LINE,0,1);
setbkcolor(WHITE);
for(i=0;i<NO_BU;i++)
{
if(i==0)
{
sp[i] = allocate_the_memory();
sp[i]->asize=rd();
}
sp[i+1] = allocate_the_memory();
for(sp[i]->c=1,sp[i+1]->asize=rd(),sp[i]->color=rnd(0,14),inf1.indi=i+1;;) //i is the identifier of each bubblne here
{
int j;
//runs only 1 time for one bullune
if(sp[i]->c==1)
{
if(sp[i]->asize == sp[i+1]->asize) // if consecutive bubble are of same size
{
if(sp[i]->asize == sr)
GAP = rnd(2*sr, 3*sr); // max gap between consecutive small bubble is 1.5 times min GAP
else //if(s1.asize[i] == br)
GAP = rnd(2*br, 3*br); // max gap between consecutive big bubble is 1.5 times min GAP
}
else
{
GAP = rnd(sr+br, 2*sr+br); // max limit is approx 1.5 times min vlaue for current value
}
}
if(sp[i]->c%GAP==0) //c for counter
break;
if(bu_gen(sp, &inf1) != 1)
{
free_rem_sp(sp,inf1.saver1,i+1);
score_keeper(-score_keeper(0)); //reset the score to 0 for new game
return;
}
target_box();
score_keeper(0); // display current score
for(j=(inf1.saver1);j<=i;j++) //all the necessery increments for making all booluns moving
(sp[j]->c)++;
if((xcen+sp[inf1.saver1]->c) > getmaxx()+br)
{
free(sp[(inf1.saver1)]);
inf1.saver1++;
}
}
}
getch();
closegraph();
}
int ycalc(int nt,int n,int font, int txt_size)
{
int total_heit,y,padding=10,txt_heit;
settextstyle(font,0,txt_size);
txt_heit = textheight("A");
total_heit = nt*txt_heit + (nt-1)*padding;
y = (SCREEN_HEIGHT/2 - total_heit/2) +(n-1)*(txt_heit + padding);
return y;
}
int button(int y, char *but_nam)
{
int txt_color , b_bool; //black by default
POINT m_po;
settextstyle(8,0,5);
GetCursorPos(&m_po);
b_bool = m_po.x > (SCREEN_WIDTH/2 - textwidth(but_nam)/2) && m_po.x < (SCREEN_WIDTH/2 + textwidth(but_nam)/2) && (m_po.y-15) > (y) && (m_po.y-15) < (y+textheight(but_nam));
txt_color = b_bool ? 2:0; //green
if(b_bool && GetAsyncKeyState(VK_LBUTTON))
{
b_but(SCREEN_WIDTH/2 - textwidth(but_nam)/2, y, but_nam, 11);
delay(B_DEL);
if(!GetAsyncKeyState(VK_LBUTTON)) //extra protection
return 1;
}
b_but(SCREEN_WIDTH/2 - textwidth(but_nam)/2, y, but_nam, txt_color);
return 0;
}
int welcom()
{
initwindow(SCREEN_WIDTH,SCREEN_HEIGHT,TITLE,true,true);
char ne_gam[] = "New Game";
char high_sc[] = "High Score";
char close[] = "Exit";
char title[] = TITLE;
char we[][21] = {"Sajil Awale","Shrey Niraula","Pratik Luitel","Pujan Budhathoki"};
int sep;
int i, sum=0;
int nt = 4; //no of buttons
cleardevice();
// names
{
setbkcolor(WHITE);
settextstyle(1,0,1);
sep = (SCREEN_WIDTH - textwidth(we[0]) -textwidth(we[1]) -textwidth(we[2]) -textwidth(we[3]))/5;
for(i=0;i<4;i++)
{
b_but((i+1)*sep+sum,SCREEN_HEIGHT-2*textheight(we[0]),we[i],i+2);
sum += textwidth(we[i]);
}
}
floodfill(SCREEN_WIDTH-1,SCREEN_HEIGHT-1,WHITE); // for white background
// for title
{
setcolor(5);
settextstyle(3,0,7);
b_but(SCREEN_WIDTH/2-textwidth(title)/2,SCREEN_HEIGHT/10,title,5);
}
for(;;)
{
//buttons
line(SCREEN_WIDTH/2-textwidth(ne_gam)/2,ycalc(nt,1,8,5),SCREEN_WIDTH/2+textwidth(ne_gam)/2,ycalc(nt,1,8,5));
line(SCREEN_WIDTH/2-textwidth(high_sc)/2,ycalc(nt,4,8,5)+textheight(high_sc),SCREEN_WIDTH/2+textwidth(high_sc)/2,ycalc(nt,4,8,5)+textheight(high_sc));
if(button(ycalc(nt,1,8,5),ne_gam)) return 0; //New game button
if(button(ycalc(nt,4,8,5),high_sc)) return 1; //high score button
if(button(SCREEN_HEIGHT-2*textheight(close),close)) return -1; // exit button
delay(50);
}
getch();
}
int print_h_s()
{
initwindow(SCREEN_WIDTH,SCREEN_HEIGHT,TITLE,true,true);
FILE *fptr;
h_s_d h1;
int i;
char h_s_s[]= "High Scores";
char g_b_w_s[] = "Go Back";
fptr = fopen(H_S_LOCATION,"rb");
cleardevice();
setcolor(5);
floodfill(SCREEN_WIDTH-1,SCREEN_HEIGHT-1,WHITE); // for white background
setbkcolor(WHITE);
if(c_fptr(fptr)) return 0;
if(check_h_m_h_s_i_f() == 0)
{
char nofile[] = "Looks like it's you first time";
b_but(SCREEN_WIDTH/2-textwidth(nofile)/2,SCREEN_HEIGHT/2-textheight(nofile)/2,nofile,0);
}
// title i.e High score
if(D_h_s_sort()) puts("High score couldnot be sort"); //sort highscore in descending order
settextstyle(8,0,5);
b_but(SCREEN_WIDTH/2-textwidth(h_s_s)/2,textheight(h_s_s)/2,h_s_s,0);
settextstyle(8,0,3);
for(i=0;fread(&h1,sizeof(h1),1,fptr) == 1; i++) //fread returns 1 if they were sucessful
{
char buffer[300];
sprintf(buffer,"#%2d: %-7s : %d :On %s",i+1,h1.name,h1.score,h1.date_t);
b_but(SCREEN_WIDTH/2-textwidth(buffer)/2,2*textheight(h_s_s)+(i+1)*textheight(buffer),buffer,0);
}
fclose(fptr);
for(;;)
if(button(SCREEN_HEIGHT-1.5*textheight(g_b_w_s),g_b_w_s)) return 1; //go back to welcome screen
return 0;
}
int main()
{
int gd = DETECT, gm;
check_h_m_h_s_i_f(); // to create file if not created
for(;;)
{
int r = welcom();
closegraph();
if(r == 0)
{
new_game();
closegraph();
}
else if(r == 1)
{
if(print_h_s()==1)
{
closegraph();
continue;
}
getch();
closegraph();
}
else if(r == -1)
break;
}
closegraph();
return 0;
}
| [
"Home@Homes-MacBook-Air.local"
] | Home@Homes-MacBook-Air.local |
ecda22d7d2e1ad464007fe27db8048a7c6a8b6b8 | 2786c37ab338ed279aa2a535d9a8143aa2e82b57 | /libs/foe_physics/libs/imgui/src/registration.cpp | 741c226b730be088bfdf0b26526773fd07952cdd | [
"Apache-2.0",
"MIT"
] | permissive | StableCoder/foe-engine | 12cdcc226bb5d1941adb72b53f8fc159ed7533c6 | b494fad60a36f0b11c526a5648277643edd4095f | refs/heads/main | 2023-08-21T18:30:50.777210 | 2023-08-21T00:33:05 | 2023-08-21T00:33:05 | 307,215,754 | 16 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 2,321 | cpp | // Copyright (C) 2021-2023 George Cave.
//
// SPDX-License-Identifier: Apache-2.0
#include <foe/physics/imgui/registration.hpp>
#include <foe/physics/component/rigid_body_pool.h>
#include <foe/physics/type_defs.h>
#include <foe/simulation/imgui/registrar.hpp>
#include <foe/simulation/simulation.hpp>
#include "collision_shape.hpp"
#include "rigid_body.hpp"
namespace {
void imgui_foePhysicsComponent(foeEntityID entity, foeSimulation const *pSimulation) {
// foeRigidBody
foeRigidBodyPool rigidBodyPool = (foeRigidBodyPool)foeSimulationGetComponentPool(
pSimulation, FOE_PHYSICS_STRUCTURE_TYPE_RIGID_BODY_POOL);
if (rigidBodyPool != FOE_NULL_HANDLE) {
foeEntityID const *const pStartID = foeEcsComponentPoolIdPtr(rigidBodyPool);
foeEntityID const *const pEndID = pStartID + foeEcsComponentPoolSize(rigidBodyPool);
foeEntityID const *pID = std::lower_bound(pStartID, pEndID, entity);
if (pID != pEndID && *pID == entity) {
size_t offset = pID - pStartID;
foeRigidBody *pRigidBodyData =
(foeRigidBody *)foeEcsComponentPoolDataPtr(rigidBodyPool) + offset;
imgui_foeRigidBody(pRigidBodyData);
}
}
}
void imgui_foePhysicsResource(foeResourceBase const *pResourceData) {
if (pResourceData->rType == FOE_PHYSICS_STRUCTURE_TYPE_COLLISION_SHAPE)
imgui_foeCollisionShape((foeCollisionShape const *)pResourceData);
}
void imgui_foePhysicsResourceCreateInfo(foeResourceCreateInfo createInfo) {
if (foeResourceCreateInfoGetType(createInfo) ==
FOE_PHYSICS_STRUCTURE_TYPE_COLLISION_SHAPE_CREATE_INFO)
imgui_foeCollisionShapeCreateInfo(
(foeCollisionShapeCreateInfo const *)foeResourceCreateInfoGetData(createInfo));
}
} // namespace
foeResultSet foePhysicsImGuiRegister(foeSimulationImGuiRegistrar *pRegistrar) {
return pRegistrar->registerElements(imgui_foePhysicsComponent, imgui_foePhysicsResource,
imgui_foePhysicsResourceCreateInfo, nullptr);
}
foeResultSet foePhysicsImGuiDeregister(foeSimulationImGuiRegistrar *pRegistrar) {
return pRegistrar->deregisterElements(imgui_foePhysicsComponent, imgui_foePhysicsResource,
imgui_foePhysicsResourceCreateInfo, nullptr);
} | [
"gcave@stablecoder.ca"
] | gcave@stablecoder.ca |
043f223c04f6c316910b7689fe5bea61080ddc16 | bdeec2a01f17d9b9e4c6f09009be5b8efb5597a7 | /College/Data Structure/avl1.cpp | 26ae6efd078d67b717c69dfcc3a1ed3990fe08f9 | [] | no_license | Naveen110501/Competitive-Programming-Using-OOPS | 175ad00800fff1635b2668b87e66bed3dc1fa501 | 072cac217d71239b7972a2da81716a14efef295b | refs/heads/master | 2023-02-15T01:27:28.158479 | 2021-01-05T11:40:31 | 2021-01-05T11:40:31 | 292,193,831 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,317 | cpp | #include<iostream>
using namespace std;
class Node
{
public:
int key;
Node *left;
Node *right;
int height;
};
int max(int a, int b);
{
return (a>b)?a:b;
}
int height(Node *N)
{
if (N == NULL)
return 0;
return N->height;
}
int max(int a, int b)
{
return (a > b)? a : b;
}
Node* newNode(int data)
{
Node* node = new Node();
node->data = data;
node->left = NULL;
node->right = NULL;
node->height = 1;
return(node);
}
Node *rightRotate(Node *y)
{
Node *x = y->left;
Node *T2 = x->right;
x->right = y;
y->left = T2;
y->height = max(height(y->left),
height(y->right)) + 1;
x->height = max(height(x->left),
height(x->right)) + 1;
return x;
}
Node *leftRotate(Node *x)
{
Node *y = x->right;
Node *T2 = y->left;
y->left = x;
x->right = T2;
x->height = max(height(x->left),
height(x->right)) + 1;
y->height = max(height(y->left),
height(y->right)) + 1;
return y;
}
int getBalance(Node *N)
{
if (N == NULL)
return 0;
return height(N->left) - height(N->right);
}
Node* insert(Node* node, int data)
{
if (node == NULL)
return(newNode(data));
if (key < node->data)
node->left = insert(node->left, data);
else if (key > node->data)
node->right = insert(node->right, data);
else
return node;
node->height = 1 + max(height(node->left),
height(node->right));
int balance = getBalance(node);
if (balance > 1 &&data<node->left->data)
return rightRotate(node);
if (balance > 1 &&data<de->right->data)
return leftRotate(node);
if (balance > 1 && key > node->left->key)
{
node->left = leftRotate(node->left);
return rightRotate(node);
}
if (balance < -1 && key < node->right->key)
{
node->right = rightRotate(node->right);
return leftRotate(node);
}
return node;
}
void preOrder(Node *root)
{
if(root != NULL)
{
cout<< root->key << " ";
preOrder(root->left);
preOrder(root->right);
}
}
int main()
{
Node *root = NULL;
root = insert(root, 10);
root = insert(root, 20);
root = insert(root, 30);
root = insert(root, 40);
root = insert(root, 50);
root = insert(root, 25);
cout<< "Preorder traversal of the "
"constructed AVL tree is \n";
preOrder(root);
return 0;
}
| [
"70461604+Naveen110501@users.noreply.github.com"
] | 70461604+Naveen110501@users.noreply.github.com |
b487e365154934ad089d9d5e9b03c7cbfaac0829 | 155e12d1b6e8cacd27d8bd773b592876d8cd9829 | /Game/Enemy/State/LongBigState/EnemyLongBigTargetingState.h | 2e7bf50465ab5ada4cee0e2d977a9adc133bc997 | [] | no_license | kokoasann/UsualEngineR | dd6606f72b719ea1e3d684bde59af90f2a981280 | cf803f96c3520bd485282c680be29f5248737b26 | refs/heads/master | 2023-03-07T12:18:52.795038 | 2021-02-25T17:21:59 | 2021-02-25T17:21:59 | 291,441,353 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 590 | h | #pragma once
#include "Enemy/State/IEnemyState.h"
#include "EnemyLongBigAttackState.h"
class EnemyLongBigTargetingState final : public IEnemyState
{
public:
EnemyLongBigTargetingState();
~EnemyLongBigTargetingState();
void Init(IK* ik, Quaternion& rot, float bulletSpeed);
void Enter(IEnemy* e) override;
IEnemyState* Update(IEnemy* e) override;
void Exit(IEnemy* e) override;
private:
EnemyLongBigAttackState m_lba;
IK* m_ik = nullptr;
float m_timer = 0.f;
const float m_timeLimit = 2.f;
Quaternion* m_rot = nullptr;
float m_speed = 0.f;
float m_overLookRange = 300.f;
};
| [
"1"
] | 1 |
f64b493d7a4f456a70e5e504bd3d4c4c0efa36cb | f6d3073fd746a71cb00e8a0d5dc4f42732eca956 | /src/Memoria/Source/Memoria/Public/LevelDataAsset.h | 1d947a167f5f385a468817caf58be76c4bdccd98 | [] | no_license | ditan96/rc-memoria | 95f8643e3ac5c1c55a4e6a910932c8e3e39f48b3 | a8c540dab55df000d7d2465ad650cd8dafdbef5f | refs/heads/master | 2022-11-05T15:46:16.783600 | 2019-11-20T04:13:49 | 2019-11-20T04:13:49 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 942 | h | // Fill out your copyright notice in the Description page of Project Settings.
#pragma once
#include "CoreMinimal.h"
#include "Engine/DataAsset.h"
#include "WaveLayout.h"
#include "LevelDataAsset.generated.h"
class AGameStateBase;
class AGameControllerBase;
/**
*
*/
UCLASS()
class MEMORIA_API ULevelDataAsset : public UPrimaryDataAsset
{
GENERATED_BODY()
public:
UPROPERTY(EditAnywhere, BlueprintReadWrite, Category = "LevelDataAsset")
TSubclassOf<AGameControllerBase> GameControllerClass;
UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "LevelDataAsset")
FString LevelName;
UPROPERTY(BlueprintReadWrite, EditAnywhere, Category = "LevelDataAsset")
FString LevelDescription;
UFUNCTION(BlueprintCallable, Category = "LevelDataAsset")
virtual void Setup(AGameControllerBase* controller);
UFUNCTION(BlueprintImplementableEvent, Category = "LevelDataAsset")
void OnReceiveSetup(AGameControllerBase* controller);
};
| [
"freedomzelda_dc@hotmail.com"
] | freedomzelda_dc@hotmail.com |
c52cc7607083e961b7e282d8de8ed2697828091e | adb23ab9c2db760afa93c09a1737687ae2431466 | /DgEngine/ViewportHandler.h | bcc3d26056574f5576ffb9ab1b893d500825ab8c | [] | no_license | int-Frank/SoftwareRasterizer | cb5d3234dcd59f55e6384a7152e0bb81cabc0401 | f62d5bf7e16b0cefe9dd46b255341ba0cea0893d | refs/heads/master | 2021-09-08T04:16:39.613309 | 2014-09-12T23:13:23 | 2014-09-12T23:13:23 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,303 | h | //================================================================================
// @ ViewportHandler.h
//
// Class: ViewportHandler
//
// Instances of this class are essentially windows to access the internal
// viewports. Only one instance of a handler can be attached to a particular
// viewport in the internal viewport manager.
//
// Simplifies accessing and locking viewports. Typically, once a viewport is
// assigned to a camera, it is desirable that all other cameras will be disallowed
// from accessing this viewport. The ViewportHandler class contains a static
// viewport manager which acts as the internal resource. All viewports are assigned from
// this resource. The manager must be loaded before any instance of this class
// can be used.
//
// -------------------------------------------------------------------------------
//
// Author: Frank Hart
// Date last modified: 2013
//
//================================================================================
#ifndef VIEWPORTHANDLER_H
#define VIEWPORTHANDLER_H
#include "DgTypes.h"
#include "ViewportManager.h"
#include <string>
class Viewport;
class WindowManager;
//--------------------------------------------------------------------------------
// @ ViewportHandler
//--------------------------------------------------------------------------------
class ViewportHandler
{
friend class CameraSystem;
public:
//--------------------------------------------------------------------------------
// Encapsulates the state of an internal viewport
//--------------------------------------------------------------------------------
struct ViewportState
{
ViewportState(): exists(false), isLocked(false), isActive(false) {}
bool exists;
bool isLocked;
bool isActive;
};
public:
//Constructor / destructor
ViewportHandler(): currentViewport(NULL_VIEWPORT_ID){}
~ViewportHandler();
//Copy operations
ViewportHandler(const ViewportHandler&);
ViewportHandler& operator= (const ViewportHandler&);
//Attach/Detach
bool Attach(viewportID); //Attach handler to a viewport
bool Detach(); //Detach handler from viewport
bool Activate(); //Activate viewport
bool Deactivate(); //Deactivate viewport
bool IsAttached() const;
bool IsActive() const;
ViewportState State() const;
//Accessors
Viewport* GetViewport();
//Returns the state of a viewport
static ViewportState GetState(viewportID);
//Functions to access the internal Viewport Manager.
static bool LoadResources(uint32 w, uint32 y);
static void SetParentDimensions(uint32 w, uint32 y);
static void Compile(WindowManager*);
static void Reset(bool flush, bool zMasks) {viewports.Reset(flush, zMasks);}
static Viewport* GetViewport(viewportID);
static const viewportID NULL_VIEWPORT_ID = -1;
private:
//Data members
viewportID currentViewport;
void init(const ViewportHandler&);
//--------------------------------------------------------------------------------
// Static resources
//--------------------------------------------------------------------------------
//The viewports a handler can be attached to. Loaded once at startup.
//These shouldn't change throughout the life of the application.
static ViewportManager viewports;
static bool isLoaded;
static const std::string viewport_file;
};
#endif | [
"theguv81@hotmail.com"
] | theguv81@hotmail.com |
1ac7dcde75afb1452827401c7c8bbd3cfa89796d | ecb2df271a0665be643b873c6d7ab98e7432c591 | /codeforces/B_Burglar_and_Matches.cpp | 74683f3071223e33b50d6941328cedd2a6398567 | [] | no_license | viagostini/maratona | d250b3464b10e0be4f4b057ec2845c2ad2d44ecf | 72060dd77df622055c9e171283e29fde5f7b42ac | refs/heads/master | 2021-06-04T02:53:56.607364 | 2021-04-04T21:55:08 | 2021-04-04T21:55:08 | 39,924,690 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 524 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef pair<int, int> pii;
int main() {
int n, m;
cin >> n >> m;
vector<pii> a(m);
for (int i = 0; i < m; i++) {
int x, y;
cin >> x >> y;
a[i] = {y, x};
}
sort(a.begin(), a.end(), greater<pii>());
int taken = 0;
long long ans = 0;
for (int i = 0; i < m; i++) {
int can_take = min(n - taken, a[i].second);
taken += can_take;
ans += can_take * a[i].first;
}
cout << ans << endl;
} | [
"vinicius.agostini19@gmail.com"
] | vinicius.agostini19@gmail.com |
93bf139e8f5dff5f97706fba63202fac7cd2cc25 | e8f271cc7db3fc7aa237ee6c86021b854cd85488 | /turtlebot_navigation_ws/src/tradr-loc-map-nav/path_planner/include/PathPlannerManager.h | c0a8c0eb3e2859515576a99ec1bd7ba6084fcad2 | [] | no_license | ElliWhite/turtlebot2_wss | e14caba73feae01b365dd367918ed3fa9089a531 | 48c1486d8b7450bea99acf4fc5de619a8c9c0188 | refs/heads/master | 2022-01-09T22:36:50.764256 | 2019-05-03T11:17:02 | 2019-05-03T11:17:02 | 177,111,010 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,496 | h | #ifndef PATH_PLANNING_MANAGER_H_
#define PATH_PLANNING_MANAGER_H_
#include <pcl/filters/crop_box.h>
#include <std_msgs/Bool.h>
#include <boost/thread/mutex.hpp>
#include <boost/thread/recursive_mutex.hpp>
#include "PathPlanner.h"
#include "Transform.h"
#include "MarkerController.h"
/// \class PathPlannerManager
/// \author Alcor
/// \brief Path planner for a single segment (start point,goal point)
/// \note
/// \todo
/// \date
/// \warning
class PathPlannerManager
{
public:
static const int kPathPlannerMaxNumAttempts = 10; // max number of times path planner try to compute the path
static const float k3DDistanceArrivedToGoal; // [m]
static const float k2DDistanceArrivedToGoal; // [m]
static const float k3DDistanceCloseToGoal;// [m]
static const float kMinXSizeCropBox; // [m] minimum size along X axis of the crop box for planning
static const float kMinYSizeCropBox; // [m] minimum size along Y axis of the crop box for planning
static const float kMinZSizeCropBox; // [m] minimum size along Z axis of the crop box for planning
static const float kGainCropBox;
static const float kGainCropBox2;
static const float kGainXCropBoxPathAligned; // crop box extends from (-kGainXCropBoxPathAligned* delta.norm(), -0.5*kSizeYCropBoxPathAligned, -0.5*kSizeZCropBoxPathAligned, 1) to (kGainXCropBoxPathAligned * delta.norm(), 0.5*kSizeYCropBoxPathAligned, 0.5*kSizeZCropBoxPathAligned, 1)
static const float kSizeYCropBoxPathAligned; //
static const float kSizeZCropBoxPathAligned; //
//static const float kTaskCallbackPeriod; // [s] the duration period of the task callback
enum CropBoxMethod
{
kCropBoxMethodPathAligned = 0, /*crop box in path-aligned frame*/
kCropBoxMethodWorldAligned, /*crop box in world-aligned frame*/
kCropBoxMethodWorldAligned2, /*crop box in a larger world-aligned frame*/
kCropBoxTakeAll, /*do not crop, take all*/
//kCropBoxTakeAll2,/*do not crop, take all - second chance */
kNumCropBoxMethod
};
// FIXME: this must be kept in synch with trajectory_control_msgs::PlanningStatus
enum PlannerStatus
{
kNone = 0,
kNotReady = 1,
kInputFailure = 2,
kFailure = 3,
kSuccess = 4,
kArrived = 5,
kAborted = 6,
kTransformFailure = 7,
kFirstSuccess = 8
};
public:
PathPlannerManager();
~PathPlannerManager();
public:
void traversabilityCloudCallback(const sensor_msgs::PointCloud2& traversability_msg);
void setTraversabilityCloud(const pcl::PointCloud<pcl::PointXYZI>& traversability_pcl_in);
void wallCloudCallback(const sensor_msgs::PointCloud2& wall_msg);
void utility2DCloudCallback(const sensor_msgs::PointCloud2& utility_msg);
void goalSelectionCallback(geometry_msgs::PoseStamped goal_msg);
void goalAbortCallback(std_msgs::Bool msg);
PlannerStatus pathPlanningServiceCallback(const geometry_msgs::PoseStamped start, const geometry_msgs::PoseStamped end, nav_msgs::Path& path, double& path_cost);
// compute path
PlannerStatus doPathPlanning();
public: /// < setters
void setGoal(pcl::PointXYZI& goal)
{
boost::recursive_mutex::scoped_lock goal_locker(goal_mutex_);
goal_position_ = goal;
if(!b_goal_selected_) b_goal_selected_ = true;
b_is_close_to_goal_ = false;
b_found_a_solution_once_ = false;
}
void setNoGoal()
{
boost::recursive_mutex::scoped_lock goal_locker(goal_mutex_);
if(b_goal_selected_) b_goal_selected_ = false;
b_is_close_to_goal_ = false;
b_found_a_solution_once_ = false;
}
// set the abort flag for possibly aborting current planning
void setAbort(bool val)
{
b_abort_ = val;
if(p_path_planner_)
{
p_path_planner_->setAbort(val);
planning_status_ = kAborted;
}
if(val) setNoGoal();
}
// set (parent) map frame and (child) robot frame
void setFramesRobot(const std::string& parent_map, const std::string& child_robot)
{
transform_robot_.set(parent_map,child_robot);
}
void setNo2DUtility()
{
boost::recursive_mutex::scoped_lock wall_locker(utility_2d_mutex_);
b_utility_2d_info_available_ = false;
}
void setCostFunctionType(int type, double lamda_trav = 1, double lambda_aux_utility = 1);
public: /// < getters
PlannerStatus getPlanningStatus() const { return planning_status_;}
bool isReady() const;
bool isReadyForService() const;
bool isSetGoal() const { return b_goal_selected_; }
pcl::PointXYZI& getGoal() { return goal_position_;}
nav_msgs::Path& getPath() {return path_;}
double& getPathCost() {return path_cost_;}
bool getRobotPosition(pcl::PointXYZI& robot_position);
bool isCloseToGoal() const {return b_is_close_to_goal_;}
bool isSolutionFoundOnce() const { return b_found_a_solution_once_; }
pcl::PointCloud<pcl::PointXYZI>& GetTraversabilityPcl() { return traversability_pcl_;}
public:
static void cropPcl(const CropBoxMethod& crop_box_method, const pcl::PointXYZI& start, const pcl::PointXYZI& goal, const pcl::PointCloud<pcl::PointXYZI>& pcl_in, pcl::PointCloud<pcl::PointXYZI>::Ptr pcl_out);
static bool cropTwoPcls(const CropBoxMethod& crop_box_method, const pcl::PointXYZI& start, const pcl::PointXYZI& goal,
const pcl::PointCloud<pcl::PointXYZI>& pcl_in, const pcl::PointCloud<pcl::PointXYZI>& pcl_in2,
pcl::PointCloud<pcl::PointXYZI>::Ptr pcl_out, pcl::PointCloud<pcl::PointXYZI>::Ptr pcl_out2);
protected:
double computePathLength(nav_msgs::Path& path);
protected:
volatile bool b_wall_info_available_;
volatile bool b_traversability_info_available_;
volatile bool b_utility_2d_info_available_;
volatile bool b_abort_; // true if we want to abort it
volatile bool b_goal_selected_;
volatile bool b_is_close_to_goal_; // true when close to the goal
volatile bool b_found_a_solution_once_; // for this goal. did you find a solution at least once?
Transform transform_robot_;
tf::StampedTransform robot_pose_;
nav_msgs::Path path_; // last planned path
double path_cost_; // cost of the last planned path
boost::recursive_mutex wall_mutex_;
pcl::PointCloud<pcl::PointXYZRGBNormal> wall_pcl_;
pp::KdTreeFLANN<pcl::PointXYZRGBNormal> wall_kdtree_;
boost::recursive_mutex traversability_mutex_;
pcl::PointCloud<pcl::PointXYZI> traversability_pcl_;
//PathPlanner::KdTreeFLANN traversability_kdtree_;
boost::recursive_mutex utility_2d_mutex_;
pcl::PointCloud<pcl::PointXYZI> utility_2d_pcl_; // [x,y,u(x,y),var(x,y)] we assume that utility_2d_pcl_ contains info about the points in traversability_pcl_
boost::recursive_mutex goal_mutex_;
pcl::PointXYZI goal_position_;
boost::shared_ptr<PathPlanner> p_path_planner_; // the used path planner instance
boost::recursive_mutex path_planner_mutex_;
BaseCostFunction::CostFunctionType cost_function_type_;
PlannerStatus planning_status_;
};
#endif //PATH_PLANNING_MANAGER_H_
| [
"elliott.white@students.plymouth.ac.uk"
] | elliott.white@students.plymouth.ac.uk |
cb3454001703c23fae7eafeef979e03543ee7a00 | 260a986070c2092c2befabf491d6a89b43b8c781 | /coregame_tasks/tasks_restore.cpp | 7b178f5de3b641898c42c072376bf81e124baac0 | [] | no_license | razodactyl/darkreign2 | 7801e5c7e655f63c6789a0a8ed3fef9e5e276605 | b6dc795190c05d39baa41e883ddf4aabcf12f968 | refs/heads/master | 2023-03-26T11:45:41.086911 | 2020-07-10T22:43:26 | 2020-07-10T22:43:26 | 256,714,317 | 11 | 2 | null | 2020-04-20T06:10:20 | 2020-04-18T09:27:10 | C++ | UTF-8 | C++ | false | false | 576 | cpp | ///////////////////////////////////////////////////////////////////////////////
//
// Copyright 1997-1999 Pandemic Studios, Dark Reign II
//
// Tasks
// 24-MAR-1999
//
///////////////////////////////////////////////////////////////////////////////
//
// Includes
//
#include "task.h"
#include "restoreobj.h"
//
// ~GameTask
//
// Destructor
//
template <> GameTask<RestoreObjType, RestoreObj>::~GameTask()
{
}
//
// GameProcess
//
// Type specific processing
//
template <> void GameTask<RestoreObjType, RestoreObj>::GameProcess()
{
}
| [
"razodactyl@gmail.com"
] | razodactyl@gmail.com |
7f91b8d798a3ca14f3d25b43c4a1a4cb4e7380b9 | 7546f570b6ca6d6f8f653124d8b3e60aaf82dc51 | /test/data_structure/batch_log_test.cpp | 060ef91b441f73b8b8798b109d2d35c085f14d56 | [
"MIT"
] | permissive | Handora/SLOG | c5ba729d78e258039bf3502d11fdfcb74a339e49 | e8e6534c57e93ea511b3d71ff8b413ddce3b8434 | refs/heads/master | 2022-10-19T21:53:20.099291 | 2020-06-10T03:30:45 | 2020-06-10T03:30:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,172 | cpp | #include <gtest/gtest.h>
#include "data_structure/batch_log.h"
using namespace std;
using namespace slog;
using internal::Batch;
class BatchLogTest : public ::testing::Test {
protected:
static const size_t NUM_BATCHES = 3;
void SetUp() {
for (size_t i = 0; i < NUM_BATCHES; i++) {
batches[i] = make_unique<Batch>();
batches[i]->set_id(100 * (i + 1));
}
}
bool BatchEQ(
pair<uint32_t, uint32_t> expected_id,
pair<SlotId, BatchPtr> batch) {
return batch.second != nullptr
&& expected_id.second == batch.second->id()
&& expected_id.first == batch.first;
}
BatchPtr batches[NUM_BATCHES]; // batch ids: 100 200 300
};
TEST_F(BatchLogTest, InOrder) {
BatchLog log;
log.AddSlot(0 /* slot_id */, 100 /* batch_id */);
log.AddBatch(move(batches[0]));
ASSERT_TRUE(BatchEQ({0, 100}, log.NextBatch()));
log.AddSlot(1 /* slot_id */, 200 /* batch_id */);
log.AddBatch(move(batches[1]));
ASSERT_TRUE(BatchEQ({1, 200}, log.NextBatch()));
log.AddSlot(2 /* slot_id */, 300 /* batch_id */);
log.AddBatch(move(batches[2]));
ASSERT_TRUE(BatchEQ({2, 300}, log.NextBatch()));
ASSERT_FALSE(log.HasNextBatch());
}
TEST_F(BatchLogTest, OutOfOrder) {
BatchLog log;
log.AddBatch(move(batches[1]));
ASSERT_FALSE(log.HasNextBatch());
log.AddBatch(move(batches[0]));
ASSERT_FALSE(log.HasNextBatch());
log.AddSlot(1 /* slot_id */, 100 /* batch_id */);
ASSERT_FALSE(log.HasNextBatch());
log.AddSlot(0 /* slot_id */, 200 /* batch_id */);
ASSERT_TRUE(BatchEQ({0, 200}, log.NextBatch()));
ASSERT_TRUE(BatchEQ({1, 100}, log.NextBatch()));
ASSERT_FALSE(log.HasNextBatch());
}
TEST_F(BatchLogTest, MultipleNextBatches) {
BatchLog log;
log.AddBatch(move(batches[2]));
log.AddBatch(move(batches[1]));
log.AddBatch(move(batches[0]));
log.AddSlot(2 /* slot_id */, 300 /* batch_id */);
log.AddSlot(1 /* slot_id */, 200 /* batch_id */);
log.AddSlot(0 /* slot_id */, 100 /* batch_id */);
ASSERT_TRUE(BatchEQ({0, 100}, log.NextBatch()));
ASSERT_TRUE(BatchEQ({1, 200}, log.NextBatch()));
ASSERT_TRUE(BatchEQ({2, 300}, log.NextBatch()));
ASSERT_FALSE(log.HasNextBatch());
} | [
"ctring23@gmail.com"
] | ctring23@gmail.com |
206db306db4a748d2e080fd4d777d4fad0178a46 | 1f9256420fe9da192f2850ce0d4ecc8744591dcc | /Exam_Abdallah/shape.cc | 63d005cb4479ca804406e26ab9aa3198289c09f8 | [] | no_license | AbdallahDaaboul/TP_Cpp | 144a8a3020e906ca7775b68957333b5e573473c9 | 9e9722593ee99724ac960168f74f0448ba4c0694 | refs/heads/master | 2022-04-10T22:06:29.218767 | 2020-04-04T08:28:07 | 2020-04-04T08:28:07 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 46 | cc | #include "shape.hh"
int Shape::_cpt_id = 0;
| [
"boudi.daaboul@outlook.com"
] | boudi.daaboul@outlook.com |
03112755026aade0920a3e9273cdce8e2f8ab701 | 7db25bcf1c93e5fe4e248b58ced98b80d46d6f61 | /renderer/source/assertions.h | e91e8d249f2a9323a6f9f3a5acad038acb2ff1a8 | [
"Apache-2.0"
] | permissive | MAPSWorks/voyager-renderer | 76d79d71b50cabf9937cd212b1cab15d99b7aa92 | a6e64647f45d652130dd946c8692c6139f9a0ec4 | refs/heads/main | 2023-02-12T00:19:09.330781 | 2021-01-02T21:07:40 | 2021-01-02T21:07:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 539 | h | #pragma once
#include <stdexcept>
#include <string>
#include "logging/LoggingCore.h"
#define ASSERT(x, ...) { if(x == true) { RENDERER_CRITICAL("Assertion failed: {0}", __VA_ARGS__); __debugbreak(); } }
#define ASSERT_SUCCESS_AND_THROW(expression, message)\
if (!(expression)) {\
RENDERER_CRITICAL("{0} ({1}): {2}", __FILE__, __LINE__, message);\
throw std::runtime_error(message);\
}\
#define THROW(message) \
{\
RENDERER_CRITICAL("{0} ({1}): {2}", __FILE__, __LINE__, message);\
throw std::runtime_error(message);\
}\
| [
"dushyantshukla@outlook.com"
] | dushyantshukla@outlook.com |
c5772ef4e5d51314c045fcf6dd565cbc4117d3f9 | 5543f27c332af1b03f1a912670f66d906f615018 | /RingBuffer.h | 23d18b7760d4152919eeb2b37cc5bbf7783f2ed9 | [] | no_license | leifsummerfield/KERB_Particle_Environmonitor | c3c55af0f69c9ab75216c2cc6d15421abb233c52 | 3a3e9e837cb8494e98777ca1c0a536b397250aff | refs/heads/master | 2021-01-11T13:47:40.644596 | 2017-04-29T20:13:06 | 2017-04-29T20:13:06 | 86,617,795 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,133 | h | #ifndef __RINGBUFFER_H
#define __RINGBUFFER_H
/**
* Thread and interrupt-safe (with caveats) circular buffer (ring buffer) class
*
* This class assumes a single reader thread and a single writer thread (or interrupt). For example, it
* works great if you read out of loop() and write from a single interrupt handler. It is not safe for
* multiple reader or multiple writer use cases!
*
*/
template <class T>
class RingBuffer {
public:
RingBuffer(T *elems, size_t size) : elems(elems), size(size) {};
~RingBuffer() {};
/**
* Returns the number of elements that can be read right now (0 = nothing can be read right now)
*
* This is mainly for informational purposes. It's more efficient to call preRead() and check for a non-NULL
* return value than it is to call availableForRead().
*/
size_t availableForRead() const {
return (size + head - tail) % size;
}
/**
* Non-copy version of read. Returns a pointer to the data to be read next or NULL if there is no data right now.
*
* If preRead() returns a non-null value you must call postRead() to consume the data, otherwise the next time
* you call preRead() you'll get the same data back. Don't call postRead() if you get NULL back from preRead()!
*/
T *preRead() const {
if (head == tail) {
return NULL;
}
else {
return &elems[tail];
}
}
/**
* Indicates that you have finished reading the data in the pointer returned by preRead() and it can be reused.
* Only call postRead() if preRead() returned a non-null value!
*/
void postRead() {
size_t next = (tail + 1) % size;
tail = next;
}
/**
* Read with copy. You can use this instead of preRead() and postRead(). Returns true if an element was copied
* or false if there was no data to read.
*/
bool read(T *elem) {
T *src = preRead();
if (src != NULL) {
*elem = *src;
postRead();
return true;
}
else {
return false;
}
}
/**
* Clear outstanding entries, called from the read thread
*/
void readClear() {
tail = head;
}
/**
* Non-copy version of write. Returns a pointer to the buffer to write to or NULL if there is no space.
*
* If preWrite() returns a non-null value you must call postWrite() to commit the data, otherwise the data
* will not be saved. Don't call postWrite() if you get NULL back from preWrite()!
*/
T *preWrite() const {
size_t next = (head + 1) % size;
if (next == tail) {
// No space to write
return NULL;
}
return &elems[head];
}
/**
* Commits the write. Only call if preWrite() returned a non-NULL value.
*/
void postWrite() {
size_t next = (head + 1) % size;
head = next;
}
/**
* Write with copy. You can use this instead of preWrite() and postWrite(). elem is copied. Returns true if
* the operation succeeded (there was space in the buffer).
*/
bool write(const T *elem) {
T *dst = preWrite();
if (dst != NULL) {
*dst = *elem;
postWrite();
return true;
}
else {
// No room to write
return false;
}
}
private:
T *elems;
size_t size;
volatile size_t head = 0;
volatile size_t tail = 0;
};
#endif /* __RINGBUFFER_H */
| [
"leifsummerfield@gmail.com"
] | leifsummerfield@gmail.com |
538809c857dec940d53f408ab7425743b8309111 | 0ef071051718096254d364055c394e32d6c7418d | /cards/card_8.h | 7d582f12fcebc4b47a8216842894eaae9f893124 | [] | no_license | maoyutao/GwentGame | 3776306ba430440529210aa3a6d99bab3319ee29 | 3a1973989f9d61c6463f9ff9f50047c0c1be0e6c | refs/heads/master | 2021-06-29T00:50:17.054627 | 2017-09-14T17:22:34 | 2017-09-14T17:22:34 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 379 | h | #ifndef CARD_8_H
#define CARD_8_H
#include "card.h"
#include <QObject>
class Card_8 : public Card
{
public:
explicit Card_8(BattleField * BattleField = nullptr,
QObject *parent = nullptr);
void exertAbility() override;
private:
QList<CardButton*> list;
private slots:
void afterChoosePosition(CardSlot * slot) override;
};
#endif // CARD_8_H
| [
"maoyutao1006@163.com"
] | maoyutao1006@163.com |
69844018295dc5755f8e9bd3bd5599630aec342e | 181d26eab0d22330c43836cdbb92c39f6b755f2b | /contador.cpp | c3a956cce4481d5381686ed78ac09629fb99bae6 | [] | no_license | MarianoOG/POO | 2e2ed18429eb30bee9e7dbb88a29d44c33c12b85 | 9a07df398c75857069c1c59f39ee8bf311795ac6 | refs/heads/master | 2023-02-13T12:20:48.632869 | 2021-01-07T09:40:29 | 2021-01-07T09:40:29 | 327,566,513 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 158 | cpp | #include <iostream.h>
#include <stdio.h>
int x;
int main () {
for(x=1;x<50;x++) {
cout<<x <<", ";
}
cout<<x <<endl;
system ("pause");
}
| [
"contacto@marianoog.com"
] | contacto@marianoog.com |
79610cc0454589a16c8e1d001cfb298a68a86f48 | 83bacfbdb7ad17cbc2fc897b3460de1a6726a3b1 | /third_party/WebKit/Source/core/svg/SVGPathBlender.h | a6da8f1f0bae05998214d59b378751ac70738047 | [
"BSD-3-Clause",
"LGPL-2.0-or-later",
"LicenseRef-scancode-warranty-disclaimer",
"LGPL-2.1-only",
"GPL-1.0-or-later",
"GPL-2.0-only",
"LGPL-2.0-only",
"BSD-2-Clause",
"LicenseRef-scancode-other-copyleft",
"Apache-2.0"
] | permissive | cool2528/miniblink49 | d909e39012f2c5d8ab658dc2a8b314ad0050d8ea | 7f646289d8074f098cf1244adc87b95e34ab87a8 | refs/heads/master | 2020-06-05T03:18:43.211372 | 2019-06-01T08:57:37 | 2019-06-01T08:59:56 | 192,294,645 | 2 | 0 | Apache-2.0 | 2019-06-17T07:16:28 | 2019-06-17T07:16:27 | null | UTF-8 | C++ | false | false | 1,557 | h | /*
* Copyright (C) Research In Motion Limited 2010. All rights reserved.
*
* 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., 51 Franklin Street, Fifth Floor,
* Boston, MA 02110-1301, USA.
*/
#ifndef SVGPathBlender_h
#define SVGPathBlender_h
#include "platform/heap/Handle.h"
#include "wtf/Noncopyable.h"
namespace blink {
struct PathSegmentData;
class SVGPathConsumer;
class SVGPathSource;
class SVGPathBlender final {
WTF_MAKE_NONCOPYABLE(SVGPathBlender);
STACK_ALLOCATED();
public:
SVGPathBlender(SVGPathSource* fromSource, SVGPathSource* toSource, SVGPathConsumer*);
bool addAnimatedPath(unsigned repeatCount);
bool blendAnimatedPath(float);
private:
class BlendState;
bool blendAnimatedPath(BlendState&);
SVGPathSource* m_fromSource;
SVGPathSource* m_toSource;
SVGPathConsumer* m_consumer;
};
} // namespace blink
#endif // SVGPathBlender_h
| [
"22249030@qq.com"
] | 22249030@qq.com |
b00a2a93f6064bdbb29840a8cae55ed87472ce03 | cf8ddfc720bf6451c4ef4fa01684327431db1919 | /SDK/ARKSurvivalEvolved_SpiderL_Character_BP_Hard_classes.hpp | bc095db132f43a00d3e812124670d73986ce0e27 | [
"MIT"
] | permissive | git-Charlie/ARK-SDK | 75337684b11e7b9f668da1f15e8054052a3b600f | c38ca9925309516b2093ad8c3a70ed9489e1d573 | refs/heads/master | 2023-06-20T06:30:33.550123 | 2021-07-11T13:41:45 | 2021-07-11T13:41:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,188 | hpp | #pragma once
// ARKSurvivalEvolved (329.9) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "ARKSurvivalEvolved_SpiderL_Character_BP_Hard_structs.hpp"
namespace sdk
{
//---------------------------------------------------------------------------
//Classes
//---------------------------------------------------------------------------
// BlueprintGeneratedClass SpiderL_Character_BP_Hard.SpiderL_Character_BP_Hard_C
// 0x000F (0x22D8 - 0x22C9)
class ASpiderL_Character_BP_Hard_C : public ASpiderL_Character_BP_C
{
public:
unsigned char UnknownData00[0x7]; // 0x22C9(0x0007) MISSED OFFSET
class UDinoCharacterStatusComponent_BP_SpiderBoss_Hard_C* DinoCharacterStatus_BP_SpiderBoss_Hard_C1; // 0x22D0(0x0008) (BlueprintVisible, ZeroConstructor, IsPlainOldData)
static UClass* StaticClass()
{
static auto ptr = UObject::FindClass("BlueprintGeneratedClass SpiderL_Character_BP_Hard.SpiderL_Character_BP_Hard_C");
return ptr;
}
void UserConstructionScript();
void ExecuteUbergraph_SpiderL_Character_BP_Hard(int EntryPoint);
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"sergey.2bite@gmail.com"
] | sergey.2bite@gmail.com |
8309331655d4b77874bed6a47765387f32f02fe6 | 9fb459f21a05718cf1dce0a59b2d04764e6db0b1 | /Image Toolkit/Stegz.cpp | 3ca65e83c4f0a4f9161e0aa0b19a206d90c7e22c | [] | no_license | lewesche/Image-Toolkit | bcbff2b4db39f33f35bdf7d1ad4486bd1202cafc | 55024b42610656aed566698ebf10fcec5c14d39f | refs/heads/master | 2020-04-10T12:26:43.121086 | 2019-04-07T05:03:04 | 2019-04-07T05:03:04 | 161,023,231 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 4,247 | cpp | #include "pch.h"
#include <iostream>
#include <opencv2/opencv.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <math.h>
#include <string>
using namespace std;
using namespace cv;
using namespace std::this_thread;
using namespace std::chrono_literals;
using image_t = Mat; // Define typedef for opencv image format
int encodeTxt(image_t &imageIn) {
image_t transformedImage = imageIn; // Container for new image
unsigned char *p; // Creat pointer for pixels
const unsigned char bit0 = 0b0000'0001; // modifier for bit 0, least signifigant bit
const unsigned char bit1 = 0b0000'0010; // modifier for bit 1
const unsigned char bit2 = 0b0000'0100; // modifier for bit 2
const unsigned char bit3 = 0b0000'1000; // etc
const unsigned char bit4 = 0b0001'0000;
const unsigned char bit5 = 0b0010'0000;
const unsigned char bit6 = 0b0100'0000;
const unsigned char bit7 = 0b1000'0000;
unsigned char bits[8] = { bit0, bit1, bit2, bit3, bit4, bit5, bit6, bit7 };
string text; // Container for input text to encode
cout << "Enter a string of text to enconde..." << endl;
getline(cin, text); // Grab text from the user
char endReturn = 13;
text += endReturn;
int textLength = text.length(); // Determine the number of characters
int imageWidth = imageIn.cols; // Width of the image in pixels
int imageHeight = imageIn.rows; // Height of the image in pixels
int x = 0; // x pixel position
int y = 0; // y pixel position
int color = 0; // Start by modifiying the first color pixel. Modifies the other pixels if necessary.
for (int i = 0; i < textLength; i++) {
for (int bitCount = 0; bitCount < 8; bitCount++) {
p = transformedImage.ptr(y, x); // Select a pixel
//cout << "Character: " << text[i];
//cout << ", bit: " << bitCount;
//cout << ", x position: " << x;
//cout << ", y position: " << y;
if (bits[bitCount] & text[i]) {
//cout << ", bit:" << 1 << endl;
p[color] |= bit0;
}
if (!(bits[bitCount] & text[i])) {
//cout << ", bit:" << 0 << endl;
p[color] &= ~bit0;
}
x++;
if (x >= imageWidth) {
x = 0;
y = y++;
}
if (y >= imageHeight) {
color++;
}
if (color >= 3) {
cout << "Out of image space!" << endl;
imshow("Input Image", imageIn); // Show the transformed image
imageIn = transformedImage;
imshow("Output Image", imageIn); // Show the transformed image
return 1;
}
}
}
imshow("Input Image", imageIn); // Show the transformed image
imageIn = transformedImage;
imshow("Output Image", imageIn); // Show the transformed image
return 0;
}
String decodeTxt(image_t &imageIn) {
unsigned char *p; // Creat pointer for pixels
const unsigned char bit0 = 0b0000'0001; // modifier for bit 0, least signifigant bit
const unsigned char bit1 = 0b0000'0010; // modifier for bit 1
const unsigned char bit2 = 0b0000'0100; // modifier for bit 2
const unsigned char bit3 = 0b0000'1000; // etc
const unsigned char bit4 = 0b0001'0000;
const unsigned char bit5 = 0b0010'0000;
const unsigned char bit6 = 0b0100'0000;
const unsigned char bit7 = 0b1000'0000;
unsigned char bits[8] = { bit0, bit1, bit2, bit3, bit4, bit5, bit6, bit7 };
string text; // Container for input text to encode
char letter;
int imageWidth = imageIn.cols; // Width of the image in pixels
int imageHeight = imageIn.rows; // Height of the image in pixels
int x = 0; // x pixel position
int y = 0; // y pixel position
int color = 0; // Start by modifiying the first color pixel. Modifies the other pixels if necessary.
for (int i = 0; i < (imageWidth * imageHeight * 3); i++) {
for (int bitCount = 0; bitCount < 8; bitCount++) {
p = imageIn.ptr(y, x); // Select a pixel
if (bit0 & p[color]) {
letter |= bits[bitCount];
}
if (!(bit0 & p[color])) {
letter &= ~bits[bitCount];
}
x++;
if (x >= imageWidth) {
x = 0;
y = y++;
}
if (y >= imageHeight) {
color++;
}
if (color >= 3) {
cout << "Reached the end of the image!" << endl;
return text;
}
}
if (static_cast<int>(letter) == 13) {
imshow("Decoded Image", imageIn); // Show the decoded image
return text;
}
else {
text += letter;
}
}
} | [
"37157762+lewesche@users.noreply.github.com"
] | 37157762+lewesche@users.noreply.github.com |
36ba8c4f194914abb54d87e3542ef5ef6e533468 | b39c7014415ea7904e1786e381a2a724eb91cb6e | /Codesignal/The Core/Labyrinth of Nested Loops/weakNumbers.cpp | b08616e471d5c8bc104b2b6588cf8d78bcaf072e | [] | no_license | chidihn/Learn-cpp | e217d2a722d49226269b8fa727ca1e909714fc12 | 682d44edb14d75d700bd7ec50ee1b61d52ed67fe | refs/heads/master | 2020-08-06T00:15:33.650474 | 2019-10-01T06:37:23 | 2019-10-01T06:37:23 | 212,767,703 | 3 | 0 | null | 2019-10-04T08:20:17 | 2019-10-04T08:20:17 | null | UTF-8 | C++ | false | false | 1,480 | cpp | /**
* Định nghĩa weakness của số x là số lượng số nguyên dương nhỏ hơn x có nhiều ước hơn x
* Bạn cần trả lời hai câu hỏi:
* Weakness lớn nhất của các số trong phạm vi [1, n] là gì?
* Có bao nhiêu số trong phạm vi [1, n] có weakness này?
* Trả về câu trả lời dưới dạng một mảng gồm hai phần tử, trong đó phần tử đầu
* tiên là câu trả lời cho câu hỏi đầu tiên và phần tử thứ hai là câu trả lời
* cho câu hỏi thứ hai.
*/
#include <iostream>
#include <vector>
#include <algorithm>
#include <math.h>
using namespace std;
vector<int> weakNumbers(int n) {
vector<int> weakness, d(n+1, 0);
// Tạo mảng số lượng ước
for(int i = 1; i <= n; i++)
for (int j = 1; j <= sqrt(i); j++)
if (i%j == 0)
if (i != j*j)
d.at(i) += 2;
else
d.at(i) += 1;
// Tạo mảng weakness
for (int i = 1; i <= n; i++) {
int count = 0;
for (int j = 1; j < i; j++)
if (d.at(j) > d.at(i))
count++;
weakness.push_back(count);
}
int q1 = *max_element(weakness.begin(), weakness.end());
int q2 = count(weakness.begin(), weakness.end(), q1);
return {q1, q2};
}
int main() {
for (auto i : weakNumbers(9)) // {2, 2}
cout << i << ' ';
cout << endl;
return 0;
} | [
"trvathin@gmail.com"
] | trvathin@gmail.com |
9494e20871c3770631edea2cefa7e4b683fabbfe | e07e3f41c9774c9684c4700a9772712bf6ac3533 | /app/Temp/StagingArea/Data/il2cppOutput/AssemblyU2DCSharp_GSN_Skill_Games_Common_Client_De3119797646.h | 88406e00b1d2165c76f70a3e055ad5b978a5b89d | [] | no_license | gdesmarais-gsn/inprocess-mobile-skill-client | 0171a0d4aaed13dbbc9cca248aec646ec5020025 | 2499d8ab5149a306001995064852353c33208fc3 | refs/heads/master | 2020-12-03T09:22:52.530033 | 2017-06-27T22:08:38 | 2017-06-27T22:08:38 | 95,603,544 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 590 | h | #pragma once
#include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
#include "AssemblyU2DCSharp_GSN_Skill_Games_Common_Client_De4164237173.h"
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// GSN.Skill.Games.Common.Client.DebugMenu.CloseableDebugMenu
struct CloseableDebugMenu_t3119797646 : public BaseDebugMenu_t4164237173
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"gdesmarais@gsngames.com"
] | gdesmarais@gsngames.com |
e8f49ca521869c665307f85840ef3b8f2f776563 | 5298705370c757d8846d409382f7dcb8450d48b8 | /wbs/src/Basic/ANN/ANN.h | d0b5f634e532487a6a6e683ccd2255533e551175 | [
"MIT"
] | permissive | RNCan/WeatherBasedSimulationFramework | 3d63b6a5fd1548cc5e5bac840f9e7c5f442dcdb0 | 05719614d2460a8929066fb920517f75a6a3ed04 | refs/heads/master | 2023-07-19T21:37:08.139215 | 2023-07-13T02:29:11 | 2023-07-13T02:29:11 | 51,245,634 | 7 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 33,349 | h | //----------------------------------------------------------------------
// File: ANN.h
// Programmer: Sunil Arya and David Mount
// Last modified: 03/19/05 (Release 1.0)
// Description: Basic include file for approximate nearest
// neighbor searching.
//----------------------------------------------------------------------
// Copyright (c) 1997-2005 University of Maryland and Sunil Arya and
// David Mount. All Rights Reserved.
//
// This software and related documentation is part of the
// Approximate Nearest Neighbor Library (ANN).
//
// Permission to use, copy, and distribute this software and its
// documentation is hereby granted free of charge, provided that
// (1) it is not a component of a commercial product, and
// (2) this notice appears in all copies of the software and
// related documentation.
//
// The University of Maryland (U.M.) and the authors make no representations
// about the suitability or fitness of this software for any purpose. It is
// provided "as is" without express or implied warranty.
//----------------------------------------------------------------------
// History:
// Revision 0.1 03/04/98
// Initial release
// Revision 1.0 04/01/05
// Added copyright and revision information
// Added ANNcoordPrec for coordinate precision.
// Added methods theDim, nPoints, maxPoints, thePoints to ANNpointSet.
// Cleaned up C++ structure for modern compilers
//----------------------------------------------------------------------
//----------------------------------------------------------------------
// ANN - approximate nearest neighbor searching
// ANN is a library for approximate nearest neighbor searching,
// based on the use of standard and priority search in kd-trees
// and balanced box-decomposition (bbd) trees. Here are some
// references to the main algorithmic techniques used here:
//
// kd-trees:
// Friedman, Bentley, and Finkel, ``An algorithm for finding
// best matches in logarithmic expected time,'' ACM
// Transactions on Mathematical Software, 3(3):209-226, 1977.
//
// Priority search in kd-trees:
// Arya and Mount, ``Algorithms for fast vector quantization,''
// Proc. of DCC '93: Data Compression Conference, eds. J. A.
// Storer and M. Cohn, IEEE Press, 1993, 381-390.
//
// Approximate nearest neighbor search and bbd-trees:
// Arya, Mount, Netanyahu, Silverman, and Wu, ``An optimal
// algorithm for approximate nearest neighbor searching,''
// 5th Ann. ACM-SIAM Symposium on Discrete Algorithms,
// 1994, 573-582.
//----------------------------------------------------------------------
#ifndef ANN_H
#define ANN_H
/*#ifdef WIN32
//----------------------------------------------------------------------
// For Microsoft Visual C++, externally accessible symbols must be
// explicitly indicated with DLL_API, which is somewhat like "extern."
//
// The following ifdef block is the standard way of creating macros
// which make exporting from a DLL simpler. All files within this DLL
// are compiled with the DLL_EXPORTS preprocessor symbol defined on the
// command line. In contrast, projects that use (or import) the DLL
// objects do not define the DLL_EXPORTS symbol. This way any other
// project whose source files include this file see DLL_API functions as
// being imported from a DLL, wheras this DLL sees symbols defined with
// this macro as being exported.
//----------------------------------------------------------------------
#ifdef DLL_EXPORTS
#define DLL_API __declspec(dllexport)
#else
#define DLL_API __declspec(dllimport)
#endif
//----------------------------------------------------------------------
// DLL_API is ignored for all other systems
//----------------------------------------------------------------------
#else
*/
#define DLL_API
//#endif
//----------------------------------------------------------------------
// basic includes
//----------------------------------------------------------------------
#include <cmath> // math includes
#include <iostream> // I/O streams
//----------------------------------------------------------------------
// Limits
// There are a number of places where we use the maximum double value as
// default initializers (and others may be used, depending on the
// data/distance representation). These can usually be found in limits.h
// (as LONG_MAX, INT_MAX) or in float.h (as DBL_MAX, FLT_MAX).
//
// Not all systems have these files. If you are using such a system,
// you should set the preprocessor symbol ANN_NO_LIMITS_H when
// compiling, and modify the statements below to generate the
// appropriate value. For practical purposes, this does not need to be
// the maximum double value. It is sufficient that it be at least as
// large than the maximum squared distance between between any two
// points.
//----------------------------------------------------------------------
#ifdef ANN_NO_LIMITS_H // limits.h unavailable
#include <cvalues> // replacement for limits.h
const double ANN_DBL_MAX = MAXDOUBLE; // insert maximum double
#else
#include <climits>
#include <cfloat>
const double ANN_DBL_MAX = DBL_MAX;
#endif
#define ANNversion "1.0" // ANN version and information
#define ANNversionCmt ""
#define ANNcopyright "David M. Mount and Sunil Arya"
#define ANNlatestRev "Mar 1, 2005"
//----------------------------------------------------------------------
// ANNbool
// This is a simple boolean type. Although ANSI C++ is supposed
// to support the type bool, some compilers do not have it.
//----------------------------------------------------------------------
enum ANNbool {ANNfalse = 0, ANNtrue = 1}; // ANN boolean type (non ANSI C++)
//----------------------------------------------------------------------
// ANNcoord, ANNdist
// ANNcoord and ANNdist are the types used for representing
// point coordinates and distances. They can be modified by the
// user, with some care. It is assumed that they are both numeric
// types, and that ANNdist is generally of an equal or higher type
// from ANNcoord. A variable of type ANNdist should be large
// enough to store the sum of squared components of a variable
// of type ANNcoord for the number of dimensions needed in the
// application. For example, the following combinations are
// legal:
//
// ANNcoord ANNdist
// --------- -------------------------------
// short short, int, long, float, double
// int int, long, float, double
// long long, float, double
// float float, double
// double double
//
// It is the user's responsibility to make sure that overflow does
// not occur in distance calculation.
//----------------------------------------------------------------------
typedef double ANNcoord; // coordinate data type
typedef double ANNdist; // distance data type
//----------------------------------------------------------------------
// ANNidx
// ANNidx is a point index. When the data structure is built, the
// points are given as an array. Nearest neighbor results are
// returned as an integer index into this array. To make it
// clearer when this is happening, we define the integer type
// ANNidx. Indexing starts from 0.
//----------------------------------------------------------------------
typedef int ANNidx; // point index
//----------------------------------------------------------------------
// Infinite distance:
// The code assumes that there is an "infinite distance" which it
// uses to initialize distances before performing nearest neighbor
// searches. It should be as larger or larger than any legitimate
// nearest neighbor distance.
//
// On most systems, these should be found in the standard include
// file <limits.h> or possibly <float.h>. If you do not have these
// file, some suggested values are listed below, assuming 64-bit
// long, 32-bit int and 16-bit short.
//
// ANNdist ANN_DIST_INF Values (see <limits.h> or <float.h>)
// ------- ------------ ------------------------------------
// double DBL_MAX 1.79769313486231570e+308
// float FLT_MAX 3.40282346638528860e+38
// long LONG_MAX 0x7fffffffffffffff
// int INT_MAX 0x7fffffff
// short SHRT_MAX 0x7fff
//----------------------------------------------------------------------
const ANNdist ANN_DIST_INF = ANN_DBL_MAX;
//----------------------------------------------------------------------
// Significant digits for tree dumps:
// When floating point coordinates are used, the routine that dumps
// a tree needs to know roughly how many significant digits there
// are in a ANNcoord, so it can output points to full precision.
// This is defined to be ANNcoordPrec. On most systems these
// values can be found in the standard include files <limits.h> or
// <float.h>. For integer types, the value is essentially ignored.
//
// ANNcoord ANNcoordPrec Values (see <limits.h> or <float.h>)
// -------- ------------ ------------------------------------
// double DBL_DIG 15
// float FLT_DIG 6
// long doesn't matter 19
// int doesn't matter 10
// short doesn't matter 5
//----------------------------------------------------------------------
#ifdef DBL_DIG // number of sig. bits in ANNcoord
const int ANNcoordPrec = DBL_DIG;
#else
const int ANNcoordPrec = 15; // default precision
#endif
//----------------------------------------------------------------------
// Self match?
// In some applications, the nearest neighbor of a point is not
// allowed to be the point itself. This occurs, for example, when
// computing all nearest neighbors in a set. By setting the
// parameter ANN_ALLOW_SELF_MATCH to ANNfalse, the nearest neighbor
// is the closest point whose distance from the query point is
// strictly positive.
//----------------------------------------------------------------------
const ANNbool ANN_ALLOW_SELF_MATCH = ANNtrue;
//----------------------------------------------------------------------
// Norms and metrics:
// ANN supports any Minkowski norm for defining distance. In
// particular, for any p >= 1, the L_p Minkowski norm defines the
// length of a d-vector (v0, v1, ..., v(d-1)) to be
//
// (|v0|^p + |v1|^p + ... + |v(d-1)|^p)^(1/p),
//
// (where ^ denotes exponentiation, and |.| denotes absolute
// value). The distance between two points is defined to be the
// norm of the vector joining them. Some common distance metrics
// include
//
// Euclidean metric p = 2
// Manhattan metric p = 1
// Max metric p = infinity
//
// In the case of the max metric, the norm is computed by taking
// the maxima of the absolute values of the components. ANN is
// highly "coordinate-based" and does not support general distances
// functions (e.g. those obeying just the triangle inequality). It
// also does not support distance functions based on
// inner-products.
//
// For the purpose of computing nearest neighbors, it is not
// necessary to compute the final power (1/p). Thus the only
// component that is used by the program is |v(i)|^p.
//
// ANN parameterizes the distance computation through the following
// macros. (Macros are used rather than procedures for
// efficiency.) Recall that the distance between two points is
// given by the length of the vector joining them, and the length
// or norm of a vector v is given by formula:
//
// |v| = ROOT(POW(v0) # POW(v1) # ... # POW(v(d-1)))
//
// where ROOT, POW are unary functions and # is an associative and
// commutative binary operator mapping the following types:
//
// ** POW: ANNcoord --> ANNdist
// ** #: ANNdist x ANNdist --> ANNdist
// ** ROOT: ANNdist (>0) --> double
//
// For early termination in distance calculation (partial distance
// calculation) we assume that POW and # together are monotonically
// increasing on sequences of arguments, meaning that for all
// v0..vk and y:
//
// POW(v0) #...# POW(vk) <= (POW(v0) #...# POW(vk)) # POW(y).
//
// Incremental Distance Calculation:
// The program uses an optimized method of computing distances for
// kd-trees and bd-trees, called incremental distance calculation.
// It is used when distances are to be updated when only a single
// coordinate of a point has been changed. In order to use this,
// we assume that there is an incremental update function DIFF(x,y)
// for #, such that if:
//
// s = x0 # ... # xi # ... # xk
//
// then if s' is equal to s but with xi replaced by y, that is,
//
// s' = x0 # ... # y # ... # xk
//
// then the length of s' can be computed by:
//
// |s'| = |s| # DIFF(xi,y).
//
// Thus, if # is + then DIFF(xi,y) is (yi-x). For the L_infinity
// norm we make use of the fact that in the program this function
// is only invoked when y > xi, and hence DIFF(xi,y)=y.
//
// Finally, for approximate nearest neighbor queries we assume
// that POW and ROOT are related such that
//
// v*ROOT(x) = ROOT(POW(v)*x)
//
// Here are the values for the various Minkowski norms:
//
// L_p: p even: p odd:
// ------------------------- ------------------------
// POW(v) = v^p POW(v) = |v|^p
// ROOT(x) = x^(1/p) ROOT(x) = x^(1/p)
// # = + # = +
// DIFF(x,y) = y - x DIFF(x,y) = y - x
//
// L_inf:
// POW(v) = |v|
// ROOT(x) = x
// # = max
// DIFF(x,y) = y
//
// By default the Euclidean norm is assumed. To change the norm,
// uncomment the appropriate set of macros below.
//----------------------------------------------------------------------
//----------------------------------------------------------------------
// Use the following for the Euclidean norm
//----------------------------------------------------------------------
#define ANN_POW(v) ((v)*(v))
#define ANN_ROOT(x) sqrt(x)
#define ANN_SUM(x,y) ((x) + (y))
#define ANN_DIFF(x,y) ((y) - (x))
//----------------------------------------------------------------------
// Use the following for the L_1 (Manhattan) norm
//----------------------------------------------------------------------
// #define ANN_POW(v) fabs(v)
// #define ANN_ROOT(x) (x)
// #define ANN_SUM(x,y) ((x) + (y))
// #define ANN_DIFF(x,y) ((y) - (x))
//----------------------------------------------------------------------
// Use the following for a general L_p norm
//----------------------------------------------------------------------
// #define ANN_POW(v) pow(fabs(v),p)
// #define ANN_ROOT(x) pow(fabs(x),1/p)
// #define ANN_SUM(x,y) ((x) + (y))
// #define ANN_DIFF(x,y) ((y) - (x))
//----------------------------------------------------------------------
// Use the following for the L_infinity (Max) norm
//----------------------------------------------------------------------
// #define ANN_POW(v) fabs(v)
// #define ANN_ROOT(x) (x)
// #define ANN_SUM(x,y) ((x) > (y) ? (x) : (y))
// #define ANN_DIFF(x,y) (y)
//----------------------------------------------------------------------
// Array types
// The following array types are of basic interest. A point is
// just a dimensionless array of coordinates, a point array is a
// dimensionless array of points. A distance array is a
// dimensionless array of distances and an index array is a
// dimensionless array of point indices. The latter two are used
// when returning the results of k-nearest neighbor queries.
//----------------------------------------------------------------------
typedef ANNcoord *ANNpoint; // a point
typedef ANNpoint *ANNpointArray; // an array of points
typedef ANNdist *ANNdistArray; // an array of distances
typedef ANNidx *ANNidxArray; // an array of point indices
//----------------------------------------------------------------------
// Basic point and array utilities:
// The following procedures are useful supplements to ANN's nearest
// neighbor capabilities.
//
// annDist():
// Computes the (squared) distance between a pair of points.
// Note that this routine is not used internally by ANN for
// computing distance calculations. For reasons of efficiency
// this is done using incremental distance calculation. Thus,
// this routine cannot be modified as a method of changing the
// metric.
//
// Because points (somewhat like strings in C) are stored as
// pointers. Consequently, creating and destroying copies of
// points may require storage allocation. These procedures do
// this.
//
// annAllocPt() and annDeallocPt():
// Allocate a deallocate storage for a single point, and
// return a pointer to it. The argument to AllocPt() is
// used to initialize all components.
//
// annAllocPts() and annDeallocPts():
// Allocate and deallocate an array of points as well a
// place to store their coordinates, and initializes the
// points to point to their respective coordinates. It
// allocates point storage in a contiguous block large
// enough to store all the points. It performs no
// initialization.
//
// annCopyPt():
// Creates a copy of a given point, allocating space for
// the new point. It returns a pointer to the newly
// allocated copy.
//----------------------------------------------------------------------
DLL_API ANNdist annDist(
int dim, // dimension of space
ANNpoint p, // points
ANNpoint q);
DLL_API ANNpoint annAllocPt(
int dim, // dimension
ANNcoord c = 0); // coordinate value (all equal)
DLL_API ANNpointArray annAllocPts(
int n, // number of points
int dim); // dimension
DLL_API void annDeallocPt(
ANNpoint &p); // deallocate 1 point
DLL_API void annDeallocPts(
ANNpointArray &pa); // point array
DLL_API ANNpoint annCopyPt(
int dim, // dimension
ANNpoint source); // point to copy
//----------------------------------------------------------------------
// Overall structure:
// ANN supports a number of different data structures for
// approximate and exact nearest neighbor searching. These are:
//
// ANNbruteForce A simple brute-force search structure.
// ANNkd_tree A kd-tree tree search structure.
// ANNbd_tree A bd-tree tree search structure (a kd-tree
// with shrink capabilities).
//
// At a minimum, each of these data structures support k-nearest
// neighbor queries. The nearest neighbor query (annkSearch)
// returns an integer identifier and the distance to the nearest
// neighbor(s).
//
// Each structure is built by invoking the appropriate constructor
// and passing it (at a minimum) the array of points, the total
// number of points and the dimension of the space. Each structure
// is also assumed to support a destructor and member functions
// that return basic information about the point set.
//
// Note that the array of points is not copied by the data
// structure (for reasons of space efficiency), and it is assumed
// to be constant throughout the lifetime of the search structure.
//
// The search algorithm, annkSearch, is given the query point (q),
// and the desired number of nearest neighbors to report (k), and
// the error bound (eps) (whose default value is 0, implying exact
// nearest neighbors). It returns two arrays which are assumed to
// contain at least k elements: one (nn_idx) contains the indices
// (within the point array) of the nearest neighbors and the other
// (dd) contains the squared distances to these nearest neighbors.
//
// The generic object from which all the search structures are
// dervied is given below. It is a virtual object, and is useless
// by itself.
//----------------------------------------------------------------------
class DLL_API ANNpointSet {
public:
virtual ~ANNpointSet() {} // virtual distructor
//virtual void annkSearch( // approx k near neighbor search
// ANNpoint q, // query point
// int k, // number of near neighbors to return
// ANNidxArray nn_idx, // nearest neighbor array (returned)
// ANNdistArray dd, // dist to near neighbors (returned)
// double eps=0.0 // error bound
// ) = 0; // pure virtual (defined elsewhere)
virtual void annPkSearch( // approx k near neighbor search
ANNpoint q, // query point
int k, // number of near neighbors to return
ANNidxArray nn_idx, // nearest neighbor array (returned)
ANNdistArray dd, // dist to near neighbors (returned)
double eps=0.0 // error bound
) = 0; // pure virtual (defined elsewhere)
virtual int theDim() = 0; // return dimension of space
virtual int nPoints() = 0; // return number of points
// return pointer to points
virtual ANNpointArray thePoints() = 0;
};
//----------------------------------------------------------------------
// Brute-force nearest neighbor search:
// The brute-force search structure is very simple but inefficient.
// It has been provided primarily for the sake of comparison with
// and validation of the more complex search structures.
//
// Query processing is the same as described above, but the value
// of epsilon is ignored, since all distance calculations are
// performed exactly.
//
// WARNING: This data structure is very slow, and should not be
// used unless the number of points is very small.
//
// Internal information:
// ---------------------
// This data structure bascially consists of the array of points
// (each a pointer to an array of coordinates). The search is
// performed by a simple linear scan of all the points.
//----------------------------------------------------------------------
class DLL_API ANNbruteForce: public ANNpointSet {
int dim; // dimension
int n_pts; // number of points
ANNpointArray pts; // point array
public:
ANNbruteForce( // constructor from point array
ANNpointArray pa, // point array
int n, // number of points
int dd); // dimension
~ANNbruteForce(); // destructor
//void annkSearch( // approx k near neighbor search
// ANNpoint q, // query point
// int k, // number of near neighbors to return
// ANNidxArray nn_idx, // nearest neighbor array (returned)
// ANNdistArray dd, // dist to near neighbors (returned)
// double eps=0.0); // error bound
void annPkSearch( // approx k near neighbor search
ANNpoint q, // query point
int k, // number of near neighbors to return
ANNidxArray nn_idx, // nearest neighbor array (returned)
ANNdistArray dd, // dist to near neighbors (returned)
double eps=0.0); // error bound
int theDim() // return dimension of space
{ return dim; }
int nPoints() // return number of points
{ return n_pts; }
ANNpointArray thePoints() // return pointer to points
{ return pts; }
};
//----------------------------------------------------------------------
// kd- and bd-tree splitting and shrinking rules
// kd-trees supports a collection of different splitting rules.
// In addition to the standard kd-tree splitting rule proposed
// by Friedman, Bentley, and Finkel, we have introduced a
// number of other splitting rules, which seem to perform
// as well or better (for the distributions we have tested).
//
// The splitting methods given below allow the user to tailor
// the data structure to the particular data set. They are
// are described in greater details in the kd_split.cc source
// file. The method ANN_KD_SUGGEST is the method chosen (rather
// subjectively) by the implementors as the one giving the
// fastest performance, and is the default splitting method.
//
// As with splitting rules, there are a number of different
// shrinking rules. The shrinking rule ANN_BD_NONE does no
// shrinking (and hence produces a kd-tree tree). The rule
// ANN_BD_SUGGEST uses the implementors favorite rule.
//----------------------------------------------------------------------
enum ANNsplitRule {
ANN_KD_STD = 0, // the optimized kd-splitting rule
ANN_KD_MIDPT = 1, // midpoint split
ANN_KD_FAIR = 2, // fair split
ANN_KD_SL_MIDPT = 3, // sliding midpoint splitting method
ANN_KD_SL_FAIR = 4, // sliding fair split method
ANN_KD_SUGGEST = 5}; // the authors' suggestion for best
const int ANN_N_SPLIT_RULES = 6; // number of split rules
enum ANNshrinkRule {
ANN_BD_NONE = 0, // no shrinking at all (just kd-tree)
ANN_BD_SIMPLE = 1, // simple splitting
ANN_BD_CENTROID = 2, // centroid splitting
ANN_BD_SUGGEST = 3}; // the authors' suggested choice
const int ANN_N_SHRINK_RULES = 4; // number of shrink rules
//----------------------------------------------------------------------
// kd-tree:
// The main search data structure supported by ANN is a kd-tree.
// The main constructor is given a set of points and a choice of
// splitting method to use in building the tree.
//
// Construction:
// -------------
// The constructor is given the point array, number of points,
// dimension, bucket size (default = 1), and the splitting rule
// (default = ANN_KD_SUGGEST). The point array is not copied, and
// is assumed to be kept constant throughout the lifetime of the
// search structure. There is also a "load" constructor that
// builds a tree from a file description that was created by the
// Dump operation.
//
// Search:
// -------
// There are two search methods:
//
// Standard search (annkSearch()):
// Searches nodes in tree-traversal order, always visiting
// the closer child first.
// Priority search (annkPriSearch()):
// Searches nodes in order of increasing distance of the
// associated cell from the query point. For many
// distributions the standard search seems to work just
// fine, but priority search is safer for worst-case
// performance.
//
// Printing:
// ---------
// There are two methods provided for printing the tree. Print()
// is used to produce a "human-readable" display of the tree, with
// indenation, which is handy for debugging. Dump() produces a
// format that is suitable reading by another program. There is a
// "load" constructor, which constructs a tree which is assumed to
// have been saved by the Dump() procedure.
//
// Performance and Structure Statistics:
// -------------------------------------
// The procedure getStats() collects statistics information on the
// tree (its size, height, etc.) See ANNperf.h for information on
// the stats structure it returns.
//
// Internal information:
// ---------------------
// The data structure consists of three major chunks of storage.
// The first (implicit) storage are the points themselves (pts),
// which have been provided by the users as an argument to the
// constructor, or are allocated dynamically if the tree is built
// using the load constructor). These should not be changed during
// the lifetime of the search structure. It is the user's
// responsibility to delete these after the tree is destroyed.
//
// The second is the tree itself (which is dynamically allocated in
// the constructor) and is given as a pointer to its root node
// (root). These nodes are automatically deallocated when the tree
// is deleted. See the file src/kd_tree.h for further information
// on the structure of the tree nodes.
//
// Each leaf of the tree does not contain a pointer directly to a
// point, but rather contains a pointer to a "bucket", which is an
// array consisting of point indices. The third major chunk of
// storage is an array (pidx), which is a large array in which all
// these bucket subarrays reside. (The reason for storing them
// separately is the buckets are typically small, but of varying
// sizes. This was done to avoid fragmentation.) This array is
// also deallocated when the tree is deleted.
//
// In addition to this, the tree consists of a number of other
// pieces of information which are used in searching and for
// subsequent tree operations. These consist of the following:
//
// dim Dimension of space
// n_pts Number of points currently in the tree
// n_max Maximum number of points that are allowed
// in the tree
// bkt_size Maximum bucket size (no. of points per leaf)
// bnd_box_lo Bounding box low point
// bnd_box_hi Bounding box high point
// splitRule Splitting method used
//
//----------------------------------------------------------------------
//----------------------------------------------------------------------
// Some types and objects used by kd-tree functions
// See src/kd_tree.h and src/kd_tree.cpp for definitions
//----------------------------------------------------------------------
class ANNkdStats; // stats on kd-tree
class ANNkd_node; // generic node in a kd-tree
typedef ANNkd_node *ANNkd_ptr; // pointer to a kd-tree node
class DLL_API ANNkd_tree: public ANNpointSet {
protected:
int dim; // dimension of space
int n_pts; // number of points in tree
int bkt_size; // bucket size
ANNpointArray pts; // the points
ANNidxArray pidx; // point indices (to pts array)
ANNkd_ptr root; // root of kd-tree
ANNpoint bnd_box_lo; // bounding box low point
ANNpoint bnd_box_hi; // bounding box high point
void SkeletonTree( // construct skeleton tree
int n, // number of points
int dd, // dimension
int bs, // bucket size
ANNpointArray pa = NULL, // point array (optional)
ANNidxArray pi = NULL); // point indices (optional)
public:
ANNkd_tree( // build skeleton tree
int n = 0, // number of points
int dd = 0, // dimension
int bs = 1); // bucket size
ANNkd_tree( // build from point array
ANNpointArray pa, // point array
int n, // number of points
int dd, // dimension
int bs = 1, // bucket size
ANNsplitRule split = ANN_KD_SUGGEST); // splitting method
ANNkd_tree( // build from dump file
std::istream &in); // input stream for dump file
~ANNkd_tree(); // tree destructor
//void annkSearch( // approx k near neighbor search
// ANNpoint q, // query point
// int k, // number of near neighbors to return
// ANNidxArray nn_idx, // nearest neighbor array (returned)
// ANNdistArray dd, // dist to near neighbors (returned)
// double eps=0.0); // error bound
void annPkSearch( // approx k near neighbor search
ANNpoint q, // query point
int k, // number of near neighbors to return
ANNidxArray nn_idx, // nearest neighbor array (returned)
ANNdistArray dd, // dist to near neighbors (returned)
double eps=0.0); // error bound
void annkPriSearch( // priority k near neighbor search
ANNpoint q, // query point
int k, // number of near neighbors to return
ANNidxArray nn_idx, // nearest neighbor array (returned)
ANNdistArray dd, // dist to near neighbors (returned)
double eps=0.0); // error bound
int theDim() // return dimension of space
{ return dim; }
int nPoints() // return number of points
{ return n_pts; }
ANNpointArray thePoints() // return pointer to points
{ return pts; }
virtual void Print( // print the tree (for debugging)
ANNbool with_pts, // print points as well?
std::ostream &out); // output stream
virtual void Dump( // dump entire tree
ANNbool with_pts, // print points as well?
std::ostream &out); // output stream
virtual void getStats( // compute tree statistics
ANNkdStats &st); // the statistics (returned)
};
//----------------------------------------------------------------------
// Box decomposition tree (bd-tree)
// The bd-tree is inherited from a kd-tree. The main difference
// in the bd-tree and the kd-tree is a new type of internal node
// called a shrinking node (in the kd-tree there is only one type
// of internal node, a splitting node). The shrinking node
// makes it possible to generate balanced trees in which the
// cells have bounded aspect ratio, by allowing the decomposition
// to zoom in on regions of dense point concentration. Although
// this is a nice idea in theory, few point distributions are so
// densely clustered that this is really needed.
//----------------------------------------------------------------------
class DLL_API ANNbd_tree: public ANNkd_tree {
public:
ANNbd_tree( // build skeleton tree
int n, // number of points
int dd, // dimension
int bs = 1) // bucket size
: ANNkd_tree(n, dd, bs) {} // build base kd-tree
ANNbd_tree( // build from point array
ANNpointArray pa, // point array
int n, // number of points
int dd, // dimension
int bs = 1, // bucket size
ANNsplitRule split = ANN_KD_SUGGEST, // splitting rule
ANNshrinkRule shrink = ANN_BD_SUGGEST); // shrinking rule
ANNbd_tree( // build from dump file
std::istream &in); // input stream for dump file
};
//----------------------------------------------------------------------
// Other functions
// annMaxPtsVisit Sets a limit on the maximum number of points
// to visit in the search.
// annClose Can be called when all use of ANN is finished.
// It clears up a minor memory leak.
//----------------------------------------------------------------------
DLL_API void annMaxPtsVisit( // max. pts to visit in search
int maxPts); // the limit
DLL_API void annClose(); // called to end use of ANN
#endif
| [
"Tigroux74@hotmail.com"
] | Tigroux74@hotmail.com |
2396411112ebe78559f9fb6f80c859fff2df2c87 | 97b78efe8ecdde2ab07112588ca0f959d43bb38c | /dependencies/common_includes.hpp | 2eddef967042199ac1867bfb85f95345e6dfcb74 | [] | no_license | TurkLee/angeldust | 3676ba8d9e7651cebe911c5a6482358fb64b2ea5 | 16740d251f9daf793086d8ecd705ed8db07a9227 | refs/heads/master | 2021-10-10T16:18:18.069813 | 2019-01-13T16:13:48 | 2019-01-13T16:13:48 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 873 | hpp | #pragma once
#include <windows.h>
#include <iostream>
#include <cstdint>
#include <memory>
#include <vector>
#include <thread>
#include <chrono>
#include <array>
#include <fstream>
#include <istream>
#include <unordered_map>
#include <intrin.h>
#include <d3d9.h>
#include <d3dx9.h>
#pragma comment(lib, "d3d9.lib")
#pragma comment(lib, "d3dx9.lib")
#include "../core/menu/imgui/imgui.h"
#include "../core/menu/imgui/dx9/imgui_impl_dx9.h"
#include "../core/menu/elements.hpp"
#include "utilities/singleton.hpp"
#include "utilities/fnv.hpp"
#include "utilities/utilities.hpp"
#include "utilities/render.hpp"
#include "utilities/hook.hpp"
#include "interfaces/interfaces.hpp"
#include "utilities/netvars.hpp"
#include "../core/hacks/misc/fakelag/fakelag.h"
#include "../dependencies/globals/globals.h"
#include "../source-sdk/sdk.hpp"
#include "../core/hooking/hooks.hpp"
| [
"37311082+stackergg@users.noreply.github.com"
] | 37311082+stackergg@users.noreply.github.com |
2ed9e223b90f3042a1bfb878be6a91f1e1852780 | d20f0bfe5343bf1e92e7eafcf3f534f275f791c4 | /Component/CEquationsSolver.h | d2631364a8ca25b7a3f36702217a04a43bd19a89 | [] | no_license | ShiloDenis1997/COM.2017.LUEquationsSolver | efdd81808035aca709e137531794fff07f406a05 | 07d472ca9ed8151c015c831d03d264b061c10e96 | refs/heads/master | 2020-05-23T04:35:26.420990 | 2017-04-08T13:13:16 | 2017-04-08T13:13:16 | 84,749,030 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 936 | h | #pragma once
#include <Unknwn.h>
#include "IEquationSolver.h"
#include "EquationsComponent.h"
#include "IEquationPrinter.h"
#include <iostream>
class CEquationsPrinter;
class CEquationSolver : public IEquationSolver//,
//public IEquationPrinter
{
public:
CEquationSolver();
~CEquationSolver() override;
HRESULT __stdcall QueryInterface(const IID& riid, void** ppvObject) override;
ULONG __stdcall AddRef() override;
ULONG __stdcall Release() override;
bool LoadMatrix(double** a, int n) override;
void SolveWithVector(double* b, double* result) override;
private:
bool MakeLU(double **a, int* pr, int* pc, int n) const;
void SolveL(double* y) const;
void SolveU(double* x) const;
void DeleteMatrix();
static void swapColumns(double **a, int c1, int c2, int n);
public:
private:
friend class CEquationsPrinter;
long m_cRef;
int m_N;
int *m_pRow;
int *m_pCol;
double **m_LUmatr;
CEquationsPrinter* printerIface;
}; | [
"shilo.denis.1997g@gmail.com"
] | shilo.denis.1997g@gmail.com |
29d186e495f33c93bbcc6bb4c8f8ddcc0278bef7 | 90593500bf54c4c16264321473db23a147fdb7dc | /PROG/PRIMER TRIMESTRE PROG/REPETICION_PRACTICA/STARWARSIprototipo.cpp | 7984c61940b1b4679eb810d6466567f710382987 | [] | no_license | RAS151822/EJERCICIOS-PROGRAMACION | 24e8f7d060317b4caa9b7528679ad4451d163413 | 4e0a5e5821966c89ffd6ee5499189df30fd7645a | refs/heads/master | 2020-04-22T21:36:01.371097 | 2019-02-14T11:35:51 | 2019-02-14T11:35:51 | 170,678,035 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,377 | cpp | #include <iostream>
#include <sstream>
using namespace std;
int filtroentero (int &a){ // FUNCION PARA ENTEROS QUE SIRVE PARA FILTRAR CARACTERES
while (cin.fail()){
cout << "CARACTER NO VALIDO, Lo siento vuelva a intentarlo introduce un numero"<< endl;
cin.clear();
cin.ignore(256,'\n');
cin>>a;
}
return a;
}
int main () {
string nombre, parentesco; // Declaro dos variables para que el usuario introduzca los datos
string Luke, padre; // Declaro dos variables para que cuando pulse esto el usuario entre en el if
string nombrecompleto;// Para guardar nombre y parentesco en una misma cadena y luego mostrarlo por pantalla
int dato = 0; // Declaro una variable de tipo entero para que el usuario me diga el número de veces que quiere introducir nombre y parentesco
int acumulador1 = 1, acumulador2 = 1; //Declaro un acumulador para parar el buckle cuando este sume el número de veces que sea igual que el dato
//PEQUEÑA PRESENTACION DONDE PIDO AL USUARIO QUE INTRODUZCA EL NÚMERO DE ENTRADAS
cout << endl;
cout << "BIENVENIDO al programa STARWARSI " << endl;
//DECLARO UN BUCKLE DO WHILE PARA REALIZAR UN FILTRO DE ENTRADA DE Nºs POSITIVIOS
do {
cout << endl;
cout << "INTRODUCE EL NÚMERO DE PERSONAJES QUE QUIERES INTRODUCIR " << endl;
cin >> dato;// El número de veces que voy a repetir mi buckle
filtroentero(dato);// llamo a la variable filtroentero para que solo pueda introducir números y no deje que entren simbolos
if ( dato <= 0){
cout << "NÚMERO NO VALIDO, porfavor introduzca un número positivo " << endl;
}
}while ( dato <= 0 );
cout << "Introduce el nombre y seguido el parentesco de tu personaje favortio de STARWARS " << endl;
while ( dato >= acumulador1 ) { //DECLARO UN BUCKLE WHILE PARA ASI PODER ACUMULAR TANTAS ENTRADAS COMO NÚMERO DE DATOS INTRODUCIDOS ANTERIORMENTE
cin >> nombre;
cin >> parentesco;
if ( nombre == "Luke" && parentesco == "padre" ){ // CONDICIONAL PARA GUARDAR EN LA VARIABLE NOMBRECOMPLETO segun el nombre y el parentesco
nombrecompleto += "TOP SECRET \n"; // VARIABLE PARA HACER LA SUMATORIA Y ASI GUARDAR LOS CIN Y (\n) PARA EL SALTO DE LINEA
}
else {
nombrecompleto += nombre + " yo soy tu " + parentesco + "\n";
}
acumulador1 ++; // PARA PARAR EL BUCKLE CUANDO DATO SEA IGUAL AL ACUMULADOR
}
cout << nombrecompleto << endl;
}
| [
"ras151822@gmail.com"
] | ras151822@gmail.com |
00a2786057e74f8bbc9c3e047cdba14743e1d21b | 300cefeb59b0b1ea3d08b79061fcd5000f2be051 | /src/include/common/timestamp_type.h | bbf2c21da48372668c9bceb6cc20e1e4ce2d3717 | [
"Apache-2.0"
] | permissive | xhad1234/Parallel-Sort-Merge-Join-in-Peloton | ccff0707b1075893008163700346dab4bdbc4f07 | 60dea12ed528bc8873b1c43d1eca841a5d76ee44 | refs/heads/master | 2020-12-24T10:54:47.119367 | 2016-12-13T08:30:20 | 2016-12-13T08:30:20 | 73,123,214 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,113 | h | //===----------------------------------------------------------------------===//
//
// Peloton
//
// boolean_value.h
//
// Identification: src/backend/common/timestamp_value.h
//
// Copyright (c) 2015-16, Carnegie Mellon University Database Group
//
//===----------------------------------------------------------------------===//
#pragma once
#include "common/value.h"
namespace peloton {
namespace common {
class TimestampType : public Type {
public:
~TimestampType() {}
TimestampType();
// Comparison functions
Value CompareEquals(const Value& left, const Value &right) const override;
Value CompareNotEquals(const Value& left, const Value &right) const override;
Value CompareLessThan(const Value& left, const Value &right) const override;
Value CompareLessThanEquals(const Value& left, const Value &right) const override;
Value CompareGreaterThan(const Value& left, const Value &right) const override;
Value CompareGreaterThanEquals(const Value& left, const Value &right) const override;
bool IsInlined(const Value&) const override { return true; }
// Debug
std::string ToString(const Value& val) const override;
// Compute a hash value
size_t Hash(const Value& val) const override;
void HashCombine(const Value& val, size_t &seed) const override;
// Serialize this value into the given storage space
void SerializeTo(const Value& val, SerializeOutput &out) const override;
void SerializeTo(const Value& val, char *storage, bool inlined,
VarlenPool *pool) const override;
// Deserialize a value of the given type from the given storage space.
Value DeserializeFrom(const char *storage,
const bool inlined, VarlenPool *pool = nullptr) const override;
Value DeserializeFrom(SerializeInput &in,
VarlenPool *pool = nullptr) const override;
// Create a copy of this value
Value Copy(const Value& val) const override;
Value CastAs(const Value& val, const Type::TypeId type_id) const override;
};
} // namespace peloton
} // namespace common
| [
"PerronMatt@gmail.com"
] | PerronMatt@gmail.com |
43068bf7fe0dd20ac60e7e62819ea5a775b26097 | 02faf426415c7c01a176563c165801001ad86466 | /libraries/cli/cli.cpp | 14fdca874942981dea974f1945e1e4dd8e4aec78 | [
"MIT"
] | permissive | MicalChine/lvm | 9c0ed33c6ab1cb551f1ee26985a7670d1f774922 | 4af6fcd72443fb5e2f7c448ec13654b8208a2fde | refs/heads/master | 2021-08-29T23:23:31.410073 | 2017-12-15T08:22:50 | 2017-12-15T08:22:50 | 110,195,280 | 0 | 0 | MIT | 2017-12-11T03:29:28 | 2017-11-10T02:59:18 | C++ | UTF-8 | C++ | false | false | 7,012 | cpp |
#include <base/exceptions.hpp>
#include <cli/cli.hpp>
#include <client/client.hpp>
#include <task/task.hpp>
#include <boost/algorithm/string/trim.hpp>
#include <fc/io/console.hpp>
#include <fc/io/sstream.hpp>
#include <iostream>
#include <memory>
Cli::Cli(Client* client)
: _p_input_stream(nullptr),
_cin_thread("stdin_reader"),
_p_out_stream(&std::cout),
_p_client(client),
_b_quit(false),
_method_data_handler(std::make_shared<MethodDataHandler>()) {
}
Cli::~Cli() {
}
std::string Cli::get_line(const std::string& prompt, bool no_echo) {
if (_b_quit) {
return std::string();
}
return get_line(
_p_input_stream,
_p_out_stream,
prompt,
no_echo,
&_cin_thread);
}
FC_DECLARE_EXCEPTION(cli_exception, 11000, "CLI Error")
FC_DECLARE_DERIVED_EXCEPTION(abort_cli_command, cli_exception, 11001, "command aborted by user");
FC_DECLARE_DERIVED_EXCEPTION(exit_cli_command, cli_exception, 11002, "exit CLI client requested by user");
std::string Cli::get_line(
std::istream* input_stream,
std::ostream* out,
const std::string& prompt,
bool no_echo,
fc::thread* cin_thread) {
if (input_stream == nullptr)
FC_CAPTURE_AND_THROW(exit_cli_command); //_input_stream != nullptr );
//FC_ASSERT( _self->is_interactive() );
std::string line;
if (no_echo) {
*out << prompt;
// there is no need to add input to history when echo is off, so both Windows and Unix implementations are same
fc::set_console_echo(false);
sync_call(cin_thread, [&](){ std::getline(*input_stream, line); }, "getline");
fc::set_console_echo(true);
*out << std::endl;
} else {
*out << prompt;
sync_call(cin_thread, [&](){ std::getline(*input_stream, line); }, "getline");
}
boost::trim(line);
return line;
}
std::string Cli::get_prompt() {
std::string prompt_name = LVM_NMAE;
std::string prompt_postfix = LVM_CLI_PROMPT_SUFFIX;
std::string prompt = prompt_name + prompt_postfix;
return prompt;
}
void Cli::parse_and_execute_interactive_command(std::string command, fc::istream_ptr argument_stream) {
if (command.empty()) {
return;
}
if (command == "quit" || command == "stop" || command == "exit") {
_p_client->quit_client(true);
FC_THROW_EXCEPTION(exit_cli_command, "quit command issued");
}
BufferedIstreamWithEotHack buffered_argument_stream(argument_stream);
bool command_is_valid = false;
fc::variants arguments;
try {
MethodData* method_data = _method_data_handler->find_method_data(command);
if (method_data) {
handle_task(command, &buffered_argument_stream);
}
// NOTE: arguments here have not been filtered for private keys or passwords
// ilog( "command: ${c} ${a}", ("c",command)("a",arguments) );
command_is_valid = true;
} catch (const lvm::global_exception::unknown_method&) {
if (!command.empty()){
*_p_out_stream << "Error: invalid command \"" << command << "\"\n";
}
} catch (const abort_cli_command&) {
throw;
} catch (const fc::exception& e) {
*_p_out_stream << e.to_detail_string() << "\n";
*_p_out_stream << "Error parsing command \"" << command << "\": " << e.to_string() << "\n";
arguments = fc::variants{ command };
edump((e.to_detail_string()));
}
} //parse_and_execute_interactive_command
bool Cli::execute_command_line(const std::string& line, std::ostream* output/* = nullptr*/) {
try {
std::string trimmed_line_to_parse(boost::algorithm::trim_copy(line));
/**
* On some OS X systems, std::stringstream gets corrupted and does not throw eof
* when expected while parsing the command. Adding EOF (0x04) characater at the
* end of the string casues the JSON parser to recognize the EOF rather than relying
* on stringstream.
*
* @todo figure out how to fix things on these OS X systems.
*/
trimmed_line_to_parse += std::string(" ") + char(0x04);
if (!trimmed_line_to_parse.empty()) {
std::string::const_iterator iter = std::find_if(trimmed_line_to_parse.begin(), trimmed_line_to_parse.end(), ::isspace);
std::string command;
fc::istream_ptr argument_stream;
if (iter != trimmed_line_to_parse.end()) {
// then there are arguments to this function
size_t first_space_pos = iter - trimmed_line_to_parse.begin();
command = trimmed_line_to_parse.substr(0, first_space_pos);
argument_stream = std::make_shared<fc::stringstream>((trimmed_line_to_parse.substr(first_space_pos + 1)));
} else {
command = trimmed_line_to_parse;
argument_stream = std::make_shared<fc::stringstream>();
}
try {
parse_and_execute_interactive_command(command, argument_stream);
} catch (const exit_cli_command&) {
return false;
} catch (const abort_cli_command&) {
*_p_out_stream << "Command aborted\n";
}
} //end if command line not empty
return true;
} FC_RETHROW_EXCEPTIONS(warn, "", ("command", line))
}
void Cli::process_commands(std::istream* input_stream) {
try {
FC_ASSERT(input_stream != nullptr);
_p_input_stream = input_stream;
//force flushing to console and log file whenever input is read
_p_input_stream->tie(_p_out_stream);
std::string line = get_line(get_prompt());
while (_p_input_stream->good() && !_b_quit) {
if (!execute_command_line(line))
break;
if (!_b_quit)
line = get_line(get_prompt());
} // while cin.good
wlog("process commands exiting");
} FC_CAPTURE_AND_RETHROW()
}
void Cli::start() {
try {
if (!_b_quit) {
process_commands(&std::cin);
}
} catch (const fc::exception& e) {
*_p_out_stream << "\nshutting down\n";
elog("${e}", ("e", e.to_detail_string()));
}
}
TaskBase* Cli::parse_to_task(const std::string& task,
fc::buffered_istream* argument_stream) {
MethodData* method_data = _method_data_handler->find_method_data(task);
if (!method_data) {
return nullptr;
}
TaskBase* task_base = gen_task_base_from_method_data(method_data,
argument_stream);
task_base->task_from = FROM_CLI;
return task_base;
}
void Cli::task_finished(TaskImplResult* result) {
format_and_print_result(result);
}
void Cli::format_and_print_result(TaskImplResult* result) {
std::string str_result = "Internal error.";
if (result) {
str_result = result->get_result_string();
}
*_p_out_stream << "result : \n" <<str_result << "\n";
}
| [
"xiaoming@new4g.cn"
] | xiaoming@new4g.cn |
fee4e05f8984c12e448275f585071a088a8891fb | 8cc3498e311d15c9a4394aaa341ef489b482dbe6 | /compiler/extensions/cpp/runtime/test/test_object/polymorphic_allocator/CreatorUnsignedEnum.h | d69041e2eb716bbd9438e9e4c593c39125ce9b9f | [
"BSD-3-Clause"
] | permissive | ndsev/zserio | 3e55c064f72e86219a6da297f116d3dbb565a9a9 | c540c4a97fee4e08bfc6669a2cec0d2b8282d8f6 | refs/heads/master | 2023-08-24T14:56:10.750155 | 2023-08-11T19:36:54 | 2023-08-11T19:36:54 | 141,550,444 | 113 | 23 | BSD-3-Clause | 2023-08-30T11:14:47 | 2018-07-19T08:44:23 | Java | UTF-8 | C++ | false | false | 4,503 | h | /**
* Automatically generated by Zserio C++ extension version 2.11.0.
* Generator setup: writerCode, pubsubCode, serviceCode, sqlCode, typeInfoCode, reflectionCode, polymorhpicAllocator.
*/
#ifndef TEST_OBJECT_POLYMORPHIC_ALLOCATOR_CREATOR_UNSIGNED_ENUM_H
#define TEST_OBJECT_POLYMORPHIC_ALLOCATOR_CREATOR_UNSIGNED_ENUM_H
#include <array>
#include <zserio/Enums.h>
#include <zserio/BitStreamReader.h>
#include <zserio/BitStreamWriter.h>
#include <zserio/pmr/ITypeInfo.h>
#include <zserio/pmr/IReflectable.h>
#include <zserio/pmr/PackingContext.h>
#include <zserio/ArrayTraits.h>
#include <zserio/Types.h>
namespace test_object
{
namespace polymorphic_allocator
{
enum class CreatorUnsignedEnum : uint8_t
{
ONE = UINT8_C(0),
TWO = UINT8_C(1)
};
} // namespace polymorphic_allocator
} // namespace test_object
namespace zserio
{
// This is full specialization of enumeration traits and methods for CreatorUnsignedEnum enumeration.
template <>
struct EnumTraits<::test_object::polymorphic_allocator::CreatorUnsignedEnum>
{
static constexpr ::std::array<const char*, 2> names =
{{
"ONE",
"TWO"
}};
static constexpr ::std::array<::test_object::polymorphic_allocator::CreatorUnsignedEnum, 2> values =
{{
::test_object::polymorphic_allocator::CreatorUnsignedEnum::ONE,
::test_object::polymorphic_allocator::CreatorUnsignedEnum::TWO
}};
static constexpr const char* enumName = "CreatorUnsignedEnum";
};
template <>
const ::zserio::pmr::ITypeInfo& enumTypeInfo<::test_object::polymorphic_allocator::CreatorUnsignedEnum, ::zserio::pmr::PropagatingPolymorphicAllocator<>>();
template <>
::zserio::pmr::IReflectablePtr enumReflectable(::test_object::polymorphic_allocator::CreatorUnsignedEnum value, const ::zserio::pmr::PropagatingPolymorphicAllocator<>& allocator);
template <>
size_t enumToOrdinal<::test_object::polymorphic_allocator::CreatorUnsignedEnum>(::test_object::polymorphic_allocator::CreatorUnsignedEnum value);
template <>
::test_object::polymorphic_allocator::CreatorUnsignedEnum valueToEnum<::test_object::polymorphic_allocator::CreatorUnsignedEnum>(
typename ::std::underlying_type<::test_object::polymorphic_allocator::CreatorUnsignedEnum>::type rawValue);
template <>
uint32_t enumHashCode<::test_object::polymorphic_allocator::CreatorUnsignedEnum>(::test_object::polymorphic_allocator::CreatorUnsignedEnum value);
template <>
void initPackingContext<::zserio::pmr::PackingContextNode, ::test_object::polymorphic_allocator::CreatorUnsignedEnum>(
::zserio::pmr::PackingContextNode& contextNode, ::test_object::polymorphic_allocator::CreatorUnsignedEnum value);
template <>
size_t bitSizeOf<::test_object::polymorphic_allocator::CreatorUnsignedEnum>(::test_object::polymorphic_allocator::CreatorUnsignedEnum value);
template <>
size_t bitSizeOf<::zserio::pmr::PackingContextNode, ::test_object::polymorphic_allocator::CreatorUnsignedEnum>(
::zserio::pmr::PackingContextNode& contextNode, ::test_object::polymorphic_allocator::CreatorUnsignedEnum value);
template <>
size_t initializeOffsets<::test_object::polymorphic_allocator::CreatorUnsignedEnum>(size_t bitPosition, ::test_object::polymorphic_allocator::CreatorUnsignedEnum value);
template <>
size_t initializeOffsets<::zserio::pmr::PackingContextNode, ::test_object::polymorphic_allocator::CreatorUnsignedEnum>(
::zserio::pmr::PackingContextNode& contextNode, size_t bitPosition, ::test_object::polymorphic_allocator::CreatorUnsignedEnum value);
template <>
::test_object::polymorphic_allocator::CreatorUnsignedEnum read<::test_object::polymorphic_allocator::CreatorUnsignedEnum>(::zserio::BitStreamReader& in);
template <>
::test_object::polymorphic_allocator::CreatorUnsignedEnum read<::test_object::polymorphic_allocator::CreatorUnsignedEnum, ::zserio::pmr::PackingContextNode>(
::zserio::pmr::PackingContextNode& contextNode, ::zserio::BitStreamReader& in);
template <>
void write<::test_object::polymorphic_allocator::CreatorUnsignedEnum>(::zserio::BitStreamWriter& out, ::test_object::polymorphic_allocator::CreatorUnsignedEnum value);
template <>
void write<::zserio::pmr::PackingContextNode, ::test_object::polymorphic_allocator::CreatorUnsignedEnum>(
::zserio::pmr::PackingContextNode& contextNode, ::zserio::BitStreamWriter& out, ::test_object::polymorphic_allocator::CreatorUnsignedEnum value);
} // namespace zserio
#endif // TEST_OBJECT_POLYMORPHIC_ALLOCATOR_CREATOR_UNSIGNED_ENUM_H
| [
"mikulas.rozloznik@eccam.com"
] | mikulas.rozloznik@eccam.com |
c0a6e86788194f007b30466695987ed8cf135a92 | 833c5759f5d56721d295ff267b648045248de3f7 | /all516/all516/main.cpp | bf2194a456b1090d387cf7d32a9589f8032060d5 | [] | no_license | BinyuHuang-nju/leetcode-implement | 6732331a80d3570521bc9f345e63dc2856cfeb06 | 60dfbf4e7fa833040d49a2907842d26808101f53 | refs/heads/master | 2022-12-23T01:43:08.374777 | 2020-09-27T14:03:39 | 2020-09-27T14:03:39 | 277,704,869 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 767 | cpp | #include <iostream>
using namespace std;
#include <vector>
#include <string>
#include <cstring>
class Solution {
public:
int longestPalindromeSubseq(string s) {
vector<vector<int>> dp(s.length(), vector<int>(s.length(), 1));
int i, j;
for (i = s.length() - 2; i >= 0; i--) {
for (j = i + 1; j < s.length(); j++) {
if (j - i == 1)
dp[i][j] = (s[i] == s[j]) ? 2 : 1;
else {
if (s[i] == s[j])
dp[i][j] = dp[i + 1][j - 1] + 2;
else
dp[i][j] = dp[i + 1][j] > dp[i][j - 1] ? dp[i + 1][j] : dp[i][j - 1];
}
}
}
return dp[0][s.length() - 1];
}
}; | [
"huangbinyu000@outlook.com"
] | huangbinyu000@outlook.com |
75d46e59c379d6b9acfc5249bdcee311a5588250 | c47399dcd4e7a2675d8ef54c4296d5fafd170898 | /备忘录模式/备忘录模式/Game.h | c3ca823d6cd365be00cdff294f254169c9fb070a | [] | no_license | kesihai/Design-pattern | 57adffc748a2531ff8ef5b0a0b7dee4ffc8ba7d3 | 95b4a5a4752f46ce99096da7e153bdbeec0e92ea | refs/heads/master | 2020-04-17T06:04:25.495932 | 2016-10-25T11:07:39 | 2016-10-25T11:07:39 | 66,174,860 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 224 | h | #pragma once
#include "Memory.h"
#include <stdio.h>
class Game
{
public:
Game(int a,int b,int c);
~Game();
int a, b, c;
const Game* Get_Status();
void Set_Status(const Memory *memory);
void show();
void Fight();
};
| [
"2693711535@qq.com"
] | 2693711535@qq.com |
3153ac875adda5d71cd07df11009ceec0c1e375d | 11f4852f6c9c445abc23532b86e45a7928ae1836 | /inc/RandomData.hpp | 93b69bb8291f636dc9fd35dffd2dc9fc64159bc9 | [
"MIT"
] | permissive | RavNowak/Database | c8ded9c8e56d7e7f85cc1b754854801f31466226 | dd6ea636f38a9b5bd4b70867f0eb65d86bc8006c | refs/heads/master | 2020-03-24T03:39:40.430065 | 2019-02-13T18:37:00 | 2019-02-13T18:37:00 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,597 | hpp | #pragma once
#include <../inc/Adress.hpp>
#include <array>
#include <unordered_set>
#include <string>
namespace RandomData
{
std::array<std::string, 10> randomFirstName = { "rafal", "marek", "maciek", "piotrek", "ula",
"klaudia", "dominika", "tomek", "jan", "darek" };
std::array<std::string, 10> randomLastName = { "szybki", "wolny", "bystry", "michalewski", "miejski",
"nowy", "podlejski", "wawrzynek", "lichy", "staszewski" };
std::array<std::string, 10> randomPesel = { "93011397014", "25040751910", "44051401359", "00302557202", "91051962012",
"76871321706", "98111588700", "08260128313", "96122729307", "04231446613" };
std::array<std::string, 2> randomGender = { "man", "woman" };
std::array<Adress, 10> randomAdress = { Adress("warszawa","cicha",5), Adress("warszawa","cicha",7), Adress("kalisz","grunwaldzka",4), Adress("Poznan","spokojna",90),
Adress("krakow","morska",13), Adress("lodz","boska",9), Adress("Kielce","powstancow",13), Adress("gdynia","lokietka",41), Adress("wroclaw","podwawelska",3), Adress("wroclaw","prosta",4) };
std::array<int, 10> randomIndex = { 123456, 467894, 378904, 234799, 456734, 678903, 136009, 567112, 789034, 996615 };
std::array<int, 10> randomSalary = { 1000,2000,3000,4000,5000,6000,7000,8000,9000,10000 };
std::unordered_set<int> randomUniqueNumber()
{
srand(time(0));
std::unordered_set<int> uniqueRandomNumbers;
while (uniqueRandomNumbers.size() != 6)
uniqueRandomNumbers.insert(rand() % 10);
return uniqueRandomNumbers;
}
}
| [
"nowak9.private@gmail.com"
] | nowak9.private@gmail.com |
d900a1e5fba39595f9d03f47a4b7a091d8ea1eb9 | 19f997590bf2cbb39dbf4e3693cbc6ba16cb7938 | /DS/main.cpp | 35e3e2fb248818c185f6c7453f2a5ee3d0655b28 | [] | no_license | Dxnium/CE2103 | ea33be52993346ba8778086d89abd540b0923b26 | efd707d6b82df99f321a9b6867212251ede66eb6 | refs/heads/master | 2020-06-27T11:21:32.341212 | 2019-10-06T18:00:16 | 2019-10-06T18:00:16 | 199,939,281 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,053 | cpp | #include <iostream>
#include "LinkedList/LinkedList.h"
#include "BinaryTree/BinaryTree.h"
#include "Sockets/Server.h"
#include "GUI/ClientGUI.hpp"
#include "Sockets/Client.h"
#include <gtk/gtk.h>
#include <iostream>
// LinkedList *list = new LinkedList();
// list->insert(1);
// list->insert(4);
// list->insert(2);
// list->insert(3);
// list->print();
// std::cout<<"*************************"<<std::endl;
// list->set(0,2);
// list->print();
// list->get(2);
// std::cout<<"*************************"<<std::endl;
// list->delete_frist();
// list->print();
// BinaryTree *tree = new BinaryTree();
// tree->insert(4);
// tree->insert(5);
// tree->insert(1);
// tree->insert(3);
// tree->insert(4);
// tree->print();
// std::cout<<"*************************"<<std::endl;
// tree->print(tree->root);
int main(int argc, char *argv[]) {
ClientGUI *g = new ClientGUI(argc,argv);
// Client *c = new Client("hola mundo");
// Server *s = new Server();
//zz
//
return 0;
} | [
"38996231+Dxnium@users.noreply.github.com"
] | 38996231+Dxnium@users.noreply.github.com |
3e793a7c74a4cda603e670c4439669a2c0e7c9a7 | 5389e503feb7ffa0936ca11d543139919b555e1d | /docker/d-streamon-master/d-streamon/streamon/lib/fc/WireTemplate.cpp | 8292e332f85a473970574b4f6e11f08a76b553b4 | [
"MIT",
"Apache-2.0"
] | permissive | scissor-project/open-scissor | 3a242d6d9035f0ae7f282d4e2c347afed86a15df | d54718a1969701798f3e2d57f3db68d829da1cc0 | refs/heads/master | 2021-09-13T03:00:20.700121 | 2018-04-23T14:55:51 | 2018-04-23T18:14:30 | 106,671,291 | 2 | 1 | Apache-2.0 | 2018-04-23T18:14:31 | 2017-10-12T09:17:50 | JavaScript | UTF-8 | C++ | false | false | 6,444 | cpp | #include "WireTemplate.h"
namespace IPFIX {
void WireTemplate::add(const InfoElement* ie) {
add_inner(ie);
// calculate offset
size_t offset;
if (offsets_.empty()) {
offset = 0;
} else if (offsets_.back() == kVarlen ||
ie->len() == kVarlen) {
offset = kVarlen;
} else {
offset = offsets_.back() + ies_.back()->len();
}
// Add offset to offset table
offsets_.push_back(offset);
// Add the length of the IE to the minimum length
if (ie->len() == kVarlen) {
minlen_ += 1;
} else {
minlen_ += ie->len();
}
// Add the length of the IE's fields to the template record length
trlen_ += ie->pen() ? 8 : 4;
}
void WireTemplate::clear() {
ies_.clear();
offsets_.clear();
index_map_.clear();
minlen_ = 0;
trlen_ = 0;
active_ = false;
}
void WireTemplate::mimic(const IETemplate& rhs) {
clear();
for (IETemplateIter i = rhs.begin(); i != rhs.end(); ++i) {
add(*i);
}
activate();
}
// std::list<TCEntry> IETemplate::planTranscode(const IETemplate &struct_tmpl) const
// {
// std::list<TCEntry> plan;
//
// for (IETemplateIter iter = ies_.begin();
// iter != ies_.end();
// iter++) {
// if (struct_tmpl.contains(*iter)) {
// plan.push_back(TCEntry(struct_tmpl.offset(*iter), struct_tmpl.length(*iter), *iter))
// } else {
// plan.push_back(TCEntry(0, (*iter)->len(), NULL);
// }
// }
//
// return plan;
// }
//
// bool IETemplate::encode(Transcoder& encoder, const std::list<TCEntry>& plan, uint8_t* struct_cp) const
// {
// uint8_t* struct_cp = reinterpret_cast<uint8_t *>(struct_vp);
//
// // Refuse to encode an with inactive template
// if (!active_) {
// throw std::logic_error("Cannot encode using an inactive template");
// }
//
// // Refuse to encode unless we have at _least_ minimum length avail.
// if (encoder.avail() < minlen_) {
// std::cerr << "encoder overrun (at least " << encoder.avail() << " avail, " << minlen_ << " required.)" << std::endl;
// return false;
// }
//
// // Note: Void casts here are safe, since we checked minlen.
// // When we move to varlen encoding, we'll need to checkpoint and rollback.
// // FIXME this should be sped up by specifically building a transcode plan.
// encoder.checkpoint();
// for (TCEntryIter iter = plan.begin();
// iter != plan.end();
// iter++) {
// if (iter->ie) {
// encoder.encode(struct_cp + iter->offset, iter->length, iter->ie) || goto err;
// } else {
// encoder.encodeZero(iter->length) || goto err;
// }
// }
//
// return true;
//
// err:
// encoder.rollback();
// return false;
// }
bool WireTemplate::encode(Transcoder& xc, const StructTemplate& struct_tmpl, uint8_t* struct_cp) const
{
// Refuse to encode an with inactive template
if (!active_) {
throw std::logic_error("Cannot encode using an inactive template");
}
// Refuse to encode unless we have at _least_ minimum length avail.
if (xc.avail() < minlen_) {
std::cerr << "encoder overrun (" << xc.avail() << " avail, " << minlen_ << " required.)" << std::endl;
return false;
}
// Note: Void casts here are safe, since we checked minlen.
// When we move to varlen encoding, we'll need to checkpoint and rollback.
// FIXME this should be sped up by specifically building a transcode plan.
xc.checkpoint();
for (IETemplateIter iter = ies_.begin();
iter != ies_.end();
iter++) {
if (struct_tmpl.contains(*iter)) {
size_t off = struct_tmpl.offset(*iter);
size_t len = struct_tmpl.length(*iter);
if (len == kVarlen) {
VarlenField *vf = reinterpret_cast<VarlenField *>(struct_cp + off);
if (!xc.encode(vf, *iter)) goto err;
} else {
if (!xc.encode(struct_cp + off, len, *iter)) goto err;
}
} else {
if (!xc.encodeZero(*iter)) goto err;
}
}
return true;
err:
xc.rollback();
return false;
}
bool WireTemplate::encodeTemplateRecord(Transcoder &xc) const {
// Refuse to encode an inactive template
if (!active_) {
throw std::logic_error("Cannot encode an inactive template");
}
// Make sure the encoder has space for the encoded version of the template
// Void casts from here are safe, since the template record length is
// constant.
if (xc.avail() < trlen_) {
return false;
}
// encode template record header
(void) xc.encode(tid_);
(void) xc.encode(static_cast<uint16_t>(ies_.size()));
// encode fields
for (IETemplateIter iter = ies_.begin();
iter != ies_.end();
iter++) {
if ((*iter)->pen()) {
(void) xc.encode(static_cast<uint16_t>((*iter)->number() | kEnterpriseBit));
(void) xc.encode((*iter)->len());
(void) xc.encode((*iter)->pen());
} else {
(void) xc.encode((*iter)->number());
(void) xc.encode((*iter)->len());
}
}
return true;
}
bool WireTemplate::decode(Transcoder& xc, const StructTemplate &struct_tmpl, uint8_t* struct_cp) const {
// Refuse to decode an with inactive template
if (!active_) {
throw std::logic_error("Cannot decode using an inactive template");
}
// Refuse to decode unless we have at _least_ minimum length avail.
if (xc.avail() < minlen_) {
std::cerr << "decoder overrun (" << xc.avail() << " avail, " << minlen_ << " required.)" << std::endl;
return false;
}
// Note: Void casts here are safe, since we checked minlen.
// When we move to varlen encoding, we'll need to checkpoint and rollback.
// FIXME this should be sped up by building a transcode plan.
xc.checkpoint();
for (IETemplateIter iter = ies_.begin();
iter != ies_.end();
iter++) {
if (struct_tmpl.contains(*iter)) {
size_t off = struct_tmpl.offset(*iter);
size_t len = struct_tmpl.length(*iter);
if (len == kVarlen) {
VarlenField *vf = reinterpret_cast<VarlenField *>(struct_cp + off);
if (!xc.decode(vf, *iter)) goto err;
} else {
//fprintf(stderr, "dec %-60s at 0x%016lx to [%u:%u] at 0x%016lx\n",
// (*iter)->toIESpec().c_str(), reinterpret_cast<long>(xc.cur()),
// off, off + len, reinterpret_cast<long>(struct_cp));
if (!xc.decode(struct_cp + off, len, *iter)) goto err;
}
}
}
return true;
err:
xc.rollback();
return false;
}
} | [
"ferrari.marco@gmail.com"
] | ferrari.marco@gmail.com |
ece4b3152be2d58af46677ca7b7614b7f06d49a1 | c7ed4e302fd22bc0c8981e31d80e404be01eef62 | /hw3/Graph_71.hpp | 481d075d6f491920464931ed75fa3444e4fa5f14 | [] | no_license | chunlinsun/peercode | ea6ca224ee8919e0281bad29a7a9a5581864c389 | fdaf3f6c88544551cd7d5fdffaa6c711e02aba7c | refs/heads/master | 2022-11-19T19:36:26.655760 | 2020-03-02T17:44:45 | 2020-03-02T17:44:45 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 25,565 | hpp | #ifndef CME212_GRAPH_HPP
#define CME212_GRAPH_HPP
/** @file Graph.hpp
* @brief An undirected graph type
*/
#include <algorithm>
#include <map>
#include <vector>
#include <cassert>
#include "CME212/Util.hpp"
#include "CME212/Point.hpp"
/** @class Graph
* @brief A template for 3D undirected graphs.
*
* Users can add and retrieve nodes and edges. Edges are unique (there is at
* most one edge between any pair of distinct nodes).
*/
template<typename V, typename E>
class Graph{
private:
struct internal_point;
// internal struct to store point information
// HW0: YOUR CODE HERE
// Use this space for declarations of important internal types you need
// later in the Graph's definition.
// (As with all the "YOUR CODE HERE" markings, you may not actually NEED
// code here. Just use the space if you need it.)
public:
//
// PUBLIC TYPE DEFINITIONS
//
typedef V node_value_type;
typedef E edge_value_type;
/** Type of this graph. */
using graph_type = Graph;
/** Predeclaration of Node type. */
class Node;
/** Synonym for Node (following STL conventions). */
using node_type = Node;
/** Predeclaration of Edge type. */
class Edge;
/** Synonym for Edge (following STL conventions). */
using edge_type = Edge;
/** Type of node iterators, which iterate over all graph nodes. */
class NodeIterator;
/** Synonym for NodeIterator */
using node_iterator = NodeIterator;
/** Type of edge iterators, which iterate over all graph edges. */
class EdgeIterator;
/** Synonym for EdgeIterator */
using edge_iterator = EdgeIterator;
/** Type of incident iterators, which iterate incident edges to a node. */
class IncidentIterator;
/** Synonym for IncidentIterator */
using incident_iterator = IncidentIterator;
/** Type of indexes and sizes.
Return type of Graph::Node::index(), Graph::num_nodes(),
Graph::num_edges(), and argument type of Graph::node(size_type) */
using size_type = unsigned;
//
// CONSTRUCTORS AND DESTRUCTOR
//
/** Construct an empty graph. */
Graph() {
points = std::vector<internal_point>();
size_ = 0;
edges = std::vector<std::vector<size_type>>();
adjs = std::vector<std::vector<size_type>>();
num_edges_ = 0;
// HW0: YOUR CODE HERE
}
/** Default destructor */
~Graph() = default;
//
// NODES
//
/** @class Graph::Node
* @brief Class representing the graph's nodes.
*
* Node objects are used to access information about the Graph's nodes.
*/
class Node: private totally_ordered<Node> {
public:
/** Construct an invalid node.
*
* Valid nodes are obtained from the Graph class, but it
* is occasionally useful to declare an @i invalid node, and assign a
* valid node to it later. For example:
*
* @code
* Graph::node_type x;
* if (...should pick the first node...)
* x = graph.node(0);
* else
* x = some other node using a complicated calculation
* do_something(x);
* @endcode
*/
Node() {
graph_ = nullptr;
// HW0: YOUR CODE HERE
}
/** Return this node's position. */
const Point& position() const {
assert (graph_ != nullptr);
return graph_->points[graph_->i2u_[pid_]].position;
// HW0: YOUR CODE HERE
}
Point& position(){
assert (graph_ != nullptr);
return graph_->points[graph_->i2u_[pid_]].position;
// HW0: YOUR CODE HERE
}
/** Return this node's index, a number in the range [0, graph_size). */
size_type index() const {
assert (graph_ != nullptr);
return pid_;
}
/** @return the value of the node, also allow modification of the value*/
node_value_type& value(){
return graph_->points[graph_->i2u_[pid_]].value_;
}
/** @return the value of the node, does not allow modification of the value*/
const node_value_type& value() const{
return graph_->points[graph_->i2u_[pid_]].value_;
}
/** @return the number of incident edges*/
size_type degree() const{
return graph_->adjs[graph_->i2u_[pid_]].size();
}
/** @return the start of the incident iterator*/
incident_iterator edge_begin() const{
return IncidentIterator(graph_, 0, pid_);
}
/** @return the end of the incident iterator*/
incident_iterator edge_end() const{
return IncidentIterator(graph_, degree(), pid_);
}
// HW1: YOUR CODE HERE
// Supply definitions AND SPECIFICATIONS for:
// node_value_type& value();
// const node_value_type& value() const;
// size_type degree() const;
// incident_iterator edge_begin() const;
// incident_iterator edge_end() const;
/** Test whether this node and @a n are equal.
*
* Equal nodes have the same graph and the same index.
*/
bool operator==(const Node& n) const {
if (this->graph_ == n.graph_ && this->pid_ == n.pid_){
return true;
}
// HW0: YOUR CODE HERE
return false;
}
/** Test whether this node is less than @a n in a global order.
*
* This ordering function is useful for STL containers such as
* std::map<>. It need not have any geometric meaning.
*
* The node ordering relation must obey trichotomy: For any two nodes x
* and y, exactly one of x == y, x < y, and y < x is true.
*/
bool operator<(const Node& n) const {
std::less <void*> compare;
// a function to compare pointers
if (compare(this->graph_, n.graph_)){
return true;
}
if (this->graph_ == n.graph_ && this->pid_ < n.pid_){
return true;
}
// HW0: YOUR CODE HERE
return false;
}
private:
// Allow Graph to access Node's private member data and functions.
friend class Graph;
Graph* graph_;
size_type pid_;
/** Construct a valid node. */
Node(const Graph* graph, size_type pid){
graph_ = const_cast<Graph*>(graph);
pid_ = pid;
}
// private constructor method of node
// HW0: YOUR CODE HERE
// Use this space to declare private data members and methods for Node
// that will not be visible to users, but may be useful within Graph.
// i.e. Graph needs a way to construct valid Node objects
};
/** Return the number of nodes in the graph.
*
* Complexity: O(1).
*/
size_type size() const {
return size_;
// HW0: YOUR CODE HERE
}
/** Synonym for size(). */
size_type num_nodes() const {
return size();
}
/** Add a node to the graph, returning the added node.
* @param[in] position The new node's position
* @post new num_nodes() == old num_nodes() + 1
* @post result_node.index() == old num_nodes()
*
* Complexity: O(1) amortized operations.
*/
Node add_node(const Point& position, const node_value_type& value = node_value_type()) {
internal_point my_point(position, value, size_);
points.push_back(my_point);
size_++;
i2u_.push_back(points.size() - 1);
std::vector<size_type>nd{};
adjs.push_back(nd);
std::map<size_type, edge_value_type> mp{};
edgevalues.push_back(mp);
return Node(this, size_ - 1);
// HW0: YOUR CODE HERE
}
/** Determine if a Node belongs to this Graph
* @return True if @a n is currently a Node of this Graph
*
* Complexity: O(1).
*/
bool has_node(const Node& n) const {
if (n.graph_ == this) return true;
// HW0: YOUR CODE HERE
return false;
}
/** Return the node with index @a i.
* @pre 0 <= @a i < num_nodes()
* @post result_node.index() == i
*
* Complexity: O(1).
*/
Node node(size_type i) const {
if (i < size_) return Node(this, i);
// HW0: YOUR CODE HERE
return Node(); // Invalid node
}
//
// EDGES
//
/** @class Graph::Edge
* @brief Class representing the graph's edges.
*
* Edges are order-insensitive pairs of nodes. Two Edges with the same nodes
* are considered equal if they connect the same nodes, in either order.
*/
class Edge: private totally_ordered<Edge> {
public:
/** Construct an invalid Edge. */
Edge() {
graph_ = nullptr;
// HW0: YOUR CODE HERE
}
/** Return a node of this Edge */
Node node1() const {
if (graph_ != nullptr){
return graph_->node(graph_->points[nd1_].idx_);
}
// HW0: YOUR CODE HERE
return Node(); // Invalid Node
}
/** Return the other node of this Edge */
Node node2() const {
if (graph_ != nullptr){
return graph_->node(graph_->points[nd2_].idx_);
}
// HW0: YOUR CODE HERE
return Node(); // Invalid Node
}
/** Test whether this edge and @a e are equal.
*
* Equal edges represent the same undirected edge between two nodes.
*/
bool operator==(const Edge& e) const {
if (this->graph_ == e.graph_ ){
if (nd1_ == e.nd1_ && nd2_ == e.nd2_)
return true;
if (nd1_ == e.nd2_ && nd2_ == e.nd1_)
return true;
}
//HW0: YOUR CODE HERE
return false;
}
/** Test whether this edge is less than @a e in a global order.
*
* This ordering function is useful for STL containers such as
* std::map<>. It need not have any interpretive meaning.
*/
bool operator<(const Edge& e) const {
std::less <void*> compare;
// a function to compare pointers
if (compare(this->graph_, e.graph_)){
return true;
}
if (this->graph_ == e.graph_ ){
if (std::min(nd1_, nd2_) < std::min(e.nd1_, e.nd2_))
return true;
if (std::min(nd1_, nd2_) == std::min(e.nd1_, e.nd2_) &&
std::max(nd1_, nd2_) < std::max(e.nd1_, e.nd2_))
return true;
}
//HW0: YOUR CODE HERE
return false;
}
double length() const{
return norm(node1().position() - node2().position());
}
edge_value_type& value(){
if (nd1_ < nd2_)
return graph_->edgevalues[nd1_][nd2_];
else{
return graph_->edgevalues[nd2_][nd1_];
}
}
const edge_value_type& value() const{
if (nd1_ < nd2_)
return graph_->edgevalues[nd1_][nd2_];
else{
return graph_->edgevalues[nd2_][nd1_];
}
}
private:
// Allow Graph to access Edge's private member data and functions.
friend class Graph;
Graph* graph_;
size_type nd1_;
size_type nd2_;
/** Construct a valid Edge. */
Edge(const Graph* graph, size_type nd1, size_type nd2){
graph_ = const_cast<Graph*>(graph);
nd1_ = nd1;
nd2_ = nd2;
}
// private constructor method of edge
// HW0: YOUR CODE HERE
// Use this space to declare private data members and methods for Edge
// that will not be visible to users, but may be useful within Graph.
// i.e. Graph needs a way to construct valid Edge objects
};
/** Return the total number of edges in the graph.
*
* Complexity: No more than O(num_nodes() + num_edges()), hopefully less
*/
size_type num_edges() const {
return num_edges_;
}
/** Return the edge with index @a i.
* @pre 0 <= @a i < num_edges()
*
* Complexity: No more than O(num_nodes() + num_edges()), hopefully less
*/
Edge edge(size_type i) const {
if (i < num_edges_){
return Edge(this, edges[i][0], edges[i][1]);
}
// HW0: YOUR CODE HERE
return Edge(); // Invalid Edge
}
/** Test whether two nodes are connected by an edge.
* @pre @a a and @a b are valid nodes of this graph
* @return True if for some @a i, edge(@a i) connects @a a and @a b.
*
* Complexity: No more than O(num_nodes() + num_edges()), hopefully less
*/
bool has_edge(const Node& a, const Node& b) const {
// check if a and b are distinct valid nodes of this graph
if (!(a == b) && a.graph_ == this && b.graph_ == this){
if (std::find(adjs[i2u_[a.index()]].begin(), adjs[i2u_[a.index()]].end(), i2u_[b.index()]) != adjs[i2u_[a.index()]].end())
return true;
}
// HW0: YOUR CODE HERE
return false;
}
/** Add an edge to the graph, or return the current edge if it already exists.
* @pre @a a and @a b are distinct valid nodes of this graph
* @return an Edge object e with e.node1() == @a a and e.node2() == @a b
* @post has_edge(@a a, @a b) == true
* @post If old has_edge(@a a, @a b), new num_edges() == old num_edges().
* Else, new num_edges() == old num_edges() + 1.
*
* Can invalidate edge indexes -- in other words, old edge(@a i) might not
* equal new edge(@a i). Must not invalidate outstanding Edge objects.
*
* Complexity: No more than O(num_nodes() + num_edges()), hopefully less
*/
Edge add_edge(const Node& a, const Node& b) {
// check if a and b are distinct valid nodes of this graph
if (!(a == b) && a.graph_ == this && b.graph_ == this){
if (has_edge(a, b))
return Edge(this, i2u_[a.index()], i2u_[b.index()]);
// has_edge(a,b) == false, need to create new edge
adjs[i2u_[a.index()]].push_back(i2u_[b.index()]);
adjs[i2u_[b.index()]].push_back(i2u_[a.index()]);
std::vector<size_type> my_edge;
my_edge.push_back(i2u_[a.index()]);
my_edge.push_back(i2u_[b.index()]);
edges.push_back(my_edge);
// add new edge to the internal struct of edges
num_edges_++;
// new num_edges() == old num_edges() + 1.
return Edge(this, i2u_[a.index()], i2u_[b.index()]);
}
// HW0: YOUR CODE HERE
return Edge(); // Invalid Edge
}
/** Remove an edge
* @post has_edge(e.node1(), e.node2()) == false
* @post new num_edges() == old num_edges() - 1
* @return The number of edge that is removed
* Can invalidate edge indexes -- in other words, old edge(@a i) might not
* equal new edge(@a i). Will not invalidate outstanding Node and Edge objects except the removed edge.
* Can invalidate edge iterator and incident iterator.
* Complexity: O(num_edges())
*/
size_type remove_edge(const Edge& e){
adjs[e.nd1_].erase(std::find(adjs[e.nd1_].begin(), adjs[e.nd1_].end(), e.nd2_));
adjs[e.nd2_].erase(std::find(adjs[e.nd2_].begin(), adjs[e.nd2_].end(), e.nd1_));
auto x = edges.begin();
while(x != edges.end()){
if (((*x)[0] == e.nd1_ && (*x)[1] == e.nd2_) ||
((*x)[1] == e.nd1_ &&(*x)[0] == e.nd2_)){
(*x) = edges.back();
edges.pop_back();
break;
}
++x;
}
num_edges_--;
return 1;
}
/** Remove an edge
* @post has_edge(n1, n2) == false
* @post If old has_edge(n1, n2) == true, new num_edges() == old num_edges() - 1
* Else, new num_edges() == old num_edges().
* @return The number of edge that is removed
* Can invalidate edge indexes -- in other words, old edge(@a i) might not
* equal new edge(@a i). Will not invalidate outstanding Node and Edge objects except the removed edge.
* Can invalidate edge iterator and incident iterator.
* Complexity: O(num_edges())
*/
size_type remove_edge(const Node& n1, const Node& n2){
if (!has_edge(n1, n2)) return 0;
return remove_edge(add_edge(n1, n2));
}
/** Remove an edge
* @post has_edge((*e_it).node1(), (*e_it).node2()) == false
* @post new num_edges() == old num_edges() - 1
* @return The iterator which refers to another edge
* Can invalidate edge indexes -- in other words, old edge(@a i) might not
* equal new edge(@a i). Will not invalidate outstanding Node and Edge objects except the removed edge.
* Can invalidate edge iterator and incident iterator.
* Complexity: O(num_edges())
*/
edge_iterator remove_edge(edge_iterator e_it){
remove_edge(*e_it);
return e_it;
}
/** Remove a node
* @post new num_nodes() == old num_nodes() - 1
* @return The number of node that is removed.
* Will invalidate outstanding Node and Edge and iterator objects.
* Complexity: O(num_edges()) + O(num_nodes()))
*/
size_type remove_node(const Node& n){
auto x = n.edge_begin();
while (x != n.edge_end()){
remove_edge(*x);
}
points[i2u_.back()].idx_ = n.index();
i2u_[n.index()] = i2u_.back();
i2u_.pop_back();
size_--;
return 1;
}
/** Remove a node
* @post new num_nodes() == old num_nodes() - 1
* @return The iterator which refers to another node
* Will invalidate outstanding Node and Edge and iterator objects.
* Complexity: O(num_edges()) + O(num_nodes()))
*/
node_iterator remove_node(node_iterator n_it){
remove_node(*n_it);
return n_it;
}
/** Remove all nodes and edges from this graph.
* @post num_nodes() == 0 && num_edges() == 0
*
* Invalidates all outstanding Node and Edge objects.
*/
void clear() {
size_ = 0;
num_edges_ = 0;
points = std::vector<internal_point>();
edges = std::vector<std::vector<size_type>>();
adjs = std::vector<std::vector<size_type>>();
i2u_ = std::vector<size_type>();
// HW0: YOUR CODE HERE
}
//
// Node Iterator
//
/** @class Graph::NodeIterator
* @brief Iterator class for nodes. A forward iterator. */
class NodeIterator {
public:
// These type definitions let us use STL's iterator_traits.
using value_type = Node; // Element type
using pointer = Node*; // Pointers to elements
using reference = Node&; // Reference to elements
using difference_type = std::ptrdiff_t; // Signed difference
using iterator_category = std::forward_iterator_tag; // Weak Category, Proxy
/** Construct an invalid NodeIterator. */
NodeIterator() {
}
/** The dereference operator
*@return the node the iterator refers to*/
Node operator*() const{
return grh->node(i);
}
/** the increment operator
*@return the iterator which refers to the subsequent node*/
NodeIterator& operator++(){
i++;
return *this;
}
/** the equality comparision operator
*@param[in] ndit the iterator which is compared with the present iterator
*@return true if they refer to the same node; false otherwise */
bool operator==(const NodeIterator& ndit) const{
return (grh == ndit.grh && i == ndit.i);
}
/** the inequality comparision operator
*@param[in] ndit the iterator which is compared with the present iterator
*@return false if they refer to the same node; true otherwise */
bool operator!=(const NodeIterator& ndit) const{
return (grh != ndit.grh || i != ndit.i);
}
// HW1 #2: YOUR CODE HERE
// Supply definitions AND SPECIFICATIONS for:
// Node operator*() const
// NodeIterator& operator++()
// bool operator==(const NodeIterator&) const
private:
friend class Graph;
Graph* grh;
size_type i;
/** Construct a valid NodeIterator. */
NodeIterator(const Graph* g, size_type j) {
grh = const_cast<Graph*>(g);
i = j;
}
// HW1 #2: YOUR CODE HERE
};
/** @return the start of the node iterator*/
node_iterator node_begin() const{
return NodeIterator(this, 0);
}
/** @return the end of the node iterator*/
node_iterator node_end() const{
return NodeIterator(this, size_);
}
// HW1 #2: YOUR CODE HERE
// Supply definitions AND SPECIFICATIONS for:
// node_iterator node_begin() const
// node_iterator node_end() const
//
// Incident Iterator
//
/** @class Graph::IncidentIterator
* @brief Iterator class for edges incident to a node. A forward iterator. */
class IncidentIterator {
public:
// These type definitions let us use STL's iterator_traits.
using value_type = Edge; // Element type
using pointer = Edge*; // Pointers to elements
using reference = Edge&; // Reference to elements
using difference_type = std::ptrdiff_t; // Signed difference
using iterator_category = std::forward_iterator_tag; // Weak Category, Proxy
/** Construct an invalid IncidentIterator. */
IncidentIterator() {
}
/** The dereference operator
*@return the edge the iterator refers to*/
Edge operator*() const{
return grh->add_edge(grh->node(nd), grh->node(grh->points[grh->adjs[grh->i2u_[nd]][i]].idx_));
}
/** the increment operator
*@return the iterator which refers to the subsequent edge*/
IncidentIterator& operator++(){
i++;
return *this;
}
/** the equality comparision operator
*@param[in] idit the iterator which is compared with the present iterator
*@return true if they are based on the same node and refer to the
same edge; false otherwise */
bool operator==(const IncidentIterator& idit) const{
return (grh == idit.grh && nd == idit.nd && i == idit.i);
}
/** the inequality comparision operator
*@param[in] idit the iterator which is compared with the present iterator
*@return false if they are based on the same node and refer to the
same edge; true otherwise */
bool operator!=(const IncidentIterator& idit) const{
return (grh != idit.grh || nd != idit.nd || i != idit.i);
}
// HW1 #3: YOUR CODE HERE
// Supply definitions AND SPECIFICATIONS for:
// Edge operator*() const
// IncidentIterator& operator++()
// bool operator==(const IncidentIterator&) const
private:
friend class Graph;
Graph* grh;
size_type i;
size_type nd;
/** Construct a valid IncidentIterator. */
IncidentIterator(Graph* g, size_type j, size_type nd_){
grh = g;
i = j;
nd = nd_;
}
// HW1 #3: YOUR CODE HERE
};
//
// Edge Iterator
//
/** @class Graph::EdgeIterator
* @brief Iterator class for edges. A forward iterator. */
class EdgeIterator {
public:
// These type definitions let us use STL's iterator_traits.
using value_type = Edge; // Element type
using pointer = Edge*; // Pointers to elements
using reference = Edge&; // Reference to elements
using difference_type = std::ptrdiff_t; // Signed difference
using iterator_category = std::input_iterator_tag; // Weak Category, Proxy
/** Construct an invalid EdgeIterator. */
EdgeIterator() {
}
/** The dereference operator
*@return the edge the iterator refers to*/
Edge operator*() const{
return grh->edge(i);
}
/** the increment operator
*@return the iterator which refers to the subsequent edge*/
EdgeIterator& operator++(){
i++;
return *this;
}
/** the equality comparision operator
*@param[in] egit the iterator which is compared with the present iterator
*@return true if they refer to the same edge; false otherwise */
bool operator==(const EdgeIterator& egit) const{
return (grh == egit.grh && i == egit.i);
}
/** the inequality comparision operator
*@param[in] egit the iterator which is compared with the present iterator
*@return false if they refer to the same edge; true otherwise */
bool operator!=(const EdgeIterator& egit) const{
return (grh != egit.grh || i != egit.i);
}
// HW1 #5: YOUR CODE HERE
// Supply definitions AND SPECIFICATIONS for:
// Edge operator*() const
// EdgeIterator& operator++()
// bool operator==(const EdgeIterator&) const
private:
friend class Graph;
Graph* grh;
size_type i;
/** Construct a valid EdgeIterator. */
EdgeIterator(const Graph* g, size_type j) {
grh = const_cast<Graph*>(g);
i = j;
}
// HW1 #5: YOUR CODE HERE
};
/** @return the start of the edge iterator*/
edge_iterator edge_begin() const{
return EdgeIterator(this, 0);
}
/** @return the end of the edge iterator*/
edge_iterator edge_end() const{
return EdgeIterator(this, num_edges_);
}
// HW1 #5: YOUR CODE HERE
// Supply definitions AND SPECIFICATIONS for:
// edge_iterator edge_begin() const
// edge_iterator edge_end() const
private:
struct internal_point{
Point position;
node_value_type value_;
size_type idx_;
/** Construct internal_point*/
internal_point(const Point& position, node_value_type value, size_type idx){
this->position = position;
this->value_ = value;
this->idx_ = idx;
}
};
// internal struct to store point information
std::vector<size_type> i2u_;
std::vector<internal_point> points;
std::vector<std::vector<size_type>> adjs;
std::vector<std::vector<size_type>> edges;
std::vector<std::map<size_type, edge_value_type>> edgevalues;
// internal struct to store edge information
size_type size_;
size_type num_edges_;
// HW0: YOUR CODE HERE
// Use this space for your Graph class's internals:
// helper functions, data members, and so forth.
};
#endif // CME212_GRAPH_HPP
| [
"="
] | = |
ff94cf462016ebd61347322f8b04e5a038ab8ba9 | 3b2abde581b31629746441150d445dc4dee62b89 | /Esami 2020/compito_02_2020/es3_compila_or_not.cpp | 052e75309e01189ea9ee75aef7aa49660ef144c1 | [] | no_license | TheBesk/PAO-esercizi | 36a1bb1b06b0aa1b0a027ee49a42d567c67afa62 | a35ffcb9acca76c6732301eebaac73242ef95c1e | refs/heads/master | 2022-12-24T15:20:09.688013 | 2020-09-24T11:51:17 | 2020-09-24T11:51:17 | 300,284,251 | 0 | 0 | null | 2020-10-01T13:11:57 | 2020-10-01T13:11:56 | null | UTF-8 | C++ | false | false | 1,503 | cpp | // Dire se il main() compila o non compila
#include <iostream>
#include <string>
using namespace std;
class Z {
public:
operator int() const {return 0;}
};
template<class T> class D; // dichiarazione incompleta
template<class T1, class T2 = Z, int k = 1>
class C {
friend class D<T1>;
private:
T1 t1;
T2 t2;
int a;
C(int x =k): a(x) {}
};
template<class T>
class D {
public:
void f() const {C<T,T> c(1); cout << c.t1 << c.t2 << c.a;}
void g() const {C<int> c;}
void h() const {C<T,int> c(3); cout << c.t2 << c.a;}
void m() const {C<int,T,3> c; cout << c.t1;}
void n() const {C<int,double> c; cout << c.t1 << c.t2 << c.a;}
void o() const {C<char,double> c(6); cout << c.a;}
void p() const {C<Z,T,7> c(7); cout << c.t2 << c.a;}
};
// int main() { D<char> d1; d1.f(); }
// int main() { D<std::string> d2; d2.f(); }
// int main() { D<char> d3; d3.g(); }
// int main() { D<int> d4; d4.g(); }
// int main() { D<char> d5; d5.h(); }
// int main() { D<int> d6; d6.h(); }
// int main() { D<char> d7; d7.m(); }
// int main() { D<int> d8; d8.m(); }
// int main() { D<char> d9; d9.n(); }
// int main() { D<Z> d10; d10.n(); }
// int main() { D<char> d11; d11.o(); }
// int main() { D<Z> d12; d12.o(); }
// int main() { D<char> d13; d13.p(); }
// int main() { D<Z> d14; d14.p(); }
// Soluzione
// Compila
// Compila
// Non Compila
// Compila
// Compila
// Compila
// Non Compila
// Compila
// Non Compila
// Non Compila
// Compila
// Non Compila
// Non Compila
// Compila | [
"martin.masevski@gmail.com"
] | martin.masevski@gmail.com |
60b3b8cdc5e05612c3817221e4f5cc435e36d40c | eacb94b1e073d390c7f24c3b3bb59d3e600f204a | /ocelot/ocelot/transforms/interface/LoopUnrollingPass.h | b633232eb957baf224c18cd8d7402b44725cd284 | [
"BSD-3-Clause"
] | permissive | mprevot/gpuocelot | b04d20ee58958efd7146ab7b3e798df8127b1a9c | d9277ef05a110e941aef77031382d0260ff115ef | refs/heads/master | 2020-10-01T19:01:38.047090 | 2019-12-12T12:41:41 | 2019-12-12T12:41:41 | 227,603,673 | 1 | 0 | BSD-3-Clause | 2019-12-12T12:38:19 | 2019-12-12T12:38:19 | null | UTF-8 | C++ | false | false | 766 | h | /*! \brief LoopUnrollingPass.h
\author Gregory Diamos <gregory.diamos@gatech.edu>
\date Wednesday May 2, 2012
\brief The header file for the LoopUnrollingPass class.
*/
#pragma once
// Ocelot Includes
#include <ocelot/transforms/interface/Pass.h>
namespace transforms
{
/*! \brief A class for splitting basic blocks larger than a specified size */
class LoopUnrollingPass : public KernelPass
{
public:
/*! \brief The constructor sets pass type and dependencies */
LoopUnrollingPass();
public:
/*! \brief Initialize the pass using a specific module */
void initialize(const ir::Module& m);
/*! \brief Run the pass on a specific kernel in the module */
void runOnKernel(ir::IRKernel& k);
/*! \brief Finalize the pass */
void finalize();
};
}
| [
"solusstultus@gmail.com"
] | solusstultus@gmail.com |
c16e07abd2aaec0978c2f22ea911e81298b1afe0 | 00306216906858239223b8bbe999c8fa36e10739 | /aws-cpp-sdk-glue/include/aws/glue/model/ImportCatalogToGlueRequest.h | ff95d595cbc11aa90613af6c968743f00608f277 | [
"MIT",
"Apache-2.0",
"JSON"
] | permissive | pcacjr/aws-sdk-cpp | ceea79f54b5656b1e6a7257aa8d37fb6d2609951 | 90eb0ee4be28ac23efc10c8eedf21235f9a37402 | refs/heads/master | 2021-01-19T05:48:16.578394 | 2017-09-25T00:36:13 | 2017-09-25T00:36:13 | 87,451,109 | 0 | 0 | null | 2017-04-06T16:26:57 | 2017-04-06T16:26:57 | null | UTF-8 | C++ | false | false | 3,211 | h | /*
* Copyright 2010-2017 Amazon.com, Inc. or its affiliates. All Rights Reserved.
*
* Licensed under the Apache License, Version 2.0 (the "License").
* You may not use this file except in compliance with the License.
* A copy of the License is located at
*
* http://aws.amazon.com/apache2.0
*
* or in the "license" file accompanying this file. This file is distributed
* on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either
* express or implied. See the License for the specific language governing
* permissions and limitations under the License.
*/
#pragma once
#include <aws/glue/Glue_EXPORTS.h>
#include <aws/glue/GlueRequest.h>
#include <aws/core/utils/memory/stl/AWSString.h>
#include <utility>
namespace Aws
{
namespace Glue
{
namespace Model
{
/**
*/
class AWS_GLUE_API ImportCatalogToGlueRequest : public GlueRequest
{
public:
ImportCatalogToGlueRequest();
// Service request name is the Operation name which will send this request out,
// each operation should has unique request name, so that we can get operation's name from this request.
// Note: this is not true for response, multiple operations may have the same response name,
// so we can not get operation's name from response.
inline virtual const char* GetServiceRequestName() override { return "ImportCatalogToGlue"; }
Aws::String SerializePayload() const override;
Aws::Http::HeaderValueCollection GetRequestSpecificHeaders() const override;
/**
* <p>The ID of the catalog to import. Currently, this should be the AWS account
* ID.</p>
*/
inline const Aws::String& GetCatalogId() const{ return m_catalogId; }
/**
* <p>The ID of the catalog to import. Currently, this should be the AWS account
* ID.</p>
*/
inline void SetCatalogId(const Aws::String& value) { m_catalogIdHasBeenSet = true; m_catalogId = value; }
/**
* <p>The ID of the catalog to import. Currently, this should be the AWS account
* ID.</p>
*/
inline void SetCatalogId(Aws::String&& value) { m_catalogIdHasBeenSet = true; m_catalogId = std::move(value); }
/**
* <p>The ID of the catalog to import. Currently, this should be the AWS account
* ID.</p>
*/
inline void SetCatalogId(const char* value) { m_catalogIdHasBeenSet = true; m_catalogId.assign(value); }
/**
* <p>The ID of the catalog to import. Currently, this should be the AWS account
* ID.</p>
*/
inline ImportCatalogToGlueRequest& WithCatalogId(const Aws::String& value) { SetCatalogId(value); return *this;}
/**
* <p>The ID of the catalog to import. Currently, this should be the AWS account
* ID.</p>
*/
inline ImportCatalogToGlueRequest& WithCatalogId(Aws::String&& value) { SetCatalogId(std::move(value)); return *this;}
/**
* <p>The ID of the catalog to import. Currently, this should be the AWS account
* ID.</p>
*/
inline ImportCatalogToGlueRequest& WithCatalogId(const char* value) { SetCatalogId(value); return *this;}
private:
Aws::String m_catalogId;
bool m_catalogIdHasBeenSet;
};
} // namespace Model
} // namespace Glue
} // namespace Aws
| [
"henso@amazon.com"
] | henso@amazon.com |
01318b4f3d4a40dacffde33325bb3b1c0f450d7c | d3a7f028b751cffa077736200bb8234db2833bcf | /src/Texture.cpp | 9d7c45ef88a2ee648d9e7f1a6e45939f23bd88ff | [] | no_license | eruchii/2048-btl | 3671b0eccce267c24f0a54aca70b534e87f49c22 | 35bca557529dba2db067b09df6ec6d07c5456620 | refs/heads/master | 2020-05-17T13:14:07.739569 | 2019-05-15T04:23:59 | 2019-05-15T04:23:59 | 183,730,896 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,027 | cpp | #include "Texture.h"
#include <SDL2/SDL_image.h>
#include <SDL2/SDL_ttf.h>
#include "Window.h"
#include "Render.h"
#include "Font.h"
Texture::Texture(){
m_texture = NULL;
m_width = 0;
m_height = 0;
}
Texture::~Texture(){
free();
}
bool Texture::loadText(Font *font, const char *text, SDL_Color fgColor){
free();
SDL_Texture *newTexture = NULL;
SDL_Surface *textSurface = font->renderLatin(text, fgColor);
if(textSurface == NULL) {
printf("Unable to render text surface! SDL_ttf Error: %s\n", TTF_GetError());
}
else {
newTexture = g_render.createTextureFromSurface(textSurface);
if(newTexture == NULL) {
printf("Unable to create texture from rendered text! SDL Error: %s\n", SDL_GetError());
}
else {
m_width = textSurface->w;
m_height = textSurface->h;
}
SDL_FreeSurface(textSurface);
}
m_texture = newTexture;
return m_texture != NULL;
}
void Texture::free(){
if(m_texture != NULL) {
SDL_DestroyTexture(m_texture);
m_texture = NULL;
m_width = 0;
m_height = 0;
}
}
void Texture::setBlendMode(SDL_BlendMode blending){
SDL_SetTextureBlendMode(m_texture, blending);
}
void Texture::setAlpha(Uint8 alpha){
SDL_SetTextureAlphaMod(m_texture, alpha);
}
void Texture::render(int x, int y, SDL_Rect *clip){
SDL_Rect renderQuad = { x, y, m_width, m_height };
if(clip != NULL) {
renderQuad.w = clip->w;
renderQuad.h = clip->h;
}
g_render.copy(m_texture, clip, &renderQuad);
}
void Texture::renderScaled(int x, int y, double ratio){
SDL_Rect dstRect = {
x, y,
static_cast<int>(m_width * ratio), static_cast<int>(m_width * ratio)
};
g_render.copy(m_texture, NULL, &dstRect);
}
bool Texture::createBlank(int width, int height, SDL_TextureAccess access){
m_texture = g_render.createTexture(SDL_PIXELFORMAT_RGBA8888, access, width, height);
if( m_texture == NULL ){
printf( "Unable to create blank texture! SDL Error: %s\n", SDL_GetError() );
}
else{
m_width = width;
m_height = height;
}
return m_texture != NULL;
}
| [
"nct1120@gmail.com"
] | nct1120@gmail.com |
6b27576f83c3c0feeb369267b94deea9fd950e38 | 80ceb0a72803089f5de8663ef0c97079d7aa57eb | /User.cpp | 692e78acad00ae477d450637f2de629640ce1a46 | [] | no_license | richardjkendall/pam-dynamo | 296b895a49084998c26ee1ae41e182520a1ef94e | 855da736365b11752269c1c5ee71de83dc1d348c | refs/heads/master | 2022-09-01T16:52:19.405494 | 2022-08-11T20:07:52 | 2022-08-11T20:07:52 | 244,859,524 | 2 | 0 | null | 2022-08-11T20:16:37 | 2020-03-04T09:31:55 | C++ | UTF-8 | C++ | false | false | 7,379 | cpp | #include <iostream>
#include <iomanip>
#include <aws/core/Aws.h>
#include <aws/core/utils/Outcome.h>
#include <aws/dynamodb/DynamoDBClient.h>
#include <aws/dynamodb/model/AttributeDefinition.h>
#include <aws/dynamodb/model/GetItemRequest.h>
#include <openssl/evp.h>
#include "User.h"
#include "Log.h"
#include "Cache.h"
User::User(std::string p_region, std::string p_ddbtable, std::string p_realm, std::string p_dir, int dur, std::string p_username) {
region = p_region;
ddbtable = p_ddbtable;
realm = p_realm;
username = p_username;
cache_location = p_dir;
session_dur = dur;
}
// based on this code https://stackoverflow.com/questions/2262386/generate-sha256-with-openssl-and-c
// and this code https://wiki.openssl.org/index.php/EVP_Message_Digests
bool hash_password(const std::string& unhashed, std::string& hashed) {
EVP_MD_CTX *mdctx;
bool success = false;
mdctx = EVP_MD_CTX_new();
if(mdctx != NULL) {
if(EVP_DigestInit_ex(mdctx, EVP_sha3_256(), NULL)) {
if(EVP_DigestUpdate(mdctx, unhashed.c_str(), unhashed.length())) {
unsigned char hash[EVP_MAX_MD_SIZE];
unsigned int lengthOfHash = 0;
if(EVP_DigestFinal_ex(mdctx, hash, &lengthOfHash)) {
std::stringstream ss;
for(unsigned int i = 0; i < lengthOfHash; ++i) {
ss << std::hex << std::setw(2) << std::setfill('0') << (int)hash[i];
}
hashed = ss.str();
success = true;
}
} else {
// could not add message to digest
std::clog << kLogErr << "Unable to add password to digest" << std::endl;
}
} else {
// could not init digest algorithm
std::clog << kLogErr << "Unable to init digest algorithm" << std::endl;
}
EVP_MD_CTX_free(mdctx);
} else {
// could not get message digest context
std::clog << kLogErr << "Could not get message digest context" << std::endl;
}
return success;
}
bool User::authenticate(std::string password) {
bool ret_val = false;
// need to hash the password before we check the cache
std::string hashed_pword;
if(hash_password(password, hashed_pword)) {
std::clog << kLogDebug << "Hashed input password = " << hashed_pword << std::endl;
} else {
// failed to hash password
std::clog << kLogErr << "Hashing password failed" << std::endl;
return(false);
}
// need to check for a valid cache record with salt
std::clog << kLogInfo << "Checking cache for valid salt value" << std::endl;
Cache c(realm, cache_location, session_dur);
std::string cache_salt;
if(c.get_user_from_cache(username, cache_salt)) {
// there's a record in the cache
std::clog << kLogInfo << "Got salt from cache = " << cache_salt << std::endl;
// so we need to rehash the password along with the salt
hash_password(cache_salt + password, hashed_pword);
std::clog << kLogInfo << "Rehashed password = " << hashed_pword << std::endl;
}
// check the cache
std::clog << kLogInfo << "Checking cache for username/password combination" << std::endl;
if(c.check_cache(username, hashed_pword)) {
// user is in the cache
// so exit here with true
std::clog << kLogInfo << "User found in cache, skipping AWS call" << std::endl;
return(true);
}
std::clog << kLogInfo << "User not in cache, calling AWS..." << std::endl;
// user not in cache, so keep running
Aws::SDKOptions options;
std::clog << kLogInfo << "Init for AWS API" << std::endl;
Aws::InitAPI(options);
{
// get strings ready
const Aws::String as_ddbtable(ddbtable.c_str());
const Aws::String as_realm(realm.c_str());
const Aws::String as_username(username.c_str());
const Aws::String as_region(region.c_str());
// get request ready
Aws::Client::ClientConfiguration clientConfig;
clientConfig.region = as_region;
Aws::DynamoDB::DynamoDBClient dynamoClient(clientConfig);
Aws::DynamoDB::Model::GetItemRequest req;
// set table
req.SetTableName(as_ddbtable);
// add hash key (auth realm)
Aws::DynamoDB::Model::AttributeValue hashKey;
hashKey.SetS(as_realm);
req.AddKey("realm", hashKey);
// add sort key (username)
Aws::DynamoDB::Model::AttributeValue sortKey;
sortKey.SetS(as_username);
req.AddKey("user", sortKey);
// fire request to API
std::clog << kLogInfo << "Calling DynamoDB API in region=" << region << std::endl;
const Aws::DynamoDB::Model::GetItemOutcome& result = dynamoClient.GetItem(req);
std::clog << kLogInfo << "Back from call to API" << std::endl;
if(result.IsSuccess()) {
std::clog << kLogInfo << "Result is a success from API" << std::endl;
// got a response
const Aws::Map<Aws::String, Aws::DynamoDB::Model::AttributeValue>& item = result.GetResult().GetItem();
if (item.size() > 1) {
// got an item, check to see if password is present
if(item.count("password") > 0) {
// check if we have salt
std::string std_salt;
bool salted = false;
if(item.count("salt") > 0) {
std::clog << kLogInfo << "Got salt, so re-hashing password with salt" << std::endl;
Aws::String salt = item.find("salt")->second.GetS();
std_salt = std::string(salt.c_str(), salt.size());
hash_password(std_salt + password, hashed_pword);
salted = true;
}
// get password from record
Aws::String saved_password = item.find("password")->second.GetS();
std::string std_saved_password(saved_password.c_str(), saved_password.size());
std::clog << kLogDebug << "Password from record = " << std_saved_password << std::endl;
// compare the password hashes
if(std_saved_password.compare(hashed_pword) == 0) {
std::clog << kLogInfo << "Password matches what is stored" << std::endl;
// need to update the cache
// if salted we should store the salt
if(salted) {
if(c.save_in_cache_w_salt(username, hashed_pword, std_salt)) {
std::clog << kLogInfo << "Saved in cache with salt" << std::endl;
} else {
std::clog << kLogErr << "Unable to save in cache, check previous messages" << std::endl;
}
ret_val = true;
} else {
if(c.save_in_cache(username, hashed_pword)) {
std::clog << kLogInfo << "Saved in cache without salt" << std::endl;
} else {
std::clog << kLogErr << "Unable to save in cache, check previous messages" << std::endl;
}
ret_val = true;
}
} else {
std::clog << kLogInfo << "Password does not match what is stored" << std::endl;
ret_val = false;
}
} else {
std::clog << kLogInfo << "No item with password field found" << std::endl;
}
} else {
// got no items, user does not exist
std::clog << kLogInfo << "No user found in realm=" << realm << ", with username=" << username << std::endl;
ret_val = false;
}
} else {
std::clog << kLogErr << "Failed to query table=" << ddbtable << ", error message=" << result.GetError().GetMessage();
ret_val = false;
}
}
Aws::ShutdownAPI(options);
return ret_val;
} | [
"richard.kendall@gmail.com"
] | richard.kendall@gmail.com |
e8c74e818199b44cdda753afaa7721405632304d | 42aaeaf7175c95d5031bbfa00f53b8343e251dde | /Source/OpenGL/Shape/BinaryShape.h | b55013d7e5af1310f1bd80d2fc674f04729351e6 | [] | no_license | stevenaubertin/VideoTexture | 653ad8492cabab0a88f2ca89be5e819046f1eb63 | 799207d0e3988708b15de93f031ce434ae7fe5c9 | refs/heads/master | 2021-01-01T05:22:08.675035 | 2016-05-18T20:32:54 | 2016-05-18T20:32:54 | 59,149,010 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,069 | h | //
// BinaryShape.h
// OpenGLAppExample
//
// Created by Steven Aubertin on 2016-04-05.
//
//
#ifndef BinaryShape_h
#define BinaryShape_h
#include "../../../JuceLibraryCode/JuceHeader.h"
#include "../Object/WavefrontObjParser.h"
class BinaryShape : public Shape{
WavefrontObjFile shapeFile;
class VertexBuffer;
OwnedArray<VertexBuffer> vertexBuffers;
public:
BinaryShape (OpenGLContext& openGLContext, const char* binObj){
if (shapeFile.load(binObj).wasOk()){
for (int i = 0; i < shapeFile.shapes.size(); ++i){
vertexBuffers.add (new VertexBuffer (openGLContext, *shapeFile.shapes.getUnchecked(i)));
}
}
}
void draw (OpenGLContext& openGLContext, Attributes& glAttributes) override{
for (int i = 0; i < vertexBuffers.size(); ++i){
VertexBuffer& vertexBuffer = *vertexBuffers.getUnchecked (i);
vertexBuffer.bind();
glAttributes.enable (openGLContext);
glDrawElements (GL_TRIANGLES, vertexBuffer.numIndices, GL_UNSIGNED_INT, 0);
glAttributes.disable (openGLContext);
}
}
private:
struct VertexBuffer{
GLuint vertexBuffer, indexBuffer;
int numIndices;
OpenGLContext& openGLContext;
VertexBuffer (OpenGLContext& context, WavefrontObjFile::Shape& aShape)
: openGLContext (context){
numIndices = aShape.mesh.indices.size();
openGLContext.extensions.glGenBuffers (1, &vertexBuffer);
openGLContext.extensions.glBindBuffer (GL_ARRAY_BUFFER, vertexBuffer);
Array<Vertex> vertices;
createVertexListFromMesh (aShape.mesh, vertices, Colours::green);
openGLContext.extensions.glBufferData (GL_ARRAY_BUFFER,
static_cast<GLsizeiptr> (static_cast<size_t> (vertices.size()) * sizeof (Vertex)),
vertices.getRawDataPointer(), GL_STATIC_DRAW);
openGLContext.extensions.glGenBuffers (1, &indexBuffer);
openGLContext.extensions.glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
openGLContext.extensions.glBufferData (GL_ELEMENT_ARRAY_BUFFER,
static_cast<GLsizeiptr> (static_cast<size_t> (numIndices) * sizeof (juce::uint32)),
aShape.mesh.indices.getRawDataPointer(), GL_STATIC_DRAW);
}
~VertexBuffer(){
openGLContext.extensions.glDeleteBuffers (1, &vertexBuffer);
openGLContext.extensions.glDeleteBuffers (1, &indexBuffer);
}
void bind(){
openGLContext.extensions.glBindBuffer (GL_ARRAY_BUFFER, vertexBuffer);
openGLContext.extensions.glBindBuffer (GL_ELEMENT_ARRAY_BUFFER, indexBuffer);
}
JUCE_DECLARE_NON_COPYABLE_WITH_LEAK_DETECTOR (VertexBuffer)
};
};
#endif /* BinaryShape_h */
| [
"stevenaubertin@gmail.com"
] | stevenaubertin@gmail.com |
f9186d17e650939401fc208fa04f3d11a448a338 | c55da57397bbc6332abf13f1768159eff33a3c53 | /bcpptgp/cpptgp_3e/chapter_05/taking_damage.cpp | a1e710178bb090d5672ae15886612e39ca8a340c | [] | no_license | CaptGreg/SenecaOOP344-attic | 8e6ce5466b50453850a0c511a65c2b17f6c79311 | a820156063f0988a145890c5d0f9bb99ed02c2b6 | refs/heads/master | 2021-01-23T15:42:17.996306 | 2014-06-17T03:25:28 | 2014-06-17T03:25:28 | 16,585,502 | 1 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 659 | cpp | // Taking Damage
// Demonstrates function inlining
#include <iostream>
int radiation(int health);
using namespace std;
int main()
{
int health = 80;
cout << "Your health is " << health << "\n\n";
health = radiation(health);
cout << "After radiation exposure your health is " << health << "\n\n";
health = radiation(health);
cout << "After radiation exposure your health is " << health << "\n\n";
health = radiation(health);
cout << "After radiation exposure your health is " << health << "\n\n";
return 0;
}
inline int radiation(int health)
{
return (health / 2);
}
| [
"john.blair@senecacollege.ca"
] | john.blair@senecacollege.ca |
a86cc9433aa1560fb2124f434a6aeddf08de6997 | ac227cc22d5f5364e5d029a2cef83816a6954590 | /applications/physbam/physbam-lib/Public_Library/PhysBAM_Dynamics/Level_Sets/FAST_LEVELSET_ADVECTION.h | 2dcc443084cc6a20f287040e4ab7ceb3d0004761 | [
"BSD-3-Clause"
] | permissive | schinmayee/nimbus | 597185bc8bac91a2480466cebc8b337f5d96bd2e | 170cd15e24a7a88243a6ea80aabadc0fc0e6e177 | refs/heads/master | 2020-03-11T11:42:39.262834 | 2018-04-18T01:28:23 | 2018-04-18T01:28:23 | 129,976,755 | 0 | 0 | BSD-3-Clause | 2018-04-17T23:33:23 | 2018-04-17T23:33:23 | null | UTF-8 | C++ | false | false | 3,246 | h | //#####################################################################
// Copyright 2009, Doug Enright, Ronald Fedkiw, Frederic Gibou, Geoffrey Irving, Frank Losasso, Neil Molino, Avi Robinson-Mosher, Tamar Shinar, Jerry Talton, Elliot English.
// This file is part of PhysBAM whose distribution is governed by the license contained in the accompanying file PHYSBAM_COPYRIGHT.txt.
//#####################################################################
// Class FAST_LEVELSET_ADVECTION
//#####################################################################
#ifndef __FAST_LEVELSET_ADVECTION__
#define __FAST_LEVELSET_ADVECTION__
#include <PhysBAM_Geometry/Grids_Uniform_Level_Sets/FAST_LEVELSET.h>
#include <PhysBAM_Geometry/Level_Sets/LEVELSET_POLICY.h>
#include <PhysBAM_Dynamics/Level_Sets/LEVELSET_ADVECTION_1D.h>
#include <PhysBAM_Dynamics/Level_Sets/LEVELSET_ADVECTION_2D.h>
#include <PhysBAM_Dynamics/Level_Sets/LEVELSET_ADVECTION_3D.h>
#include <PhysBAM_Dynamics/Level_Sets/LEVELSET_ADVECTION_POLICY.h>
namespace PhysBAM {
template<class T_GRID>
class FAST_LEVELSET_ADVECTION:public LEVELSET_ADVECTION_POLICY<T_GRID>::LEVELSET_ADVECTION
{
typedef typename LEVELSET_ADVECTION_POLICY<T_GRID>::LEVELSET_ADVECTION BASE;
typedef typename LEVELSET_POLICY<T_GRID>::FAST_LEVELSET_T T_FAST_LEVELSET;
typedef typename T_GRID::VECTOR_T TV;typedef typename T_GRID::SCALAR T;typedef typename T_GRID::VECTOR_INT TV_INT;
typedef typename GRID_ARRAYS_POLICY<T_GRID>::ARRAYS_SCALAR T_ARRAYS_SCALAR;typedef typename T_ARRAYS_SCALAR::template REBIND<TV>::TYPE T_ARRAYS_VECTOR;
typedef typename GRID_ARRAYS_POLICY<T_GRID>::FACE_ARRAYS T_FACE_ARRAYS_SCALAR;typedef typename T_GRID::CELL_ITERATOR CELL_ITERATOR;typedef typename T_GRID::FACE_ITERATOR FACE_ITERATOR;
public:
using BASE::levelset;
using BASE::advection;
using BASE::reinitialization_cfl;using BASE::reinitialization_runge_kutta_order;using BASE::reinitialization_spatial_order;
int local_advection_spatial_order;
bool local_semi_lagrangian_advection;
FAST_LEVELSET_ADVECTION(T_FAST_LEVELSET* fast_levelset):
BASE(fast_levelset)
{
Use_Level_Set_Advection_Method();
};
FAST_LEVELSET_ADVECTION():
BASE(0) {};
void Use_Local_WENO_For_Advection()
{local_advection_spatial_order=5;local_semi_lagrangian_advection=false;}
void Use_Local_ENO_For_Advection(const int order=3)
{local_advection_spatial_order=order;local_semi_lagrangian_advection=false;assert(order >= 1 && order <= 3);}
void Use_Local_Semi_Lagrangian_Advection()
{local_semi_lagrangian_advection=true;local_advection_spatial_order=0;}
void Use_Level_Set_Advection_Method()
{local_semi_lagrangian_advection=false;local_advection_spatial_order=0;}
void Euler_Step(const T_ARRAYS_VECTOR& velocity,const T dt,const T time,const int number_of_ghost_cells);
void Euler_Step(const T_FACE_ARRAYS_SCALAR& velocity,const T dt,const T time,const int number_of_ghost_cells);
void Euler_Step_Of_Reinitialization(const T_ARRAYS_SCALAR& signed_distance,const T_ARRAYS_SCALAR& sign_phi,const T dt,const T time);
void Reinitialize(const int time_steps=10,const T time=0);
};
}
#endif
| [
"quhang@stanford.edu"
] | quhang@stanford.edu |
cf9a28952ee7d5fd910f6c1073ff7ecb94471370 | 2277375bd4a554d23da334dddd091a36138f5cae | /ThirdParty/Havok/Source/Common/Base/Math/Vector/Neon/hkNeonHalf8Util.inl | acb6a152b3eb02875623d5ea6826ce01841089ba | [] | no_license | kevinmore/Project-Nebula | 9a0553ccf8bdc1b4bb5e2588fc94516d9e3532bc | f6d284d4879ae1ea1bd30c5775ef8733cfafa71d | refs/heads/master | 2022-10-22T03:55:42.596618 | 2020-06-19T09:07:07 | 2020-06-19T09:07:07 | 25,372,691 | 6 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 3,450 | inl | /*
*
* Confidential Information of Telekinesys Research Limited (t/a Havok). Not for disclosure or distribution without Havok's
* prior written consent. This software contains code, techniques and know-how which is confidential and proprietary to Havok.
* Product and Trade Secret source code contains trade secrets of Havok. Havok Software (C) Copyright 1999-2013 Telekinesys Research Limited t/a Havok. All Rights Reserved. Use of this software is subject to the terms of an end user license agreement.
*
*/
#if defined(HK_HALF_IS_FLOAT)
#error not implemented
#endif
namespace hkHalf8Util
{
template<hkMathRoundingMode R, hkMathIoMode I>
/*static*/ HK_FORCE_INLINE void pack( hkVector4fParameter v0, hkVector4fParameter v1, hkHalf* HK_RESTRICT packedHalf8 )
{
hkVector4f vs0, vs1;
if ( R == HK_ROUND_NEAREST )
{
vs0.setMul( v0, hkVector4f::getConstant<HK_QUADREAL_PACK_HALF>());
vs1.setMul( v1, hkVector4f::getConstant<HK_QUADREAL_PACK_HALF>());
}
else
{
vs0 = v0;
vs1 = v1;
}
uint32x4_t vsi0 = vreinterpretq_u32_f32(vs0.m_quad);
uint32x4_t vsi1 = vreinterpretq_u32_f32(vs1.m_quad);
uint16x4_t r0 = vshrn_n_u32(vsi0, 16);
uint16x4_t r1 = vshrn_n_u32(vsi1, 16);
hkVector4f p; p.m_quad = vreinterpretq_f32_u32(vreinterpretq_u32_u16(vcombine_u16(r0, r1)) );
p.store<4>((hkFloat32*) packedHalf8);
}
/*static*/ HK_FORCE_INLINE void unpackFirst( hkVector4fParameter packedHalf8, hkVector4f& v0 )
{
uint32x4_t r0 = vshll_n_u16(vget_low_u16(vreinterpretq_u16_u32(vreinterpretq_u32_f32(packedHalf8.m_quad))), 16);
v0.m_quad = vreinterpretq_f32_u32(r0);
}
/*static*/ HK_FORCE_INLINE void unpackSecond( hkVector4fParameter packedHalf8, hkVector4f& v1 )
{
uint32x4_t r1 = vshll_n_u16(vget_low_u16(vreinterpretq_u16_u32(vreinterpretq_u32_f32(packedHalf8.m_quad))), 16);
v1.m_quad = vreinterpretq_f32_u32(r1);
}
template<hkMathIoMode I>
/*static*/ HK_FORCE_INLINE void unpack( const hkHalf* HK_RESTRICT packedHalf8, hkVector4f* HK_RESTRICT v0, hkVector4f* HK_RESTRICT v1 )
{
hkVector4f h; h.load<4>( (const hkFloat32*)packedHalf8 );
unpackFirst( h, *v0 );
unpackSecond( h, *v1 );
}
template<hkMathRoundingMode A>
/*static*/ HK_FORCE_INLINE void packInterleaved( hkVector4fParameter v0, hkVector4fParameter v1, hkVector4f& packedHalf8 )
{
HK_ERROR(0x68abe9e1, "Not implemented");
}
/*static*/ HK_FORCE_INLINE void unpackFirstInterleaved( hkVector4fParameter packedHalf8, hkVector4f& v0 )
{
HK_ERROR(0xc50f0b2, "Not implemented");
}
/*static*/ HK_FORCE_INLINE void unpackSecondInterleaved( hkVector4fParameter packedHalf8, hkVector4f& v1 )
{
HK_ERROR(0x42f5c60c, "Not implemented");
}
/*static*/ HK_FORCE_INLINE void unpackInterleaved( hkVector4fParameter packedHalf8, hkVector4f* HK_RESTRICT v0, hkVector4f* HK_RESTRICT v1 )
{
HK_ERROR(0x568b4066, "Not implemented");
}
}
/*
* Havok SDK - Base file, BUILD(#20130912)
*
* Confidential Information of Havok. (C) Copyright 1999-2013
* Telekinesys Research Limited t/a Havok. All Rights Reserved. The Havok
* Logo, and the Havok buzzsaw logo are trademarks of Havok. Title, ownership
* rights, and intellectual property rights in the Havok software remain in
* Havok and/or its suppliers.
*
* Use of this software for evaluation purposes is subject to and indicates
* acceptance of the End User licence Agreement for this product. A copy of
* the license is included with this software and is also available from salesteam@havok.com.
*
*/
| [
"dingfengyu@gmail.com"
] | dingfengyu@gmail.com |
f2379d36e7d3486d8c85bd10913e3923bc765c75 | 7104fd99b63a16dd740ebdc4a71c934ed7adf5eb | /src/ht4c.Odbc/OdbcStm.h | 8c3c17ef466c2e0d736f4fb2e89cce30d7934504 | [] | no_license | andysoftdev/ht4c | a44a24fe377cb8b7bc3242e7ff0e9416ec40aa47 | 1a8825a0c1c9e7e61326172abe5b5abd697de600 | refs/heads/master | 2023-05-27T19:09:19.588042 | 2023-05-16T15:35:01 | 2023-05-16T15:35:01 | 1,573,512 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,518 | h | /** -*- C++ -*-
* Copyright (C) 2010-2016 Thalmann Software & Consulting, http://www.softdev.ch
*
* This file is part of ht4c.
*
* ht4c 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 3
* of the License, or any later version.
*
* Hypertable 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., 51 Franklin Street, Fifth Floor, Boston, MA
* 02110-1301, USA.
*/
#pragma once
#ifdef __cplusplus_cli
#error compile native
#endif
namespace ht4c { namespace Odbc {
namespace Db {
class Table;
}
/// <summary>
/// Represents the odbc statements.
/// </summary>
class OdbcStm {
public:
OdbcStm( const std::string& tableId );
OdbcStm( Db::Table* table );
static std::string sysDbCreate( );
static std::string sysDbInsert( );
static std::string sysDbUpdateKey( );
static std::string sysDbUpdateValue( );
static std::string sysDbReadKeyAndValue( );
static std::string sysDbReadValue( );
static std::string sysDbExists( );
static std::string sysDbDelete( );
static std::string sysDbQueryKey( );
static std::string sysDbQueryKeyAndValue( );
std::string createTable( ) const;
std::string deleteTable( ) const;
std::string insert( ) const;
std::string deleteRow( ) const;
std::string deleteColumnFamily( ) const;
std::string deleteCell( ) const;
std::string deleteCellVersion( ) const;
std::string deleteCutoffTime( ) const;
std::string select( const std::string& columns, const std::string& predicate ) const;
std::string selectRowInterval( const std::string& columns, const std::string& predicate ) const;
std::string selectRowInterval( const std::string& columns, const std::string& predicate, bool startInclusive, bool endInclusive ) const;
std::string selectRow( const std::string& columns, const std::string& predicate ) const;
std::string selectRowColumnFamilyInterval( const std::string& columns, const std::string& predicate ) const;
std::string selectRowColumnFamily( const std::string& columns, const std::string& predicate ) const;
private:
std::string tableId;
};
} }
| [
"andy.softdev@bluewin.ch"
] | andy.softdev@bluewin.ch |
42078c8a7ffcf538a7fa124d324158fb99c524c4 | bb82a5f977bef455714c16e24e2d8254e2d0faa5 | /src/vendor/cget/include/pqrs/osx/iokit_return.hpp | d799bfe5c3f1c05ce21ae809deffe3561241af85 | [
"Unlicense"
] | permissive | pqrs-org/Karabiner-Elements | 4ae307d82f8b67547c161c7d46d2083a0fd07630 | d05057d7c769e2ff35638282e888a6d5eca566be | refs/heads/main | 2023-09-01T03:11:08.474417 | 2023-09-01T00:44:19 | 2023-09-01T00:44:19 | 63,037,806 | 8,197 | 389 | Unlicense | 2023-09-01T00:11:00 | 2016-07-11T04:57:55 | C++ | UTF-8 | C++ | false | false | 90 | hpp | ../../../cget/pkg/pqrs-org__cpp-osx-iokit_return/install/include/pqrs/osx/iokit_return.hpp | [
"tekezo@pqrs.org"
] | tekezo@pqrs.org |
93664b1e5d002aa388bbec386dc0960cfafdc8f3 | 85d0d91154ec618d14e1ced5f82dfeb081b6b767 | /include/osmium/io/pbf.hpp | f48659ff1881fdde42bf277b1291cff641064385 | [
"BSL-1.0",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | osmcode/libosmium | feb80237bbac6269039bd963a13c658498a4d70e | 345d19054c64e864e3995a309a2e775d9551adf9 | refs/heads/master | 2023-08-03T07:12:55.748491 | 2023-06-20T08:00:37 | 2023-06-20T08:00:37 | 11,733,070 | 404 | 134 | BSL-1.0 | 2023-05-02T10:06:39 | 2013-07-29T06:47:29 | C++ | UTF-8 | C++ | false | false | 2,029 | hpp | #ifndef OSMIUM_IO_PBF_HPP
#define OSMIUM_IO_PBF_HPP
/*
This file is part of Osmium (https://osmcode.org/libosmium).
Copyright 2013-2023 Jochen Topf <jochen@topf.org> and others (see README).
Boost Software License - Version 1.0 - August 17th, 2003
Permission is hereby granted, free of charge, to any person or organization
obtaining a copy of the software and accompanying documentation covered by
this license (the "Software") to use, reproduce, display, distribute,
execute, and transmit the Software, and to prepare derivative works of the
Software, and to permit third-parties to whom the Software is furnished to
do so, all subject to the following:
The copyright notices in the Software and this entire statement, including
the above license grant, this restriction and the following disclaimer,
must be included in all copies of the Software, in whole or in part, and
all derivative works of the Software, unless such copies or derivative
works are solely in the form of machine-executable object code generated by
a source language processor.
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, TITLE AND NON-INFRINGEMENT. IN NO EVENT
SHALL THE COPYRIGHT HOLDERS OR ANYONE DISTRIBUTING THE SOFTWARE BE LIABLE
FOR ANY DAMAGES OR OTHER LIABILITY, WHETHER IN CONTRACT, TORT OR OTHERWISE,
ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
DEALINGS IN THE SOFTWARE.
*/
#include <string>
#include <vector>
namespace osmium {
namespace io {
/**
* Get a list of all compression types supported for PBF files.
*/
inline std::vector<std::string> supported_pbf_compression_types() {
std::vector<std::string> types{"none", "zlib"};
#ifdef OSMIUM_WITH_LZ4
types.emplace_back("lz4");
#endif
return types;
}
} // namespace io
} // namespace osmium
#endif // OSMIUM_IO_PBF_HPP
| [
"jochen@topf.org"
] | jochen@topf.org |
a0ec60902a3783f0073bf43fe50097475d4e3c56 | f7be1846da14366ca8277dc3edc207766de838f0 | /Codeforces/414/B.cpp | b8f35b988f78cd8930cad0959e151a794acaa681 | [] | no_license | IsThatYou/Competitive-Programming | d440f9e78f8a982cd60aa8c81833b9e10208b29e | a924ac7087654402c7f7c4b62374c377178061ad | refs/heads/master | 2020-07-19T16:31:32.492635 | 2019-01-27T02:45:21 | 2019-01-27T02:45:21 | 73,759,128 | 2 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 348 | cpp | #include <iostream>
#include <cmath>
#include <iomanip>
using namespace std;
int main()
{
double n,h;
cin>>n>>h;
double cur_base = 1;
double new_base;
double cur_height;
double total =0.5 * h;
double each = total/n;
double sum_height = 0;
for (int i =1;i<n;++i)
{
double height= sqrt(i/n);
cout<<setprecision(8)<<height*h<<" ";
}
}
| [
"junlinwang18@gmail.com"
] | junlinwang18@gmail.com |
d420fc36754df961490e88fa17c01ede3b7c9663 | f271c46bb77d70c81354f550b3004976541ba12b | /src/WindowWnd.cpp | 973ecfa37606b34a9696d6321704576188d196e5 | [] | no_license | yearling/YYUI | 4baa2b2f5a7cb0a61120a0404e9ed3afe7c4e73f | 3984776c5878f48851c4e7814789d403a15b1114 | refs/heads/master | 2021-01-10T01:06:10.881411 | 2015-06-10T12:40:34 | 2015-06-10T12:40:34 | 36,545,444 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 11,107 | cpp | //////////////////////////////////////////////////////////////////////////
// Create by yyCom ,2015/4/10
//////////////////////////////////////////////////////////////////////////
#include "YUI.h"
#include "WindowWnd.h"
#include "ControlUI.h"
#include "UIUtility.h"
#include "WindowManager.h"
#include "SystemInfo.h"
namespace YUI
{
WindowWnd::WindowWnd() :
m_hWnd( NULL ),
m_OldWndProc( ::DefWindowProc ),
m_bSubClassed( false )
{
}
void WindowWnd::RegisterWindowClass()
{
WNDCLASS wc;
ZeroMemory(&wc,sizeof(wc));
wc.style = GetClassStyle();
wc.lpfnWndProc =WindowManger::WndProc; //用自己的WndProc
wc.cbClsExtra = 0;
wc.cbWndExtra = 0;
wc.hInstance = SystemInfo::GetInstance()->GetProcessInstance();
wc.hIcon = NULL;
wc.hCursor = ::LoadCursor(NULL, IDC_ARROW);
wc.hbrBackground = NULL;
wc.lpszMenuName = NULL;
wc.lpszClassName = GetWindowClassName();
ATOM ret = ::RegisterClass( &wc );
DWORD err = ::GetLastError();
assert( ret !=0 || err == ERROR_CLASS_ALREADY_EXISTS );
if( ret == 0 && err != ERROR_CLASS_ALREADY_EXISTS)
{
THROW_EXCEPTION(YYUIException()<<UIErrorStr(_T("Call RegisterClassEx Failed! :")+FormatGetLastError(err)));
}
}
void WindowWnd::RegisterSuperClass()
{
//！！目前还不知道有什么用
//功能是如下
// Get the class information from an existing
// window so we can subclass it later on...
//为什么是ControlProc不明白
WNDCLASSEX wc;
ZeroMemory(&wc, sizeof(wc));
wc.cbSize = sizeof(wc);
if( !::GetClassInfoEx( NULL, GetSuperClassName() , &wc) )
{
/* if( !::GetClassInfoEx(PaintManagerUI::GetInstance(),GetSuperClassName(),&wc))
{
THROW_EXCEPTION(YYUIException()<< UIErrorStr(_T("找不到Register Class Name")));
}*/
}
m_OldWndProc = wc.lpfnWndProc;
wc.lpfnWndProc = WindowWnd::ControlProc;
wc.hInstance = SystemInfo::GetInstance()->GetProcessInstance();;
wc.lpszClassName = GetWindowClassName();
ATOM hr = ::RegisterClassEx(&wc);
assert( hr !=0 || hr == ERROR_CLASS_ALREADY_EXISTS );
if( hr == 0 && hr != ERROR_CLASS_ALREADY_EXISTS)
{
THROW_EXCEPTION(YYUIException()<<UIErrorStr(_T("Call RegisterClassEx Failed! :")+FormatGetLastError(hr)));
}
}
HWND WindowWnd::Create(HWND hwndParent, LPCTSTR pstrName, DWORD dwStyle, DWORD dwExStyle, const RECT rc, HMENU hMenu/*= NULL*/)
{
return Create(hwndParent, pstrName, dwStyle, dwExStyle, rc.left, rc.top, rc.right - rc.left, rc.bottom - rc.top, hMenu );
}
HWND WindowWnd::Create(HWND hWndParent, LPCTSTR pstrName, DWORD dwStyple, DWORD dwExStyle, int x /*= CW_USEDEFAULT*/, int y /*= CW_USEDEFAULT*/, int cx /*= CW_USEDEFAULT*/, int cy /*= CW_USEDEFAULT*/, HMENU hMenu /*= NULL*/)
{
try
{
if( GetSuperClassName() != nullptr )
RegisterSuperClass(); //如果SuperClassName存在的话就创建SuperClass
else
RegisterWindowClass();
m_hWnd = CreateWindowEx( dwExStyle, GetWindowClassName(), pstrName, dwStyple, x, y, cx, cy, hWndParent, hMenu, SystemInfo::GetInstance()->GetProcessInstance(),this);
assert( m_hWnd != NULL );
return m_hWnd;
}
catch( ... )
{
throw;
}
}
HWND WindowWnd::CreateUIWindow(HWND hWndParent, LPCTSTR pstrWindowName, DWORD dwStyle /*=0*/, DWORD dwExStyle/*=0*/)
{
return Create(hWndParent,pstrWindowName,dwStyle,dwExStyle,0,0,0,0,NULL);
}
UINT WindowWnd::GetClassStyle() const
{
return 0;
}
void WindowWnd::UnsubClass()
{
assert( ::IsWindow(m_hWnd) );
if( ::IsWindow(m_hWnd) )
return ;
if( !m_bSubClassed )
return ;
SetWindowLongPtr((m_hWnd), GWLP_WNDPROC, (LPARAM)(WNDPROC)(m_OldWndProc));
m_OldWndProc = ::DefWindowProc;
m_bSubClassed = false;
}
HWND WindowWnd::SubClass(HWND hWnd)
{
assert(::IsWindow(hWnd));
assert(m_hWnd == NULL);
//把当前YWindowWnd的WndProc设为hWnd的WndProc,之前的保存;
/* m_OldWndProc = (WNDPROC)SetWindowLongPtr((hWnd), GWLP_WNDPROC, (LPARAM)(WNDPROC)(WindowWnd::WndProc));
if( m_OldWndProc == NULL )
return NULL;
m_bSubClassed = true;
m_hWnd = hWnd;
::SetWindowLongPtr( hWnd, GWLP_USERDATA , reinterpret_cast<LPARAM>(this));*/
return m_hWnd;
}
void WindowWnd::OnFinalMessage(HWND /*hWnd*/)
{
//一般用来清理和PostQuitMessage
}
LRESULT WindowWnd::OnSysMessage(UINT uMsg, WPARAM wParam, LPARAM lParam)
{
return ::CallWindowProc( m_OldWndProc, m_hWnd, uMsg, wParam, lParam);
}
LPCTSTR WindowWnd::GetSuperClassName() const
{
return NULL;
}
LRESULT CALLBACK WindowWnd::ControlProc(HWND hWnd, UINT uMsg, WPARAM wParam, LPARAM lParam)
{
WindowWnd *pWnd = nullptr;
if( uMsg == WM_NCCREATE )
{
LPCREATESTRUCT lpcs = reinterpret_cast<LPCREATESTRUCT>( lParam );
pWnd = static_cast<WindowWnd*>( lpcs->lpCreateParams );
//之前的窗口的附加指针已经被占用，只能用附加Prop
::SetProp( hWnd, _T("YYProperty"), (HANDLE)pWnd );
pWnd->m_hWnd = hWnd;
}
else
{
pWnd = reinterpret_cast<WindowWnd *>(::GetProp(hWnd, _T("YYProperty")));
if( uMsg == WM_NCDESTROY && pWnd != nullptr )
{
LRESULT lRes = ::CallWindowProc( pWnd->m_OldWndProc, hWnd, uMsg, wParam, lParam );
if( pWnd->m_bSubClassed )
pWnd->UnsubClass();
::SetProp( hWnd, _T("YYProperty"), NULL );
pWnd->m_hWnd = NULL;
pWnd->OnFinalMessage( hWnd );
return lRes;
}
}
if( pWnd != nullptr )
return pWnd->OnSysMessage(uMsg, wParam, lParam);
else
return ::DefWindowProc( hWnd, uMsg, wParam, lParam);
}
void WindowWnd::ShowWindow(bool bShow /*= true*/, bool bTakeFocus /*= true*/)
{
assert( ::IsWindow( m_hWnd ) );
if( !::IsWindow( m_hWnd ) )
return;
::ShowWindow(m_hWnd, bShow? ( bTakeFocus ? SW_SHOWNORMAL : SW_SHOWNOACTIVATE ) : SW_HIDE);
}
UINT WindowWnd::ShowModal()
{
assert(::IsWindow(m_hWnd));
UINT nRet = 0;
HWND hWndParent = ::GetWindow(m_hWnd,GW_OWNER);
::ShowWindow(m_hWnd , SW_SHOWNORMAL );
::EnableWindow(hWndParent, FALSE);
MSG msg = { 0 };
while( ::IsWindow( m_hWnd ) && ::GetMessage( &msg, NULL, 0, 0) )
{
if( msg.message == WM_CLOSE && msg.hwnd == m_hWnd )
{
nRet =(UINT) msg.wParam;
::EnableWindow( hWndParent, TRUE ) ;
::SetFocus( hWndParent );
}
//if( !PaintManagerUI::TranslateMessage(& msg ) )
{
::TranslateMessage(&msg);
::DispatchMessage(&msg);
if( msg.message == WM_QUIT )
break;
}
}
::EnableWindow(hWndParent,TRUE);
::SetFocus( hWndParent );
if( msg.message == WM_QUIT)
::PostQuitMessage((int)msg.wParam);
return nRet;
}
void WindowWnd::Close(UINT nRet)
{
assert(::IsWindow(m_hWnd));
if( !::IsWindow( m_hWnd ) )
return ;
PostMessage( WM_CLOSE, (WPARAM)nRet , 0L );
}
LRESULT WindowWnd::SendMessage(UINT uMsg, WPARAM wParam /*= 0*/, LPARAM lParam /*= 0L*/)
{
assert( ::IsWindow( m_hWnd ) );
return ::SendMessage( m_hWnd, uMsg, wParam, lParam);
}
LRESULT WindowWnd::PostMessage(UINT uMsg, WPARAM wParam /*= 0*/, LPARAM lParam /*= 0L*/)
{
assert( ::IsWindow( m_hWnd ) );
return ::PostMessage( m_hWnd, uMsg, wParam, lParam);
}
void WindowWnd::CenterWindow()
{
assert( ::IsWindow( m_hWnd ));
assert( (GetWindowLong( m_hWnd, GWL_STYLE) & WS_CHILD) == 0 );
RECT rcFrame = { 0 };
::GetWindowRect(m_hWnd, &rcFrame);
RECT rcArea = { 0 };
RECT rcCenter = { 0 };
HWND hWnd = *this;
HWND hWndCenter = ::GetWindow(m_hWnd ,GW_OWNER);
if( hWndCenter != NULL )
hWnd = hWndCenter;
// 处理多显示器模式下屏幕居中;
MONITORINFO monInfo;
ZeroMemory( &monInfo, sizeof(monInfo) );
monInfo.cbSize = sizeof(monInfo);
::GetMonitorInfo(::MonitorFromWindow( hWnd, MONITOR_DEFAULTTONEAREST), &monInfo);
rcArea = monInfo.rcWork;
if( hWndCenter == NULL )
rcCenter = rcArea;
else
::GetWindowRect( hWndCenter, &rcCenter );
int width = rcFrame.right - rcFrame.left;
int height = rcFrame.bottom - rcFrame.top;
int xLeft = (rcCenter.left + rcCenter.right - width )/2;
int yTop = (rcCenter.top + rcCenter.bottom - height )/2;
if( xLeft < rcArea.left )
xLeft = rcArea.left;
else if( xLeft + width > rcArea.right )
xLeft = rcArea.right- width;
if( yTop < rcArea.top )
yTop = rcArea.top;
else if( yTop + height > rcArea.bottom )
yTop = rcArea.bottom - height;
::SetWindowPos( m_hWnd , NULL, xLeft, yTop, -1, -1, SWP_NOSIZE | SWP_NOZORDER | SWP_NOACTIVATE );
}
void WindowWnd::SetIcon(UINT nRes)
{
HICON hIcon = (HICON)::LoadImage(SystemInfo::GetInstance()->GetProcessInstance(),
MAKEINTRESOURCE(nRes),
IMAGE_ICON,
(::GetSystemMetrics(SM_CXICON) + 15) & ~15,
(::GetSystemMetrics(SM_CYICON) + 15) & ~15, // 防止高DPI下图标模糊
LR_DEFAULTCOLOR);
assert(hIcon && "create icon failed!");
::SendMessage( m_hWnd, WM_SETICON, (WPARAM)FALSE, (LPARAM)hIcon);
}
WindowWnd::~WindowWnd()
{
}
void WindowWnd::MaxWindow()
{
SendMessage(WM_SYSCOMMAND, SC_MAXIMIZE, 0);
}
void WindowWnd::MinWindow()
{
SendMessage(WM_SYSCOMMAND, SC_MINIMIZE, 0);
}
void WindowWnd::RestoreWindow()
{
SendMessage(WM_SYSCOMMAND, SC_RESTORE, 0);
}
} | [
"yearlingwes@gmail.com"
] | yearlingwes@gmail.com |
6ea7b1ccc120c7d0d2c9a5b0c60071a770279348 | c5459f80ea769a1f35014717ee27cd6a40e48ba9 | /2442.cpp | bc84119febd76ebf8043b74dfd1b1c6fc45efb34 | [] | no_license | Thugday/BOJ | da495ce9d112085ace55ffec0487e01f5eda4f72 | 20530c6a8daf02e9514219798873c557ca535d48 | refs/heads/master | 2022-12-05T10:14:45.029635 | 2020-08-28T08:49:44 | 2020-08-28T08:49:44 | 275,761,787 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 392 | cpp | #include <iostream>
using namespace std;
int main() {
ios_base::sync_with_stdio(false);
cin.tie(nullptr);
int n;
cin >> n;
for (int i = 0; i < n; i++) {
for (int j = 0; j < n - i - 1; j++) { // 공백 부터 출력 해줘서 대칭 만들기
cout << " ";
}
for (int j = 0; j < 2 * i + 1; j++) { // 2*n+1 찍어주기.
cout << "*";
}
cout << "\n";
}
return 0;
} | [
"anais41721@naver.com"
] | anais41721@naver.com |
a3200cd319d46e476978e4d71ab295a8172fb834 | c05d6093baee784526217b3a5443326756494f1e | /Hmwk/Assignment_2/Savitch_9thEd_Chap2_Prob1_DietCoke/main.cpp | 44eaf9d73e01a40ddb46f13c0d99a0b58aff07e0 | [] | no_license | OvAlexander/CSC5 | 5adb6d669298dcfb0cdff12a9081d5113b734bd9 | 632854605c8fed37459a91dabc1ea48f717b91c7 | refs/heads/master | 2020-12-14T11:26:16.426634 | 2020-01-21T06:35:25 | 2020-01-21T06:35:25 | 234,726,641 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,694 | cpp | /*
* File: main.cpp
* Author: Alexander Ov
* Created on January 15, 2020, 11:06 PM
* Purpose: Find the lethal dose of diet coke
*/
//System Libraries
#include <iostream>
#include <iomanip>
using namespace std;
//User Libraries
//Global Constants - No Global Variables
//Only Universal Constants, Math, Physics, Conversions, Higher Dimensions
const float LBS_GRAM_CONVERSION = 453.592; //Conversion variable for lbs to grams
//Function Prototypes
//Execution Begins Here
int main(int argc, char** argv) {
//Set Random Number seed
//Declare Variable Data Types and Constants
const float SODA_SWEET = 1e-3f; //Holds value for how much sweetener is in the soda
const float SODA_MASS = 350; //Holds value for how much mass the soda is
float mMass, mDose, dsrMass; //Holds value for mass of mouse, deadly dose for mouse, and wanted mass
int totalCan; //Holds value for how many cans they can drink
//Initialize Variables
mMass = 35; //Sets mouse mass to 35g
mDose = 5; //Sets mouse dose to 5g
//Process or map Inputs to Outputs
cout << "Program to calculate the limit of Soda Pop Consumption." <<endl; //Title of program
cout << "Input the desired dieters weight in lbs.\n"; //Asks for users desired weight
cin >> dsrMass;
totalCan = dsrMass * LBS_GRAM_CONVERSION * mDose / (mMass * SODA_MASS * SODA_SWEET); //Calculates the amount of cans they can drink
//Display Outputs
cout << "The maximum number of soda pop cans\n" << "which can be consumed is " << totalCan << " cans"; //Displays to user how many cans they can drink
//Exit stage right!
return 0;
} | [
"OvAlexander@users.noreply.github.com"
] | OvAlexander@users.noreply.github.com |
1d05baff92aee17611af37ae0bff0fe9022cc2b6 | 4e96dad823be20b445c95acf7624507bc93e134d | /src/HelloWorld.cpp | 171410df2c0cc44e56f9897795a9f7fd56b8168a | [] | no_license | JamesDelfini/ESP8266-HelloWorld-PlatformIO | f19ccf3709c2a8e666e4b02bed5e4e2511327b10 | c71c16e9490d358fad9912b2b8bf87fc04a8a4be | refs/heads/main | 2023-09-01T01:38:19.527043 | 2021-10-23T09:52:26 | 2021-10-23T09:52:26 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 331 | cpp | #include "HelloWorld.h"
void HelloWorld::begin() {
Serial.println("Waiting..");
delay(2000);
Serial.println("Ready..");
delay(500);
}
void HelloWorld::loop() {
if (m_requestRun) {
m_requestRun = false;
Serial.println("");
Serial.println("Hello World");
}
}
HelloWorld helloWorld; | [
"dj.matildo@gmail.com"
] | dj.matildo@gmail.com |
10f71fabe66e6fd3b25a7abfe008d9f3efef2202 | 506ec7f8495b8120c4a0f5b42f40945161a822b3 | /native/com_dokukino_rados4j_Pool.cpp | b605d82655c6857088d23dc7bed2e835ad70f03b | [] | no_license | ankitcharolia/rados4j | fe462bd15aee2f1ce132e61cc1eba8e332cfba5a | e401a29c98c242fab9319e976aa25130105b69e1 | refs/heads/master | 2020-04-07T15:43:04.331959 | 2010-11-15T07:35:50 | 2010-11-15T07:35:50 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 16,668 | cpp | /*******************************************************************************
*Copyright (c) 2010 Takuya ASADA
*
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, only version 3 of the License.
*
*
* This file is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
* for more details.
*
* You should have received a copy of the GNU General Public License along
* with this program. If not, see <http://www.gnu.org/licenses/>.
*
* Please contact Eucalyptus Systems, Inc., 130 Castilian
* Dr., Goleta, CA 93101 USA or visit <http://www.eucalyptus.com/licenses/>
* if you need additional information or have any questions.
*
* This file may incorporate work covered under the following copyright and
* permission notice:
*
* Software License Agreement (BSD License)
*
* Copyright (c) 2008, Regents of the University of California
* All rights reserved.
*
* Redistribution and use of this software 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.
*
* 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. USERS OF
* THIS SOFTWARE ACKNOWLEDGE THE POSSIBLE PRESENCE OF OTHER OPEN SOURCE
* LICENSED MATERIAL, COPYRIGHTED MATERIAL OR PATENTED MATERIAL IN THIS
* SOFTWARE, AND IF ANY SUCH MATERIAL IS DISCOVERED THE PARTY DISCOVERING
* IT MAY INFORM DR. RICH WOLSKI AT THE UNIVERSITY OF CALIFORNIA, SANTA
* BARBARA WHO WILL THEN ASCERTAIN THE MOST APPROPRIATE REMEDY, WHICH IN
* THE REGENTS’ DISCRETION MAY INCLUDE, WITHOUT LIMITATION, REPLACEMENT
* OF THE CODE SO IDENTIFIED, LICENSING OF THE CODE SO IDENTIFIED, OR
* WITHDRAWAL OF THE CODE CAPABILITY TO THE EXTENT NEEDED TO COMPLY WITH
* ANY SUCH LICENSES OR RIGHTS.
*******************************************************************************/
#include "com_dokukino_rados4j_Pool.h"
#include <rados/librados.hpp>
#include <iostream>
jclass pool_class = NULL, stat_class = NULL;
jfieldID pool_instance_ptr = NULL, pool_rados_ptr = NULL, stat_psize = NULL, stat_pmtime = NULL;
jmethodID pool_constructor = NULL, stat_constructor = NULL;
extern jclass list_ctx_class;
extern jmethodID list_ctx_constructor;
extern jfieldID list_ctx_instance_ptr, list_ctx_rados_ptr;
int
pool_field_initialize(JNIEnv *env)
{
jclass clsj = env->FindClass("Lcom/dokukino/rados4j/Pool;");
if (!clsj)
return -1;
pool_class = reinterpret_cast<jclass>(env->NewGlobalRef(clsj));
env->DeleteLocalRef(clsj);
pool_constructor = env->GetMethodID(pool_class, "<init>", "()V");
if (!pool_constructor)
return -1;
pool_instance_ptr = env->GetFieldID(pool_class, "instancePtr", "J");
if (!pool_instance_ptr)
return -1;
pool_rados_ptr = env->GetFieldID(pool_class, "radosPtr", "J");
if (!pool_rados_ptr)
return -1;
return 0;
}
int
stat_field_initialize(JNIEnv *env)
{
jclass clsj = env->FindClass("Lcom/dokukino/rados4j/Stat;");
if (!clsj)
return -1;
stat_class = reinterpret_cast<jclass>(env->NewGlobalRef(clsj));
env->DeleteLocalRef(clsj);
stat_constructor = env->GetMethodID(stat_class, "<init>", "()V");
if (!stat_constructor)
return -1;
stat_psize = env->GetFieldID(stat_class, "psize", "J");
if (!stat_psize)
return -1;
stat_pmtime = env->GetFieldID(stat_class, "pmtime", "J");
if (!stat_pmtime)
return -1;
return 0;
}
static inline void
pool_set_instance_ptr(JNIEnv *env, jobject obj, librados::pool_t pool)
{
env->SetLongField(obj, pool_instance_ptr, reinterpret_cast<jlong>(pool));
}
static inline void
pool_set_rados_ptr(JNIEnv *env, jobject obj, librados::Rados *rados)
{
env->SetLongField(obj, pool_rados_ptr, reinterpret_cast<jlong>(rados));
}
static inline librados::pool_t
pool_get_instance_ptr(JNIEnv *env, jobject obj)
{
jlong ptr = env->GetLongField(obj, pool_instance_ptr);
return reinterpret_cast<librados::pool_t>(ptr);
}
static inline librados::Rados *
pool_get_rados_ptr(JNIEnv *env, jobject obj)
{
jlong ptr = env->GetLongField(obj, pool_rados_ptr);
return reinterpret_cast<librados::Rados *>(ptr);
}
static inline jobject
pool_new_instance(JNIEnv *env)
{
return env->NewObject(pool_class, pool_constructor);
}
static inline jobject
stat_new_instance(JNIEnv *env)
{
return env->NewObject(stat_class, stat_constructor);
}
static inline void
stat_set_psize(JNIEnv *env, jobject obj, uint64_t psize)
{
env->SetLongField(obj, stat_psize, static_cast<jlong>(psize));
}
static inline void
stat_set_pmtime(JNIEnv *env, jobject obj, time_t pmtime)
{
env->SetLongField(obj, stat_pmtime, static_cast<jlong>(pmtime));
}
static inline jobject
list_ctx_new_instance(JNIEnv *env)
{
return env->NewObject(list_ctx_class, list_ctx_constructor);
}
static inline void
list_ctx_set_instance_ptr(JNIEnv *env, jobject obj, librados::Rados::ListCtx *ctx)
{
env->SetLongField(obj, list_ctx_instance_ptr, reinterpret_cast<jlong>(ctx));
}
static inline void
list_ctx_set_rados_ptr(JNIEnv *env, jobject obj, librados::Rados *rados)
{
env->SetLongField(obj, list_ctx_rados_ptr, reinterpret_cast<jlong>(rados));
}
extern "C"
{
/*
* Class: com_dokukino_rados4j_Pool
* Method: delete
* Signature: ()I
*/
JNIEXPORT jint JNICALL Java_com_dokukino_rados4j_Pool_delete
(JNIEnv *env, jobject obj)
{
librados::Rados *rados;
librados::pool_t pool_ptr;
rados = pool_get_rados_ptr(env, obj);
if (!rados)
return -1;
pool_ptr = pool_get_instance_ptr(env, obj);
if (!pool_ptr)
return -1;
return rados->delete_pool(pool_ptr);
}
/*
* Class: com_dokukino_rados4j_Pool
* Method: close
* Signature: ()V
*/
JNIEXPORT void JNICALL Java_com_dokukino_rados4j_Pool_close
(JNIEnv *env, jobject obj)
{
librados::Rados *rados;
librados::pool_t pool_ptr;
rados = pool_get_rados_ptr(env, obj);
if (!rados)
return;
pool_ptr = pool_get_instance_ptr(env, obj);
if (!pool_ptr)
return;
rados->close_pool(pool_ptr);
pool_set_instance_ptr(env, obj, NULL);
}
/*
* Class: com_dokukino_rados4j_Pool
* Method: createObj
* Signature: (Ljava/lang/String;Z)I
*/
JNIEXPORT jint JNICALL Java_com_dokukino_rados4j_Pool_createObj
(JNIEnv *env, jobject obj, jstring oid, jboolean exclusive)
{
librados::Rados *rados;
librados::pool_t pool_ptr;
const char *oid_char;
jint ret;
if (!oid)
return -1;
rados = pool_get_rados_ptr(env, obj);
if (!rados)
return -1;
pool_ptr = pool_get_instance_ptr(env, obj);
if (!pool_ptr)
return -1;
oid_char = env->GetStringUTFChars(oid, NULL);
if (!oid_char)
return -1;
ret = rados->create(pool_ptr, oid_char, exclusive);
env->ReleaseStringUTFChars(oid, oid_char);
return ret;
}
/*
* Class: com_dokukino_rados4j_Pool
* Method: writeObj
* Signature: (Ljava/lang/String;J[BJ)I
*/
JNIEXPORT jint JNICALL Java_com_dokukino_rados4j_Pool_writeObj
(JNIEnv *env, jobject obj, jstring oid, jlong off, jbyteArray buf, jlong len)
{
librados::Rados *rados;
librados::pool_t pool_ptr;
librados::bufferlist bl;
const char *oid_char;
jbyte* src;
jint ret;
if (!oid || !buf)
return -1;
rados = pool_get_rados_ptr(env, obj);
if (!rados)
return -1;
pool_ptr = pool_get_instance_ptr(env, obj);
if (!pool_ptr)
return -1;
oid_char = env->GetStringUTFChars(oid, NULL);
if (!oid_char)
return -1;
src = env->GetByteArrayElements(buf, NULL);
bl.append(reinterpret_cast<char *>(src), len);
ret = rados->write(pool_ptr, oid_char, off, bl, len);
env->ReleaseByteArrayElements(buf, src, 0);
env->ReleaseStringUTFChars(oid, oid_char);
return ret;
}
/*
* Class: com_dokukino_rados4j_Pool
* Method: readObj
* Signature: (Ljava/lang/String;J[BJ)I
*/
JNIEXPORT jint JNICALL Java_com_dokukino_rados4j_Pool_readObj
(JNIEnv *env, jobject obj, jstring oid, jlong off, jbyteArray buf, jlong len)
{
librados::Rados *rados;
librados::pool_t pool_ptr;
librados::bufferlist bl;
const char *oid_char;
jint ret;
if (!oid || !buf)
return -1;
rados = pool_get_rados_ptr(env, obj);
if (!rados)
return -1;
pool_ptr = pool_get_instance_ptr(env, obj);
if (!pool_ptr)
return -1;
oid_char = env->GetStringUTFChars(oid, NULL);
if (!oid_char)
return -1;
ret = rados->read(pool_ptr, oid_char, off, bl, len);
if (ret > 0)
env->SetByteArrayRegion(buf, 0, ret, reinterpret_cast<jbyte*>(bl.c_str()));
env->ReleaseStringUTFChars(oid, oid_char);
return ret;
}
/*
* Class: com_dokukino_rados4j_Pool
* Method: renameObj
* Signature: (Ljava/lang/String;Ljava/lang/String;)I
*/
JNIEXPORT jint JNICALL Java_com_dokukino_rados4j_Pool_renameObj
(JNIEnv *env, jobject obj, jstring old_oid, jstring new_oid)
{
librados::Rados *rados;
librados::pool_t pool_ptr;
librados::bufferlist bl;
const char *old_oid_char, *new_oid_char;
jint ret;
if (!old_oid || !new_oid)
return -1;
rados = pool_get_rados_ptr(env, obj);
if (!rados)
return -1;
pool_ptr = pool_get_instance_ptr(env, obj);
if (!pool_ptr)
return -1;
old_oid_char = env->GetStringUTFChars(old_oid, NULL);
if (!old_oid_char)
return -1;
new_oid_char = env->GetStringUTFChars(new_oid, NULL);
if (!new_oid_char)
{
env->ReleaseStringUTFChars(old_oid, old_oid_char);
return -1;
}
ret = rados->read(pool_ptr, old_oid_char, 0, bl, 0);
if (ret < 0)
goto err;
ret = rados->write_full(pool_ptr, new_oid_char, bl);
if (ret < 0)
goto err;
rados->remove(pool_ptr, old_oid_char);
err:
env->ReleaseStringUTFChars(old_oid, old_oid_char);
env->ReleaseStringUTFChars(new_oid, new_oid_char);
return ret;
}
/*
* Class: com_dokukino_rados4j_Pool
* Method: copyObj
* Signature: (Ljava/lang/String;Lcom/dokukino/rados4j/Pool;Ljava/lang/String;)I
*/
JNIEXPORT jint JNICALL Java_com_dokukino_rados4j_Pool_copyObj
(JNIEnv *env, jobject obj, jstring src_oid, jobject dest_pool, jstring dest_oid)
{
librados::Rados *rados;
librados::pool_t src_pool_ptr, dest_pool_ptr;
librados::bufferlist bl;
const char *src_oid_char, *dest_oid_char;
jint ret;
if (!src_oid || !dest_pool || !dest_oid)
return -1;
rados = pool_get_rados_ptr(env, obj);
if (!rados)
return -1;
src_pool_ptr = pool_get_instance_ptr(env, obj);
if (!src_pool_ptr)
return -1;
dest_pool_ptr = pool_get_instance_ptr(env, dest_pool);
if (!dest_pool_ptr)
return -1;
src_oid_char = env->GetStringUTFChars(src_oid, NULL);
if (!src_oid_char)
return -1;
dest_oid_char = env->GetStringUTFChars(dest_oid, NULL);
if (!dest_oid_char)
{
env->ReleaseStringUTFChars(src_oid, src_oid_char);
return -1;
}
ret = rados->read(src_pool_ptr, src_oid_char, 0, bl, 0);
if (ret < 0)
goto err;
ret = rados->write_full(dest_pool_ptr, dest_oid_char, bl);
if (ret < 0)
goto err;
err:
env->ReleaseStringUTFChars(src_oid, src_oid_char);
env->ReleaseStringUTFChars(dest_oid, dest_oid_char);
return ret;
}
/*
* Class: com_dokukino_rados4j_Pool
* Method: removeObj
* Signature: (Ljava/lang/String;)I
*/
JNIEXPORT jint JNICALL Java_com_dokukino_rados4j_Pool_removeObj
(JNIEnv *env, jobject obj, jstring oid)
{
librados::Rados *rados;
librados::pool_t pool_ptr;
const char *oid_char;
jint ret;
if (!oid)
return -1;
rados = pool_get_rados_ptr(env, obj);
if (!rados)
return -1;
pool_ptr = pool_get_instance_ptr(env, obj);
if (!pool_ptr)
return -1;
oid_char = env->GetStringUTFChars(oid, NULL);
if (!oid_char)
return -1;
ret = rados->remove(pool_ptr, oid_char);
env->ReleaseStringUTFChars(oid, oid_char);
return ret;
}
/*
* Class: com_dokukino_rados4j_Pool
* Method: statObj
* Signature: (Ljava/lang/String;)Lcom/dokukino/rados4j/Stat;
*/
JNIEXPORT jobject JNICALL Java_com_dokukino_rados4j_Pool_statObj
(JNIEnv *env, jobject obj, jstring oid)
{
librados::Rados *rados;
librados::pool_t pool_ptr;
const char *oid_char;
uint64_t psize;
time_t pmtime;
jint ret;
if (!oid)
return NULL;
rados = pool_get_rados_ptr(env, obj);
if (!rados)
return NULL;
pool_ptr = pool_get_instance_ptr(env, obj);
if (!pool_ptr)
return NULL;
oid_char = env->GetStringUTFChars(oid, NULL);
if (!oid_char)
return NULL;
ret = rados->stat(pool_ptr, oid_char, &psize, &pmtime);
env->ReleaseStringUTFChars(oid, oid_char);
if (ret < 0)
return NULL;
else
{
jobject obj = stat_new_instance(env);
if (!obj)
return NULL;
stat_set_psize(env, obj, psize);
stat_set_pmtime(env, obj, pmtime);
return obj;
}
}
/*
* Class: com_dokukino_rados4j_Pool
* Method: openList
* Signature: ()Lcom/dokukino/rados4j/ListCtx;
*/
JNIEXPORT jobject JNICALL Java_com_dokukino_rados4j_Pool_openList
(JNIEnv *env, jobject obj)
{
librados::Rados *rados;
librados::pool_t pool_ptr;
librados::Rados::ListCtx *ctx = NULL;
jint ret;
rados = pool_get_rados_ptr(env, obj);
if (!rados)
return NULL;
pool_ptr = pool_get_instance_ptr(env, obj);
if (!pool_ptr)
return NULL;
ctx = new librados::Rados::ListCtx();
ret = rados->list_objects_open(pool_ptr, ctx);
if (ret < 0)
{
delete ctx;
return NULL;
}
else
{
jobject obj = list_ctx_new_instance(env);
if (!obj)
return NULL;
list_ctx_set_instance_ptr(env, obj, ctx);
list_ctx_set_rados_ptr(env, obj, rados);
return obj;
}
}
}
| [
"syuu@dokukino.com"
] | syuu@dokukino.com |
bf7dcca59fde2c1fdd4b94ec2b0447124326a07e | e6a7743bcee28fbc39e495c4fdf005f1a2ff446f | /export/windows/cpp/obj/src/flixel/tile/FlxBaseTilemap.cpp | a1fe9d21ba85541002f2bd474d2fbafbb22de3cf | [] | no_license | jwat445/DungeonCrawler | 56fd0b91d44793802e87097eb52d740709a10ffa | 5f60dbe509ec73dc9aa0cf8f38cf53ba486fdad2 | refs/heads/master | 2020-04-05T13:08:31.562552 | 2017-12-07T02:42:41 | 2017-12-07T02:42:41 | 95,114,406 | 0 | 0 | null | 2017-12-07T03:20:53 | 2017-06-22T12:41:59 | C++ | UTF-8 | C++ | false | true | 89,729 | cpp | // Generated by Haxe 3.4.2 (git build master @ 890f8c7)
#include <hxcpp.h>
#ifndef INCLUDED_EReg
#include <EReg.h>
#endif
#ifndef INCLUDED_Std
#include <Std.h>
#endif
#ifndef INCLUDED_StringTools
#include <StringTools.h>
#endif
#ifndef INCLUDED_flixel_FlxBasic
#include <flixel/FlxBasic.h>
#endif
#ifndef INCLUDED_flixel_FlxCamera
#include <flixel/FlxCamera.h>
#endif
#ifndef INCLUDED_flixel_FlxG
#include <flixel/FlxG.h>
#endif
#ifndef INCLUDED_flixel_FlxObject
#include <flixel/FlxObject.h>
#endif
#ifndef INCLUDED_flixel_group_FlxTypedGroup
#include <flixel/group/FlxTypedGroup.h>
#endif
#ifndef INCLUDED_flixel_math_FlxPoint
#include <flixel/math/FlxPoint.h>
#endif
#ifndef INCLUDED_flixel_math_FlxRandom
#include <flixel/math/FlxRandom.h>
#endif
#ifndef INCLUDED_flixel_math_FlxRect
#include <flixel/math/FlxRect.h>
#endif
#ifndef INCLUDED_flixel_system_FlxAssets
#include <flixel/system/FlxAssets.h>
#endif
#ifndef INCLUDED_flixel_tile_FlxBaseTilemap
#include <flixel/tile/FlxBaseTilemap.h>
#endif
#ifndef INCLUDED_flixel_tile_FlxTilemapAutoTiling
#include <flixel/tile/FlxTilemapAutoTiling.h>
#endif
#ifndef INCLUDED_flixel_util_FlxArrayUtil
#include <flixel/util/FlxArrayUtil.h>
#endif
#ifndef INCLUDED_flixel_util_FlxPool_flixel_math_FlxRect
#include <flixel/util/FlxPool_flixel_math_FlxRect.h>
#endif
#ifndef INCLUDED_flixel_util_FlxStringUtil
#include <flixel/util/FlxStringUtil.h>
#endif
#ifndef INCLUDED_flixel_util_IFlxDestroyable
#include <flixel/util/IFlxDestroyable.h>
#endif
#ifndef INCLUDED_flixel_util_IFlxPool
#include <flixel/util/IFlxPool.h>
#endif
#ifndef INCLUDED_flixel_util_IFlxPooled
#include <flixel/util/IFlxPooled.h>
#endif
#ifndef INCLUDED_openfl__legacy_AssetType
#include <openfl/_legacy/AssetType.h>
#endif
#ifndef INCLUDED_openfl__legacy_Assets
#include <openfl/_legacy/Assets.h>
#endif
#ifndef INCLUDED_openfl__legacy_display_BitmapData
#include <openfl/_legacy/display/BitmapData.h>
#endif
#ifndef INCLUDED_openfl__legacy_display_IBitmapDrawable
#include <openfl/_legacy/display/IBitmapDrawable.h>
#endif
HX_DEFINE_STACK_FRAME(_hx_pos_36d94048d9e4941f_17_new,"flixel.tile.FlxBaseTilemap","new",0x601e788b,"flixel.tile.FlxBaseTilemap.new","flixel/tile/FlxBaseTilemap.hx",17,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_88_updateTile,"flixel.tile.FlxBaseTilemap","updateTile",0x4985390c,"flixel.tile.FlxBaseTilemap.updateTile","flixel/tile/FlxBaseTilemap.hx",88,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_93_cacheGraphics,"flixel.tile.FlxBaseTilemap","cacheGraphics",0x589e0d18,"flixel.tile.FlxBaseTilemap.cacheGraphics","flixel/tile/FlxBaseTilemap.hx",93,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_98_initTileObjects,"flixel.tile.FlxBaseTilemap","initTileObjects",0x1ec17ac1,"flixel.tile.FlxBaseTilemap.initTileObjects","flixel/tile/FlxBaseTilemap.hx",98,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_103_updateMap,"flixel.tile.FlxBaseTilemap","updateMap",0xe833827e,"flixel.tile.FlxBaseTilemap.updateMap","flixel/tile/FlxBaseTilemap.hx",103,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_108_computeDimensions,"flixel.tile.FlxBaseTilemap","computeDimensions",0xc850220f,"flixel.tile.FlxBaseTilemap.computeDimensions","flixel/tile/FlxBaseTilemap.hx",108,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_113_getTileIndexByCoords,"flixel.tile.FlxBaseTilemap","getTileIndexByCoords",0x5f0cf078,"flixel.tile.FlxBaseTilemap.getTileIndexByCoords","flixel/tile/FlxBaseTilemap.hx",113,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_119_getTileCoordsByIndex,"flixel.tile.FlxBaseTilemap","getTileCoordsByIndex",0x89a6db2e,"flixel.tile.FlxBaseTilemap.getTileCoordsByIndex","flixel/tile/FlxBaseTilemap.hx",119,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_125_ray,"flixel.tile.FlxBaseTilemap","ray",0x60217e15,"flixel.tile.FlxBaseTilemap.ray","flixel/tile/FlxBaseTilemap.hx",125,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_131_overlapsWithCallback,"flixel.tile.FlxBaseTilemap","overlapsWithCallback",0x90f43a8c,"flixel.tile.FlxBaseTilemap.overlapsWithCallback","flixel/tile/FlxBaseTilemap.hx",131,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_137_setDirty,"flixel.tile.FlxBaseTilemap","setDirty",0x31f19505,"flixel.tile.FlxBaseTilemap.setDirty","flixel/tile/FlxBaseTilemap.hx",137,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_150_destroy,"flixel.tile.FlxBaseTilemap","destroy",0x44ffc6a5,"flixel.tile.FlxBaseTilemap.destroy","flixel/tile/FlxBaseTilemap.hx",150,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_188_loadMapFromCSV,"flixel.tile.FlxBaseTilemap","loadMapFromCSV",0xbac5ecbb,"flixel.tile.FlxBaseTilemap.loadMapFromCSV","flixel/tile/FlxBaseTilemap.hx",188,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_175_loadMapFromCSV,"flixel.tile.FlxBaseTilemap","loadMapFromCSV",0xbac5ecbb,"flixel.tile.FlxBaseTilemap.loadMapFromCSV","flixel/tile/FlxBaseTilemap.hx",175,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_258_loadMapFromArray,"flixel.tile.FlxBaseTilemap","loadMapFromArray",0x576cd9ce,"flixel.tile.FlxBaseTilemap.loadMapFromArray","flixel/tile/FlxBaseTilemap.hx",258,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_287_loadMapFrom2DArray,"flixel.tile.FlxBaseTilemap","loadMapFrom2DArray",0xb01a13fc,"flixel.tile.FlxBaseTilemap.loadMapFrom2DArray","flixel/tile/FlxBaseTilemap.hx",287,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_321_loadMapFromGraphic,"flixel.tile.FlxBaseTilemap","loadMapFromGraphic",0xe93ffe1d,"flixel.tile.FlxBaseTilemap.loadMapFromGraphic","flixel/tile/FlxBaseTilemap.hx",321,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_329_loadMapHelper,"flixel.tile.FlxBaseTilemap","loadMapHelper",0xc59c560f,"flixel.tile.FlxBaseTilemap.loadMapHelper","flixel/tile/FlxBaseTilemap.hx",329,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_352_postGraphicLoad,"flixel.tile.FlxBaseTilemap","postGraphicLoad",0x0dc00119,"flixel.tile.FlxBaseTilemap.postGraphicLoad","flixel/tile/FlxBaseTilemap.hx",352,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_361_applyAutoTile,"flixel.tile.FlxBaseTilemap","applyAutoTile",0xcc60c5b6,"flixel.tile.FlxBaseTilemap.applyAutoTile","flixel/tile/FlxBaseTilemap.hx",361,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_372_applyCustomRemap,"flixel.tile.FlxBaseTilemap","applyCustomRemap",0x2fd5c57f,"flixel.tile.FlxBaseTilemap.applyCustomRemap","flixel/tile/FlxBaseTilemap.hx",372,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_392_randomizeIndices,"flixel.tile.FlxBaseTilemap","randomizeIndices",0x9015e6eb,"flixel.tile.FlxBaseTilemap.randomizeIndices","flixel/tile/FlxBaseTilemap.hx",392,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_399_randomizeIndices,"flixel.tile.FlxBaseTilemap","randomizeIndices",0x9015e6eb,"flixel.tile.FlxBaseTilemap.randomizeIndices","flixel/tile/FlxBaseTilemap.hx",399,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_428_autoTile,"flixel.tile.FlxBaseTilemap","autoTile",0x7a0f9632,"flixel.tile.FlxBaseTilemap.autoTile","flixel/tile/FlxBaseTilemap.hx",428,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_495_setCustomTileMappings,"flixel.tile.FlxBaseTilemap","setCustomTileMappings",0x91d80f71,"flixel.tile.FlxBaseTilemap.setCustomTileMappings","flixel/tile/FlxBaseTilemap.hx",495,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_517_getTile,"flixel.tile.FlxBaseTilemap","getTile",0x3ff9148f,"flixel.tile.FlxBaseTilemap.getTile","flixel/tile/FlxBaseTilemap.hx",517,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_528_getTileByIndex,"flixel.tile.FlxBaseTilemap","getTileByIndex",0xf0387cec,"flixel.tile.FlxBaseTilemap.getTileByIndex","flixel/tile/FlxBaseTilemap.hx",528,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_539_getTileCollisions,"flixel.tile.FlxBaseTilemap","getTileCollisions",0x9ca1bd30,"flixel.tile.FlxBaseTilemap.getTileCollisions","flixel/tile/FlxBaseTilemap.hx",539,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_549_getTileInstances,"flixel.tile.FlxBaseTilemap","getTileInstances",0xa0cac4af,"flixel.tile.FlxBaseTilemap.getTileInstances","flixel/tile/FlxBaseTilemap.hx",549,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_580_setTile,"flixel.tile.FlxBaseTilemap","setTile",0x32faa59b,"flixel.tile.FlxBaseTilemap.setTile","flixel/tile/FlxBaseTilemap.hx",580,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_598_setTileByIndex,"flixel.tile.FlxBaseTilemap","setTileByIndex",0x10586560,"flixel.tile.FlxBaseTilemap.setTileByIndex","flixel/tile/FlxBaseTilemap.hx",598,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_658_setTileProperties,"flixel.tile.FlxBaseTilemap","setTileProperties",0x2905d56e,"flixel.tile.FlxBaseTilemap.setTileProperties","flixel/tile/FlxBaseTilemap.hx",658,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_691_getData,"flixel.tile.FlxBaseTilemap","getData",0x355f9f8b,"flixel.tile.FlxBaseTilemap.getData","flixel/tile/FlxBaseTilemap.hx",691,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_723_findPath,"flixel.tile.FlxBaseTilemap","findPath",0xe6d2ce73,"flixel.tile.FlxBaseTilemap.findPath","flixel/tile/FlxBaseTilemap.hx",723,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_791_computePathDistance,"flixel.tile.FlxBaseTilemap","computePathDistance",0x34e53a3c,"flixel.tile.FlxBaseTilemap.computePathDistance","flixel/tile/FlxBaseTilemap.hx",791,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_986_walkPath,"flixel.tile.FlxBaseTilemap","walkPath",0xa1980343,"flixel.tile.FlxBaseTilemap.walkPath","flixel/tile/FlxBaseTilemap.hx",986,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_1085_simplifyPath,"flixel.tile.FlxBaseTilemap","simplifyPath",0xe8519bc3,"flixel.tile.FlxBaseTilemap.simplifyPath","flixel/tile/FlxBaseTilemap.hx",1085,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_1118_raySimplifyPath,"flixel.tile.FlxBaseTilemap","raySimplifyPath",0x32723703,"flixel.tile.FlxBaseTilemap.raySimplifyPath","flixel/tile/FlxBaseTilemap.hx",1118,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_1162_overlaps,"flixel.tile.FlxBaseTilemap","overlaps",0x8f17af01,"flixel.tile.FlxBaseTilemap.overlaps","flixel/tile/FlxBaseTilemap.hx",1162,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_1177_tilemapOverlapsCallback,"flixel.tile.FlxBaseTilemap","tilemapOverlapsCallback",0x40d17cea,"flixel.tile.FlxBaseTilemap.tilemapOverlapsCallback","flixel/tile/FlxBaseTilemap.hx",1177,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_1201_overlapsAt,"flixel.tile.FlxBaseTilemap","overlapsAt",0x47a26a54,"flixel.tile.FlxBaseTilemap.overlapsAt","flixel/tile/FlxBaseTilemap.hx",1201,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_1217_tilemapOverlapsAtCallback,"flixel.tile.FlxBaseTilemap","tilemapOverlapsAtCallback",0xbef90c3d,"flixel.tile.FlxBaseTilemap.tilemapOverlapsAtCallback","flixel/tile/FlxBaseTilemap.hx",1217,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_1236_overlapsPoint,"flixel.tile.FlxBaseTilemap","overlapsPoint",0x91c6718f,"flixel.tile.FlxBaseTilemap.overlapsPoint","flixel/tile/FlxBaseTilemap.hx",1236,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_1249_tileAtPointAllowsCollisions,"flixel.tile.FlxBaseTilemap","tileAtPointAllowsCollisions",0x26e8ec45,"flixel.tile.FlxBaseTilemap.tileAtPointAllowsCollisions","flixel/tile/FlxBaseTilemap.hx",1249,0x0139d8e5)
HX_LOCAL_STACK_FRAME(_hx_pos_36d94048d9e4941f_1263_getBounds,"flixel.tile.FlxBaseTilemap","getBounds",0x47c7aa16,"flixel.tile.FlxBaseTilemap.getBounds","flixel/tile/FlxBaseTilemap.hx",1263,0x0139d8e5)
namespace flixel{
namespace tile{
void FlxBaseTilemap_obj::__construct(){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_17_new)
HXLINE( 81) this->_collideIndex = (int)0;
HXLINE( 80) this->_drawIndex = (int)0;
HXLINE( 74) this->_startingIndex = (int)0;
HXLINE( 69) this->_tileObjects = ::cpp::VirtualArray_obj::__new(0);
HXLINE( 28) this->totalTiles = (int)0;
HXLINE( 26) this->heightInTiles = (int)0;
HXLINE( 24) this->widthInTiles = (int)0;
HXLINE( 22) this->_hx_auto = ::flixel::tile::FlxTilemapAutoTiling_obj::OFF_dyn();
HXLINE( 142) super::__construct(null(),null(),null(),null());
HXLINE( 144) this->flixelType = (int)3;
HXLINE( 145) this->set_immovable(true);
HXLINE( 146) this->set_moves(false);
}
Dynamic FlxBaseTilemap_obj::__CreateEmpty() { return new FlxBaseTilemap_obj; }
void *FlxBaseTilemap_obj::_hx_vtable = 0;
Dynamic FlxBaseTilemap_obj::__Create(hx::DynamicArray inArgs)
{
hx::ObjectPtr< FlxBaseTilemap_obj > _hx_result = new FlxBaseTilemap_obj();
_hx_result->__construct();
return _hx_result;
}
bool FlxBaseTilemap_obj::_hx_isInstanceOf(int inClassId) {
if (inClassId<=(int)0x2e105115) {
if (inClassId<=(int)0x25a685e0) {
return inClassId==(int)0x00000001 || inClassId==(int)0x25a685e0;
} else {
return inClassId==(int)0x2e105115;
}
} else {
return inClassId==(int)0x725f80f5;
}
}
void FlxBaseTilemap_obj::updateTile(int Index){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_88_updateTile)
HXDLIN( 88) HX_STACK_DO_THROW(HX_("updateTile must be implemented",53,76,b0,30));
}
HX_DEFINE_DYNAMIC_FUNC1(FlxBaseTilemap_obj,updateTile,(void))
void FlxBaseTilemap_obj::cacheGraphics(int TileWidth,int TileHeight, ::Dynamic TileGraphic){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_93_cacheGraphics)
HXDLIN( 93) HX_STACK_DO_THROW(HX_("cacheGraphics must be implemented",a9,10,20,38));
}
HX_DEFINE_DYNAMIC_FUNC3(FlxBaseTilemap_obj,cacheGraphics,(void))
void FlxBaseTilemap_obj::initTileObjects(){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_98_initTileObjects)
HXDLIN( 98) HX_STACK_DO_THROW(HX_("initTileObjects must be implemented",12,b8,a6,2f));
}
HX_DEFINE_DYNAMIC_FUNC0(FlxBaseTilemap_obj,initTileObjects,(void))
void FlxBaseTilemap_obj::updateMap(){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_103_updateMap)
HXDLIN( 103) HX_STACK_DO_THROW(HX_("updateMap must be implemented",8f,ae,0f,b7));
}
HX_DEFINE_DYNAMIC_FUNC0(FlxBaseTilemap_obj,updateMap,(void))
void FlxBaseTilemap_obj::computeDimensions(){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_108_computeDimensions)
HXDLIN( 108) HX_STACK_DO_THROW(HX_("computeDimensions must be implemented",a0,79,f6,10));
}
HX_DEFINE_DYNAMIC_FUNC0(FlxBaseTilemap_obj,computeDimensions,(void))
int FlxBaseTilemap_obj::getTileIndexByCoords( ::flixel::math::FlxPoint Coord){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_113_getTileIndexByCoords)
HXDLIN( 113) HX_STACK_DO_THROW(HX_("getTileIndexByCoords must be implemented",7f,57,93,9c));
HXDLIN( 113) return (int)0;
}
HX_DEFINE_DYNAMIC_FUNC1(FlxBaseTilemap_obj,getTileIndexByCoords,return )
::flixel::math::FlxPoint FlxBaseTilemap_obj::getTileCoordsByIndex(int Index,hx::Null< bool > __o_Midpoint){
bool Midpoint = __o_Midpoint.Default(true);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_119_getTileCoordsByIndex)
HXDLIN( 119) HX_STACK_DO_THROW(HX_("getTileCoordsByIndex must be implemented",35,21,39,05));
HXDLIN( 119) return null();
}
HX_DEFINE_DYNAMIC_FUNC2(FlxBaseTilemap_obj,getTileCoordsByIndex,return )
bool FlxBaseTilemap_obj::ray( ::flixel::math::FlxPoint Start, ::flixel::math::FlxPoint End, ::flixel::math::FlxPoint Result,hx::Null< Float > __o_Resolution){
Float Resolution = __o_Resolution.Default(1);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_125_ray)
HXDLIN( 125) HX_STACK_DO_THROW(HX_("ray must be implemented",e6,31,5e,58));
HXDLIN( 125) return false;
}
HX_DEFINE_DYNAMIC_FUNC4(FlxBaseTilemap_obj,ray,return )
bool FlxBaseTilemap_obj::overlapsWithCallback( ::flixel::FlxObject Object, ::Dynamic Callback,hx::Null< bool > __o_FlipCallbackParams, ::flixel::math::FlxPoint Position){
bool FlipCallbackParams = __o_FlipCallbackParams.Default(false);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_131_overlapsWithCallback)
HXDLIN( 131) HX_STACK_DO_THROW(HX_("overlapsWithCallback must be implemented",93,a3,ff,38));
HXDLIN( 131) return false;
}
HX_DEFINE_DYNAMIC_FUNC4(FlxBaseTilemap_obj,overlapsWithCallback,return )
void FlxBaseTilemap_obj::setDirty(hx::Null< bool > __o_Dirty){
bool Dirty = __o_Dirty.Default(true);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_137_setDirty)
HXDLIN( 137) HX_STACK_DO_THROW(HX_("setDirty must be implemented",0c,cc,e0,5f));
}
HX_DEFINE_DYNAMIC_FUNC1(FlxBaseTilemap_obj,setDirty,(void))
void FlxBaseTilemap_obj::destroy(){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_150_destroy)
HXLINE( 151) this->_data = null();
HXLINE( 152) this->super::destroy();
}
::flixel::tile::FlxBaseTilemap FlxBaseTilemap_obj::loadMapFromCSV(::String MapData, ::Dynamic TileGraphic,hx::Null< int > __o_TileWidth,hx::Null< int > __o_TileHeight, ::flixel::tile::FlxTilemapAutoTiling AutoTile,hx::Null< int > __o_StartingIndex,hx::Null< int > __o_DrawIndex,hx::Null< int > __o_CollideIndex){
HX_BEGIN_LOCAL_FUNC_S0(hx::LocalFunc,_hx_Closure_0) HXARGC(1)
bool _hx_run(::String line){
HX_GC_STACKFRAME(&_hx_pos_36d94048d9e4941f_188_loadMapFromCSV)
HXLINE( 188) return (line != HX_("",00,00,00,00));
}
HX_END_LOCAL_FUNC1(return)
int TileWidth = __o_TileWidth.Default(0);
int TileHeight = __o_TileHeight.Default(0);
int StartingIndex = __o_StartingIndex.Default(0);
int DrawIndex = __o_DrawIndex.Default(1);
int CollideIndex = __o_CollideIndex.Default(1);
HX_GC_STACKFRAME(&_hx_pos_36d94048d9e4941f_175_loadMapFromCSV)
HXLINE( 177) if (::openfl::_legacy::Assets_obj::exists(MapData,null())) {
HXLINE( 179) MapData = ::openfl::_legacy::Assets_obj::getText(MapData);
}
HXLINE( 183) this->_data = ::Array_obj< int >::__new();
HXLINE( 184) ::Array< ::String > columns;
HXLINE( 186) ::EReg regex = ::EReg_obj::__alloc( HX_CTX ,HX_("[ \t]*((\r\n)|\r|\n)[ \t]*",22,2c,8d,6d),HX_("g",67,00,00,00));
HXLINE( 187) ::Array< ::String > lines = regex->split(MapData);
HXLINE( 188) ::Array< ::String > rows = lines->filter( ::Dynamic(new _hx_Closure_0()));
HXLINE( 190) this->heightInTiles = rows->length;
HXLINE( 191) this->widthInTiles = (int)0;
HXLINE( 193) int row = (int)0;
HXLINE( 194) while((row < this->heightInTiles)){
HXLINE( 196) ::String rowString = rows->__get(row);
HXLINE( 197) if (::StringTools_obj::endsWith(rowString,HX_(",",2c,00,00,00))) {
HXLINE( 198) rowString = rowString.substr((int)0,(rowString.length - (int)1));
}
HXLINE( 199) columns = rowString.split(HX_(",",2c,00,00,00));
HXLINE( 201) if ((columns->length == (int)0)) {
HXLINE( 203) this->heightInTiles--;
HXLINE( 204) continue;
}
HXLINE( 206) if ((this->widthInTiles == (int)0)) {
HXLINE( 208) this->widthInTiles = columns->length;
}
HXLINE( 211) int column = (int)0;
HXLINE( 212) while((column < this->widthInTiles)){
HXLINE( 215) ::String columnString = columns->__get(column);
HXLINE( 216) ::Dynamic curTile = ::Std_obj::parseInt(columnString);
HXLINE( 218) if (hx::IsNull( curTile )) {
HXLINE( 219) HX_STACK_DO_THROW(((((((HX_("String in row ",b2,a4,63,43) + row) + HX_(", column ",96,fc,25,5b)) + column) + HX_(" is not a valid integer: \"",44,67,cc,45)) + columnString) + HX_("\"",22,00,00,00)));
}
HXLINE( 222) if (hx::IsLess( curTile,(int)0 )) {
HXLINE( 223) curTile = (int)0;
}
HXLINE( 225) this->_data->push(curTile);
HXLINE( 226) column = (column + (int)1);
}
HXLINE( 229) row = (row + (int)1);
}
HXLINE( 232) this->loadMapHelper(TileGraphic,TileWidth,TileHeight,AutoTile,StartingIndex,DrawIndex,CollideIndex);
HXLINE( 233) return hx::ObjectPtr<OBJ_>(this);
}
HX_DEFINE_DYNAMIC_FUNC8(FlxBaseTilemap_obj,loadMapFromCSV,return )
::flixel::tile::FlxBaseTilemap FlxBaseTilemap_obj::loadMapFromArray(::Array< int > MapData,int WidthInTiles,int HeightInTiles, ::Dynamic TileGraphic,hx::Null< int > __o_TileWidth,hx::Null< int > __o_TileHeight, ::flixel::tile::FlxTilemapAutoTiling AutoTile,hx::Null< int > __o_StartingIndex,hx::Null< int > __o_DrawIndex,hx::Null< int > __o_CollideIndex){
int TileWidth = __o_TileWidth.Default(0);
int TileHeight = __o_TileHeight.Default(0);
int StartingIndex = __o_StartingIndex.Default(0);
int DrawIndex = __o_DrawIndex.Default(1);
int CollideIndex = __o_CollideIndex.Default(1);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_258_loadMapFromArray)
HXLINE( 259) this->widthInTiles = WidthInTiles;
HXLINE( 260) this->heightInTiles = HeightInTiles;
HXLINE( 261) this->_data = MapData->copy();
HXLINE( 263) this->loadMapHelper(TileGraphic,TileWidth,TileHeight,AutoTile,StartingIndex,DrawIndex,CollideIndex);
HXLINE( 264) return hx::ObjectPtr<OBJ_>(this);
}
HX_DEFINE_DYNAMIC_FUNC10(FlxBaseTilemap_obj,loadMapFromArray,return )
::flixel::tile::FlxBaseTilemap FlxBaseTilemap_obj::loadMapFrom2DArray(::Array< ::Dynamic> MapData, ::Dynamic TileGraphic,hx::Null< int > __o_TileWidth,hx::Null< int > __o_TileHeight, ::flixel::tile::FlxTilemapAutoTiling AutoTile,hx::Null< int > __o_StartingIndex,hx::Null< int > __o_DrawIndex,hx::Null< int > __o_CollideIndex){
int TileWidth = __o_TileWidth.Default(0);
int TileHeight = __o_TileHeight.Default(0);
int StartingIndex = __o_StartingIndex.Default(0);
int DrawIndex = __o_DrawIndex.Default(1);
int CollideIndex = __o_CollideIndex.Default(1);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_287_loadMapFrom2DArray)
HXLINE( 288) this->widthInTiles = MapData->__get((int)0).StaticCast< ::Array< int > >()->length;
HXLINE( 289) this->heightInTiles = MapData->length;
HXLINE( 290) this->_data = ::flixel::util::FlxArrayUtil_obj::flatten2DArray_Int(MapData);
HXLINE( 292) this->loadMapHelper(TileGraphic,TileWidth,TileHeight,AutoTile,StartingIndex,DrawIndex,CollideIndex);
HXLINE( 293) return hx::ObjectPtr<OBJ_>(this);
}
HX_DEFINE_DYNAMIC_FUNC8(FlxBaseTilemap_obj,loadMapFrom2DArray,return )
::flixel::tile::FlxBaseTilemap FlxBaseTilemap_obj::loadMapFromGraphic( ::Dynamic MapGraphic,hx::Null< bool > __o_Invert,hx::Null< int > __o_Scale,::Array< int > ColorMap, ::Dynamic TileGraphic,hx::Null< int > __o_TileWidth,hx::Null< int > __o_TileHeight, ::flixel::tile::FlxTilemapAutoTiling AutoTile,hx::Null< int > __o_StartingIndex,hx::Null< int > __o_DrawIndex,hx::Null< int > __o_CollideIndex){
bool Invert = __o_Invert.Default(false);
int Scale = __o_Scale.Default(1);
int TileWidth = __o_TileWidth.Default(0);
int TileHeight = __o_TileHeight.Default(0);
int StartingIndex = __o_StartingIndex.Default(0);
int DrawIndex = __o_DrawIndex.Default(1);
int CollideIndex = __o_CollideIndex.Default(1);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_321_loadMapFromGraphic)
HXLINE( 322) ::openfl::_legacy::display::BitmapData mapBitmap = ::flixel::_hx_system::FlxAssets_obj::resolveBitmapData(MapGraphic);
HXLINE( 323) ::String mapData = ::flixel::util::FlxStringUtil_obj::bitmapToCSV(mapBitmap,Invert,Scale,ColorMap);
HXLINE( 324) return this->loadMapFromCSV(mapData,TileGraphic,TileWidth,TileHeight,AutoTile,StartingIndex,DrawIndex,CollideIndex);
}
HX_DEFINE_DYNAMIC_FUNC11(FlxBaseTilemap_obj,loadMapFromGraphic,return )
void FlxBaseTilemap_obj::loadMapHelper( ::Dynamic TileGraphic,hx::Null< int > __o_TileWidth,hx::Null< int > __o_TileHeight, ::flixel::tile::FlxTilemapAutoTiling AutoTile,hx::Null< int > __o_StartingIndex,hx::Null< int > __o_DrawIndex,hx::Null< int > __o_CollideIndex){
int TileWidth = __o_TileWidth.Default(0);
int TileHeight = __o_TileHeight.Default(0);
int StartingIndex = __o_StartingIndex.Default(0);
int DrawIndex = __o_DrawIndex.Default(1);
int CollideIndex = __o_CollideIndex.Default(1);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_329_loadMapHelper)
HXLINE( 330) this->totalTiles = this->_data->length;
HXLINE( 331) ::flixel::tile::FlxTilemapAutoTiling _hx_tmp;
HXDLIN( 331) if (hx::IsNull( AutoTile )) {
HXLINE( 331) _hx_tmp = ::flixel::tile::FlxTilemapAutoTiling_obj::OFF_dyn();
}
else {
HXLINE( 331) _hx_tmp = AutoTile;
}
HXDLIN( 331) this->_hx_auto = _hx_tmp;
HXLINE( 332) int _hx_tmp1;
HXDLIN( 332) if ((StartingIndex <= (int)0)) {
HXLINE( 332) _hx_tmp1 = (int)0;
}
else {
HXLINE( 332) _hx_tmp1 = StartingIndex;
}
HXDLIN( 332) this->_startingIndex = _hx_tmp1;
HXLINE( 334) if (hx::IsNotEq( this->_hx_auto,::flixel::tile::FlxTilemapAutoTiling_obj::OFF_dyn() )) {
HXLINE( 336) this->_startingIndex = (int)1;
HXLINE( 337) DrawIndex = (int)1;
HXLINE( 338) CollideIndex = (int)1;
}
HXLINE( 341) this->_drawIndex = DrawIndex;
HXLINE( 342) this->_collideIndex = CollideIndex;
HXLINE( 344) this->applyAutoTile();
HXLINE( 345) this->applyCustomRemap();
HXLINE( 346) this->randomizeIndices();
HXLINE( 347) this->cacheGraphics(TileWidth,TileHeight,TileGraphic);
HXLINE( 348) this->postGraphicLoad();
}
HX_DEFINE_DYNAMIC_FUNC7(FlxBaseTilemap_obj,loadMapHelper,(void))
void FlxBaseTilemap_obj::postGraphicLoad(){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_352_postGraphicLoad)
HXLINE( 353) this->initTileObjects();
HXLINE( 354) this->computeDimensions();
HXLINE( 355) this->updateMap();
}
HX_DEFINE_DYNAMIC_FUNC0(FlxBaseTilemap_obj,postGraphicLoad,(void))
void FlxBaseTilemap_obj::applyAutoTile(){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_361_applyAutoTile)
HXDLIN( 361) if (hx::IsNotEq( this->_hx_auto,::flixel::tile::FlxTilemapAutoTiling_obj::OFF_dyn() )) {
HXLINE( 363) int i = (int)0;
HXLINE( 364) while((i < this->totalTiles)){
HXLINE( 366) i = (i + (int)1);
HXDLIN( 366) this->autoTile((i - (int)1));
}
}
}
HX_DEFINE_DYNAMIC_FUNC0(FlxBaseTilemap_obj,applyAutoTile,(void))
void FlxBaseTilemap_obj::applyCustomRemap(){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_372_applyCustomRemap)
HXLINE( 373) int i = (int)0;
HXLINE( 375) if (hx::IsNotNull( this->customTileRemap )) {
HXLINE( 377) while((i < this->totalTiles)){
HXLINE( 379) int oldIndex = this->_data->__get(i);
HXLINE( 380) int newIndex = oldIndex;
HXLINE( 381) if ((oldIndex < this->customTileRemap->length)) {
HXLINE( 383) newIndex = this->customTileRemap->__get(oldIndex);
}
HXLINE( 385) this->_data[i] = newIndex;
HXLINE( 386) i = (i + (int)1);
}
}
}
HX_DEFINE_DYNAMIC_FUNC0(FlxBaseTilemap_obj,applyCustomRemap,(void))
void FlxBaseTilemap_obj::randomizeIndices(){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_392_randomizeIndices)
HXLINE( 393) int i = (int)0;
HXLINE( 395) if (hx::IsNotNull( this->_randomIndices )) {
HXLINE( 397) ::Dynamic randLambda;
HXDLIN( 397) if (hx::IsNotNull( this->_randomLambda )) {
HXLINE( 397) randLambda = this->_randomLambda;
}
else {
HX_BEGIN_LOCAL_FUNC_S0(hx::LocalFunc,_hx_Closure_0) HXARGC(0)
Float _hx_run(){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_399_randomizeIndices)
HXLINE( 399) return ::flixel::FlxG_obj::random->_hx_float(null(),null(),null());
}
HX_END_LOCAL_FUNC0(return)
HXLINE( 397) randLambda = ::Dynamic(new _hx_Closure_0());
}
HXLINE( 402) while((i < this->totalTiles)){
HXLINE( 404) int oldIndex = this->_data->__get(i);
HXLINE( 405) int j = (int)0;
HXLINE( 406) int newIndex = oldIndex;
HXLINE( 407) {
HXLINE( 407) int _g = (int)0;
HXDLIN( 407) ::Array< int > _g1 = this->_randomIndices;
HXDLIN( 407) while((_g < _g1->length)){
HXLINE( 407) int rand = _g1->__get(_g);
HXDLIN( 407) _g = (_g + (int)1);
HXLINE( 409) if ((oldIndex == rand)) {
HXLINE( 411) Float k = ( (Float)(randLambda()) );
HXDLIN( 411) int k1 = ::Std_obj::_hx_int((k * this->_randomChoices->__get(j).StaticCast< ::Array< int > >()->length));
HXLINE( 412) newIndex = this->_randomChoices->__get(j).StaticCast< ::Array< int > >()->__get(k1);
}
HXLINE( 414) j = (j + (int)1);
}
}
HXLINE( 416) this->_data[i] = newIndex;
HXLINE( 417) i = (i + (int)1);
}
}
}
HX_DEFINE_DYNAMIC_FUNC0(FlxBaseTilemap_obj,randomizeIndices,(void))
void FlxBaseTilemap_obj::autoTile(int Index){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_428_autoTile)
HXLINE( 429) if ((this->_data->__get(Index) == (int)0)) {
HXLINE( 431) return;
}
HXLINE( 434) this->_data[Index] = (int)0;
HXLINE( 437) bool _hx_tmp;
HXDLIN( 437) if (((Index - this->widthInTiles) >= (int)0)) {
HXLINE( 437) ::Array< int > _hx_tmp1 = this->_data;
HXDLIN( 437) _hx_tmp = (_hx_tmp1->__get((Index - this->widthInTiles)) > (int)0);
}
else {
HXLINE( 437) _hx_tmp = true;
}
HXDLIN( 437) if (_hx_tmp) {
HXLINE( 439) ::Array< int > _hx_tmp2 = this->_data;
HXDLIN( 439) int Index1 = Index;
HXDLIN( 439) _hx_tmp2[Index1] = (_hx_tmp2->__get(Index1) + (int)1);
}
HXLINE( 442) bool _hx_tmp3;
HXDLIN( 442) int _hx_tmp4 = hx::Mod(Index,this->widthInTiles);
HXDLIN( 442) if ((_hx_tmp4 < (this->widthInTiles - (int)1))) {
HXLINE( 442) ::Array< int > _hx_tmp5 = this->_data;
HXDLIN( 442) _hx_tmp3 = (_hx_tmp5->__get((Index + (int)1)) > (int)0);
}
else {
HXLINE( 442) _hx_tmp3 = true;
}
HXDLIN( 442) if (_hx_tmp3) {
HXLINE( 444) ::Array< int > _hx_tmp6 = this->_data;
HXDLIN( 444) int Index2 = Index;
HXDLIN( 444) _hx_tmp6[Index2] = (_hx_tmp6->__get(Index2) + (int)2);
}
HXLINE( 447) bool _hx_tmp7;
HXDLIN( 447) int _hx_tmp8 = ::Std_obj::_hx_int((Index + this->widthInTiles));
HXDLIN( 447) if ((_hx_tmp8 < this->totalTiles)) {
HXLINE( 447) ::Array< int > _hx_tmp9 = this->_data;
HXDLIN( 447) _hx_tmp7 = (_hx_tmp9->__get((Index + this->widthInTiles)) > (int)0);
}
else {
HXLINE( 447) _hx_tmp7 = true;
}
HXDLIN( 447) if (_hx_tmp7) {
HXLINE( 449) ::Array< int > _hx_tmp10 = this->_data;
HXDLIN( 449) int Index3 = Index;
HXDLIN( 449) _hx_tmp10[Index3] = (_hx_tmp10->__get(Index3) + (int)4);
}
HXLINE( 452) bool _hx_tmp11;
HXDLIN( 452) if ((hx::Mod(Index,this->widthInTiles) > (int)0)) {
HXLINE( 452) ::Array< int > _hx_tmp12 = this->_data;
HXDLIN( 452) _hx_tmp11 = (_hx_tmp12->__get((Index - (int)1)) > (int)0);
}
else {
HXLINE( 452) _hx_tmp11 = true;
}
HXDLIN( 452) if (_hx_tmp11) {
HXLINE( 454) ::Array< int > _hx_tmp13 = this->_data;
HXDLIN( 454) int Index4 = Index;
HXDLIN( 454) _hx_tmp13[Index4] = (_hx_tmp13->__get(Index4) + (int)8);
}
HXLINE( 458) bool _hx_tmp14;
HXDLIN( 458) if (hx::IsEq( this->_hx_auto,::flixel::tile::FlxTilemapAutoTiling_obj::ALT_dyn() )) {
HXLINE( 458) _hx_tmp14 = (this->_data->__get(Index) == (int)15);
}
else {
HXLINE( 458) _hx_tmp14 = false;
}
HXDLIN( 458) if (_hx_tmp14) {
HXLINE( 461) bool _hx_tmp15;
HXDLIN( 461) bool _hx_tmp16;
HXDLIN( 461) if ((hx::Mod(Index,this->widthInTiles) > (int)0)) {
HXLINE( 461) int _hx_tmp17 = ::Std_obj::_hx_int((Index + this->widthInTiles));
HXDLIN( 461) _hx_tmp16 = (_hx_tmp17 < this->totalTiles);
}
else {
HXLINE( 461) _hx_tmp16 = false;
}
HXDLIN( 461) if (_hx_tmp16) {
HXLINE( 461) ::Array< int > _hx_tmp18 = this->_data;
HXDLIN( 461) _hx_tmp15 = (_hx_tmp18->__get(((Index + this->widthInTiles) - (int)1)) <= (int)0);
}
else {
HXLINE( 461) _hx_tmp15 = false;
}
HXDLIN( 461) if (_hx_tmp15) {
HXLINE( 463) this->_data[Index] = (int)1;
}
HXLINE( 466) bool _hx_tmp19;
HXDLIN( 466) bool _hx_tmp20;
HXDLIN( 466) if ((hx::Mod(Index,this->widthInTiles) > (int)0)) {
HXLINE( 466) _hx_tmp20 = ((Index - this->widthInTiles) >= (int)0);
}
else {
HXLINE( 466) _hx_tmp20 = false;
}
HXDLIN( 466) if (_hx_tmp20) {
HXLINE( 466) ::Array< int > _hx_tmp21 = this->_data;
HXDLIN( 466) _hx_tmp19 = (_hx_tmp21->__get(((Index - this->widthInTiles) - (int)1)) <= (int)0);
}
else {
HXLINE( 466) _hx_tmp19 = false;
}
HXDLIN( 466) if (_hx_tmp19) {
HXLINE( 468) this->_data[Index] = (int)2;
}
HXLINE( 471) bool _hx_tmp22;
HXDLIN( 471) bool _hx_tmp23;
HXDLIN( 471) int _hx_tmp24 = hx::Mod(Index,this->widthInTiles);
HXDLIN( 471) if ((_hx_tmp24 < (this->widthInTiles - (int)1))) {
HXLINE( 471) _hx_tmp23 = ((Index - this->widthInTiles) >= (int)0);
}
else {
HXLINE( 471) _hx_tmp23 = false;
}
HXDLIN( 471) if (_hx_tmp23) {
HXLINE( 471) ::Array< int > _hx_tmp25 = this->_data;
HXDLIN( 471) _hx_tmp22 = (_hx_tmp25->__get(((Index - this->widthInTiles) + (int)1)) <= (int)0);
}
else {
HXLINE( 471) _hx_tmp22 = false;
}
HXDLIN( 471) if (_hx_tmp22) {
HXLINE( 473) this->_data[Index] = (int)4;
}
HXLINE( 476) bool _hx_tmp26;
HXDLIN( 476) bool _hx_tmp27;
HXDLIN( 476) int _hx_tmp28 = hx::Mod(Index,this->widthInTiles);
HXDLIN( 476) if ((_hx_tmp28 < (this->widthInTiles - (int)1))) {
HXLINE( 476) int _hx_tmp29 = ::Std_obj::_hx_int((Index + this->widthInTiles));
HXDLIN( 476) _hx_tmp27 = (_hx_tmp29 < this->totalTiles);
}
else {
HXLINE( 476) _hx_tmp27 = false;
}
HXDLIN( 476) if (_hx_tmp27) {
HXLINE( 476) ::Array< int > _hx_tmp30 = this->_data;
HXDLIN( 476) _hx_tmp26 = (_hx_tmp30->__get(((Index + this->widthInTiles) + (int)1)) <= (int)0);
}
else {
HXLINE( 476) _hx_tmp26 = false;
}
HXDLIN( 476) if (_hx_tmp26) {
HXLINE( 478) this->_data[Index] = (int)8;
}
}
HXLINE( 482) ::Array< int > _hx_tmp31 = this->_data;
HXDLIN( 482) int Index5 = Index;
HXDLIN( 482) _hx_tmp31[Index5] = (_hx_tmp31->__get(Index5) + (int)1);
}
HX_DEFINE_DYNAMIC_FUNC1(FlxBaseTilemap_obj,autoTile,(void))
void FlxBaseTilemap_obj::setCustomTileMappings(::Array< int > mappings,::Array< int > randomIndices,::Array< ::Dynamic> randomChoices, ::Dynamic randomLambda){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_495_setCustomTileMappings)
HXLINE( 496) this->customTileRemap = mappings;
HXLINE( 497) this->_randomIndices = randomIndices;
HXLINE( 498) this->_randomChoices = randomChoices;
HXLINE( 499) this->_randomLambda = randomLambda;
HXLINE( 502) bool _hx_tmp;
HXDLIN( 502) if (hx::IsNotNull( this->_randomIndices )) {
HXLINE( 502) if (hx::IsNotNull( this->_randomChoices )) {
HXLINE( 502) _hx_tmp = (this->_randomChoices->length == (int)0);
}
else {
HXLINE( 502) _hx_tmp = true;
}
}
else {
HXLINE( 502) _hx_tmp = false;
}
HXDLIN( 502) if (_hx_tmp) {
HXLINE( 504) HX_STACK_DO_THROW(HX_("You must provide valid 'randomChoices' if you wish to randomize tilemap indicies, please read documentation of 'setCustomTileMappings' function.",58,d6,21,51));
}
}
HX_DEFINE_DYNAMIC_FUNC4(FlxBaseTilemap_obj,setCustomTileMappings,(void))
int FlxBaseTilemap_obj::getTile(int X,int Y){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_517_getTile)
HXDLIN( 517) ::Array< int > _hx_tmp = this->_data;
HXDLIN( 517) return _hx_tmp->__get(((Y * this->widthInTiles) + X));
}
HX_DEFINE_DYNAMIC_FUNC2(FlxBaseTilemap_obj,getTile,return )
int FlxBaseTilemap_obj::getTileByIndex(int Index){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_528_getTileByIndex)
HXDLIN( 528) return this->_data->__get(Index);
}
HX_DEFINE_DYNAMIC_FUNC1(FlxBaseTilemap_obj,getTileByIndex,return )
int FlxBaseTilemap_obj::getTileCollisions(int Index){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_539_getTileCollisions)
HXDLIN( 539) return ( ( ::flixel::FlxObject)(this->_tileObjects->__get(Index)) )->allowCollisions;
}
HX_DEFINE_DYNAMIC_FUNC1(FlxBaseTilemap_obj,getTileCollisions,return )
::Array< int > FlxBaseTilemap_obj::getTileInstances(int Index){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_549_getTileInstances)
HXLINE( 550) ::Array< int > array = null();
HXLINE( 551) int i = (int)0;
HXLINE( 552) int l = (this->widthInTiles * this->heightInTiles);
HXLINE( 554) while((i < l)){
HXLINE( 556) if ((this->_data->__get(i) == Index)) {
HXLINE( 558) if (hx::IsNull( array )) {
HXLINE( 560) array = ::Array_obj< int >::__new(0);
}
HXLINE( 562) array->push(i);
}
HXLINE( 564) i = (i + (int)1);
}
HXLINE( 567) return array;
}
HX_DEFINE_DYNAMIC_FUNC1(FlxBaseTilemap_obj,getTileInstances,return )
bool FlxBaseTilemap_obj::setTile(int X,int Y,int Tile,hx::Null< bool > __o_UpdateGraphics){
bool UpdateGraphics = __o_UpdateGraphics.Default(true);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_580_setTile)
HXLINE( 581) bool _hx_tmp;
HXDLIN( 581) if ((X < this->widthInTiles)) {
HXLINE( 581) _hx_tmp = (Y >= this->heightInTiles);
}
else {
HXLINE( 581) _hx_tmp = true;
}
HXDLIN( 581) if (_hx_tmp) {
HXLINE( 583) return false;
}
HXLINE( 586) return this->setTileByIndex(((Y * this->widthInTiles) + X),Tile,UpdateGraphics);
}
HX_DEFINE_DYNAMIC_FUNC4(FlxBaseTilemap_obj,setTile,return )
bool FlxBaseTilemap_obj::setTileByIndex(int Index,int Tile,hx::Null< bool > __o_UpdateGraphics){
bool UpdateGraphics = __o_UpdateGraphics.Default(true);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_598_setTileByIndex)
HXLINE( 599) if ((Index >= this->_data->length)) {
HXLINE( 601) return false;
}
HXLINE( 604) bool ok = true;
HXLINE( 605) this->_data[Index] = Tile;
HXLINE( 607) if (!(UpdateGraphics)) {
HXLINE( 609) return ok;
}
HXLINE( 612) this->setDirty(null());
HXLINE( 614) if (hx::IsEq( this->_hx_auto,::flixel::tile::FlxTilemapAutoTiling_obj::OFF_dyn() )) {
HXLINE( 616) this->updateTile(this->_data->__get(Index));
HXLINE( 617) return ok;
}
HXLINE( 621) int i;
HXLINE( 622) int row = (::Std_obj::_hx_int(((Float)Index / (Float)this->widthInTiles)) - (int)1);
HXLINE( 623) int rowLength = (row + (int)3);
HXLINE( 624) int column = (hx::Mod(Index,this->widthInTiles) - (int)1);
HXLINE( 625) int columnHeight = (column + (int)3);
HXLINE( 627) while((row < rowLength)){
HXLINE( 629) column = (columnHeight - (int)3);
HXLINE( 631) while((column < columnHeight)){
HXLINE( 633) bool _hx_tmp;
HXDLIN( 633) bool _hx_tmp1;
HXDLIN( 633) bool _hx_tmp2;
HXDLIN( 633) if ((row >= (int)0)) {
HXLINE( 633) _hx_tmp2 = (row < this->heightInTiles);
}
else {
HXLINE( 633) _hx_tmp2 = false;
}
HXDLIN( 633) if (_hx_tmp2) {
HXLINE( 633) _hx_tmp1 = (column >= (int)0);
}
else {
HXLINE( 633) _hx_tmp1 = false;
}
HXDLIN( 633) if (_hx_tmp1) {
HXLINE( 633) _hx_tmp = (column < this->widthInTiles);
}
else {
HXLINE( 633) _hx_tmp = false;
}
HXDLIN( 633) if (_hx_tmp) {
HXLINE( 635) i = ((row * this->widthInTiles) + column);
HXLINE( 636) this->autoTile(i);
HXLINE( 637) this->updateTile(this->_data->__get(i));
}
HXLINE( 639) column = (column + (int)1);
}
HXLINE( 641) row = (row + (int)1);
}
HXLINE( 644) return ok;
}
HX_DEFINE_DYNAMIC_FUNC3(FlxBaseTilemap_obj,setTileByIndex,return )
void FlxBaseTilemap_obj::setTileProperties(int Tile,hx::Null< int > __o_AllowCollisions, ::Dynamic Callback,hx::Class CallbackFilter,hx::Null< int > __o_Range){
int AllowCollisions = __o_AllowCollisions.Default(4369);
int Range = __o_Range.Default(1);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_658_setTileProperties)
HXLINE( 659) if ((Range <= (int)0)) {
HXLINE( 661) Range = (int)1;
}
HXLINE( 664) ::Dynamic tile;
HXLINE( 665) int i = Tile;
HXLINE( 666) int l = (Tile + Range);
HXLINE( 668) int maxIndex = this->_tileObjects->get_length();
HXLINE( 669) if ((l > maxIndex)) {
HXLINE( 671) HX_STACK_DO_THROW(((((((((HX_("Index ",ee,88,87,c8) + l) + HX_(" exceeds the maximum tile index of ",d9,51,06,f4)) + maxIndex) + HX_(". Please verfiy the Tile (",ee,52,a5,6c)) + Tile) + HX_(") and Range (",25,ce,96,19)) + Range) + HX_(") parameters.",cd,e3,29,61)));
}
HXLINE( 674) while((i < l)){
HXLINE( 676) ::cpp::VirtualArray tile1 = this->_tileObjects;
HXDLIN( 676) i = (i + (int)1);
HXDLIN( 676) tile = tile1->__get((i - (int)1));
HXLINE( 677) ( ( ::flixel::FlxObject)(tile) )->set_allowCollisions(AllowCollisions);
HXLINE( 678) tile->__SetField(HX_("callbackFunction",fd,cd,91,7e),Callback,hx::paccDynamic);
HXLINE( 679) tile->__SetField(HX_("filter",b8,1f,35,85),CallbackFilter,hx::paccDynamic);
}
}
HX_DEFINE_DYNAMIC_FUNC5(FlxBaseTilemap_obj,setTileProperties,(void))
::Array< int > FlxBaseTilemap_obj::getData(hx::Null< bool > __o_Simple){
bool Simple = __o_Simple.Default(false);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_691_getData)
HXLINE( 692) if (!(Simple)) {
HXLINE( 694) return this->_data;
}
HXLINE( 697) int i = (int)0;
HXLINE( 698) int l = this->_data->length;
HXLINE( 699) ::Array< int > data = ::Array_obj< int >::__new();
HXLINE( 700) ::flixel::util::FlxArrayUtil_obj::setLength_Int(data,l);
HXLINE( 702) while((i < l)){
HXLINE( 704) int _hx_tmp;
HXDLIN( 704) ::cpp::VirtualArray _hx_tmp1 = this->_tileObjects;
HXDLIN( 704) if ((( ( ::flixel::FlxObject)(_hx_tmp1->__get(this->_data->__get(i))) )->allowCollisions > (int)0)) {
HXLINE( 704) _hx_tmp = (int)1;
}
else {
HXLINE( 704) _hx_tmp = (int)0;
}
HXDLIN( 704) data[i] = _hx_tmp;
HXLINE( 705) i = (i + (int)1);
}
HXLINE( 708) return data;
}
HX_DEFINE_DYNAMIC_FUNC1(FlxBaseTilemap_obj,getData,return )
::Array< ::Dynamic> FlxBaseTilemap_obj::findPath( ::flixel::math::FlxPoint Start, ::flixel::math::FlxPoint End,hx::Null< bool > __o_Simplify,hx::Null< bool > __o_RaySimplify,hx::Null< int > __o_DiagonalPolicy){
bool Simplify = __o_Simplify.Default(true);
bool RaySimplify = __o_RaySimplify.Default(false);
int DiagonalPolicy = __o_DiagonalPolicy.Default(2);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_723_findPath)
HXLINE( 725) int startIndex = this->getTileIndexByCoords(Start);
HXLINE( 726) int endIndex = this->getTileIndexByCoords(End);
HXLINE( 729) bool _hx_tmp;
HXDLIN( 729) ::cpp::VirtualArray _hx_tmp1 = this->_tileObjects;
HXDLIN( 729) if ((( ( ::flixel::FlxObject)(_hx_tmp1->__get(this->_data->__get(startIndex))) )->allowCollisions <= (int)0)) {
HXLINE( 729) ::cpp::VirtualArray _hx_tmp2 = this->_tileObjects;
HXDLIN( 729) _hx_tmp = (( ( ::flixel::FlxObject)(_hx_tmp2->__get(this->_data->__get(endIndex))) )->allowCollisions > (int)0);
}
else {
HXLINE( 729) _hx_tmp = true;
}
HXDLIN( 729) if (_hx_tmp) {
HXLINE( 731) return null();
}
HXLINE( 735) ::Array< int > distances = this->computePathDistance(startIndex,endIndex,DiagonalPolicy,null());
HXLINE( 737) if (hx::IsNull( distances )) {
HXLINE( 739) return null();
}
HXLINE( 743) ::Array< ::Dynamic> points = ::Array_obj< ::Dynamic>::__new();
HXLINE( 744) this->walkPath(distances,endIndex,points);
HXLINE( 747) ::flixel::math::FlxPoint node = points->__get((points->length - (int)1)).StaticCast< ::flixel::math::FlxPoint >();
HXLINE( 749) {
HXLINE( 749) node->set_x(Start->x);
HXDLIN( 749) node->set_y(Start->y);
HXDLIN( 749) if (Start->_weak) {
HXLINE( 749) Start->put();
}
}
HXLINE( 750) node = points->__get((int)0).StaticCast< ::flixel::math::FlxPoint >();
HXLINE( 751) {
HXLINE( 751) node->set_x(End->x);
HXDLIN( 751) node->set_y(End->y);
HXDLIN( 751) if (End->_weak) {
HXLINE( 751) End->put();
}
}
HXLINE( 754) if (Simplify) {
HXLINE( 756) this->simplifyPath(points);
}
HXLINE( 758) if (RaySimplify) {
HXLINE( 760) this->raySimplifyPath(points);
}
HXLINE( 764) ::Array< ::Dynamic> path = ::Array_obj< ::Dynamic>::__new(0);
HXLINE( 765) int i = (points->length - (int)1);
HXLINE( 767) while((i >= (int)0)){
HXLINE( 769) i = (i - (int)1);
HXDLIN( 769) node = points->__get((i + (int)1)).StaticCast< ::flixel::math::FlxPoint >();
HXLINE( 771) if (hx::IsNotNull( node )) {
HXLINE( 773) path->push(node);
}
}
HXLINE( 777) return path;
}
HX_DEFINE_DYNAMIC_FUNC5(FlxBaseTilemap_obj,findPath,return )
::Array< int > FlxBaseTilemap_obj::computePathDistance(int StartIndex,int EndIndex,int DiagonalPolicy,hx::Null< bool > __o_StopOnEnd){
bool StopOnEnd = __o_StopOnEnd.Default(true);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_791_computePathDistance)
HXLINE( 794) int mapSize = (this->widthInTiles * this->heightInTiles);
HXLINE( 795) ::Array< int > distances = ::Array_obj< int >::__new();
HXLINE( 796) ::flixel::util::FlxArrayUtil_obj::setLength_Int(distances,mapSize);
HXLINE( 797) int i = (int)0;
HXLINE( 799) while((i < mapSize)){
HXLINE( 801) ::cpp::VirtualArray _hx_tmp = this->_tileObjects;
HXDLIN( 801) if ((( ( ::flixel::FlxObject)(_hx_tmp->__get(this->_data->__get(i))) )->allowCollisions != (int)0)) {
HXLINE( 803) distances[i] = (int)-2;
}
else {
HXLINE( 807) distances[i] = (int)-1;
}
HXLINE( 809) i = (i + (int)1);
}
HXLINE( 812) distances[StartIndex] = (int)0;
HXLINE( 813) int distance = (int)1;
HXLINE( 814) ::Array< int > neighbors = ::Array_obj< int >::__new(1)->init(0,StartIndex);
HXLINE( 815) ::Array< int > current;
HXLINE( 816) int currentIndex;
HXLINE( 817) bool left;
HXLINE( 818) bool right;
HXLINE( 819) bool up;
HXLINE( 820) bool down;
HXLINE( 821) int currentLength;
HXLINE( 822) bool foundEnd = false;
HXLINE( 824) while((neighbors->length > (int)0)){
HXLINE( 826) current = neighbors;
HXLINE( 827) neighbors = ::Array_obj< int >::__new();
HXLINE( 829) i = (int)0;
HXLINE( 830) currentLength = current->length;
HXLINE( 831) while((i < currentLength)){
HXLINE( 833) i = (i + (int)1);
HXDLIN( 833) currentIndex = current->__get((i - (int)1));
HXLINE( 835) if ((currentIndex == ::Std_obj::_hx_int(EndIndex))) {
HXLINE( 837) foundEnd = true;
HXLINE( 838) if (StopOnEnd) {
HXLINE( 840) neighbors = ::Array_obj< int >::__new(0);
HXLINE( 841) goto _hx_goto_48;
}
}
HXLINE( 846) left = (hx::Mod(currentIndex,this->widthInTiles) > (int)0);
HXLINE( 847) int right1 = hx::Mod(currentIndex,this->widthInTiles);
HXDLIN( 847) right = (right1 < (this->widthInTiles - (int)1));
HXLINE( 848) up = (((Float)currentIndex / (Float)this->widthInTiles) > (int)0);
HXLINE( 849) Float down1 = ((Float)currentIndex / (Float)this->widthInTiles);
HXDLIN( 849) down = (down1 < (this->heightInTiles - (int)1));
HXLINE( 851) int index;
HXLINE( 853) if (up) {
HXLINE( 855) index = (currentIndex - this->widthInTiles);
HXLINE( 857) if ((distances->__get(index) == (int)-1)) {
HXLINE( 859) distances[index] = distance;
HXLINE( 860) neighbors->push(index);
}
}
HXLINE( 863) if (right) {
HXLINE( 865) index = (currentIndex + (int)1);
HXLINE( 867) if ((distances->__get(index) == (int)-1)) {
HXLINE( 869) distances[index] = distance;
HXLINE( 870) neighbors->push(index);
}
}
HXLINE( 873) if (down) {
HXLINE( 875) index = (currentIndex + this->widthInTiles);
HXLINE( 877) if ((distances->__get(index) == (int)-1)) {
HXLINE( 879) distances[index] = distance;
HXLINE( 880) neighbors->push(index);
}
}
HXLINE( 883) if (left) {
HXLINE( 885) index = (currentIndex - (int)1);
HXLINE( 887) if ((distances->__get(index) == (int)-1)) {
HXLINE( 889) distances[index] = distance;
HXLINE( 890) neighbors->push(index);
}
}
HXLINE( 894) if ((DiagonalPolicy != (int)0)) {
HXLINE( 896) bool wideDiagonal = (DiagonalPolicy == (int)2);
HXLINE( 897) bool _hx_tmp1;
HXDLIN( 897) if (up) {
HXLINE( 897) _hx_tmp1 = right;
}
else {
HXLINE( 897) _hx_tmp1 = false;
}
HXDLIN( 897) if (_hx_tmp1) {
HXLINE( 899) index = ((currentIndex - this->widthInTiles) + (int)1);
HXLINE( 901) bool _hx_tmp2;
HXDLIN( 901) bool _hx_tmp3;
HXDLIN( 901) bool _hx_tmp4;
HXDLIN( 901) if (wideDiagonal) {
HXLINE( 901) _hx_tmp4 = (distances->__get(index) == (int)-1);
}
else {
HXLINE( 901) _hx_tmp4 = false;
}
HXDLIN( 901) if (_hx_tmp4) {
HXLINE( 901) _hx_tmp3 = (distances->__get((currentIndex - this->widthInTiles)) >= (int)-1);
}
else {
HXLINE( 901) _hx_tmp3 = false;
}
HXDLIN( 901) if (_hx_tmp3) {
HXLINE( 901) _hx_tmp2 = (distances->__get((currentIndex + (int)1)) >= (int)-1);
}
else {
HXLINE( 901) _hx_tmp2 = false;
}
HXDLIN( 901) if (_hx_tmp2) {
HXLINE( 905) distances[index] = distance;
HXLINE( 906) neighbors->push(index);
}
else {
HXLINE( 908) bool _hx_tmp5;
HXDLIN( 908) if (!(wideDiagonal)) {
HXLINE( 908) _hx_tmp5 = (distances->__get(index) == (int)-1);
}
else {
HXLINE( 908) _hx_tmp5 = false;
}
HXDLIN( 908) if (_hx_tmp5) {
HXLINE( 910) distances[index] = distance;
HXLINE( 911) neighbors->push(index);
}
}
}
HXLINE( 914) bool _hx_tmp6;
HXDLIN( 914) if (right) {
HXLINE( 914) _hx_tmp6 = down;
}
else {
HXLINE( 914) _hx_tmp6 = false;
}
HXDLIN( 914) if (_hx_tmp6) {
HXLINE( 916) index = ((currentIndex + this->widthInTiles) + (int)1);
HXLINE( 918) bool _hx_tmp7;
HXDLIN( 918) bool _hx_tmp8;
HXDLIN( 918) bool _hx_tmp9;
HXDLIN( 918) if (wideDiagonal) {
HXLINE( 918) _hx_tmp9 = (distances->__get(index) == (int)-1);
}
else {
HXLINE( 918) _hx_tmp9 = false;
}
HXDLIN( 918) if (_hx_tmp9) {
HXLINE( 918) _hx_tmp8 = (distances->__get((currentIndex + this->widthInTiles)) >= (int)-1);
}
else {
HXLINE( 918) _hx_tmp8 = false;
}
HXDLIN( 918) if (_hx_tmp8) {
HXLINE( 918) _hx_tmp7 = (distances->__get((currentIndex + (int)1)) >= (int)-1);
}
else {
HXLINE( 918) _hx_tmp7 = false;
}
HXDLIN( 918) if (_hx_tmp7) {
HXLINE( 922) distances[index] = distance;
HXLINE( 923) neighbors->push(index);
}
else {
HXLINE( 925) bool _hx_tmp10;
HXDLIN( 925) if (!(wideDiagonal)) {
HXLINE( 925) _hx_tmp10 = (distances->__get(index) == (int)-1);
}
else {
HXLINE( 925) _hx_tmp10 = false;
}
HXDLIN( 925) if (_hx_tmp10) {
HXLINE( 927) distances[index] = distance;
HXLINE( 928) neighbors->push(index);
}
}
}
HXLINE( 931) bool _hx_tmp11;
HXDLIN( 931) if (left) {
HXLINE( 931) _hx_tmp11 = down;
}
else {
HXLINE( 931) _hx_tmp11 = false;
}
HXDLIN( 931) if (_hx_tmp11) {
HXLINE( 933) index = ((currentIndex + this->widthInTiles) - (int)1);
HXLINE( 935) bool _hx_tmp12;
HXDLIN( 935) bool _hx_tmp13;
HXDLIN( 935) bool _hx_tmp14;
HXDLIN( 935) if (wideDiagonal) {
HXLINE( 935) _hx_tmp14 = (distances->__get(index) == (int)-1);
}
else {
HXLINE( 935) _hx_tmp14 = false;
}
HXDLIN( 935) if (_hx_tmp14) {
HXLINE( 935) _hx_tmp13 = (distances->__get((currentIndex + this->widthInTiles)) >= (int)-1);
}
else {
HXLINE( 935) _hx_tmp13 = false;
}
HXDLIN( 935) if (_hx_tmp13) {
HXLINE( 935) _hx_tmp12 = (distances->__get((currentIndex - (int)1)) >= (int)-1);
}
else {
HXLINE( 935) _hx_tmp12 = false;
}
HXDLIN( 935) if (_hx_tmp12) {
HXLINE( 939) distances[index] = distance;
HXLINE( 940) neighbors->push(index);
}
else {
HXLINE( 942) bool _hx_tmp15;
HXDLIN( 942) if (!(wideDiagonal)) {
HXLINE( 942) _hx_tmp15 = (distances->__get(index) == (int)-1);
}
else {
HXLINE( 942) _hx_tmp15 = false;
}
HXDLIN( 942) if (_hx_tmp15) {
HXLINE( 944) distances[index] = distance;
HXLINE( 945) neighbors->push(index);
}
}
}
HXLINE( 948) bool _hx_tmp16;
HXDLIN( 948) if (up) {
HXLINE( 948) _hx_tmp16 = left;
}
else {
HXLINE( 948) _hx_tmp16 = false;
}
HXDLIN( 948) if (_hx_tmp16) {
HXLINE( 950) index = ((currentIndex - this->widthInTiles) - (int)1);
HXLINE( 952) bool _hx_tmp17;
HXDLIN( 952) bool _hx_tmp18;
HXDLIN( 952) bool _hx_tmp19;
HXDLIN( 952) if (wideDiagonal) {
HXLINE( 952) _hx_tmp19 = (distances->__get(index) == (int)-1);
}
else {
HXLINE( 952) _hx_tmp19 = false;
}
HXDLIN( 952) if (_hx_tmp19) {
HXLINE( 952) _hx_tmp18 = (distances->__get((currentIndex - this->widthInTiles)) >= (int)-1);
}
else {
HXLINE( 952) _hx_tmp18 = false;
}
HXDLIN( 952) if (_hx_tmp18) {
HXLINE( 952) _hx_tmp17 = (distances->__get((currentIndex - (int)1)) >= (int)-1);
}
else {
HXLINE( 952) _hx_tmp17 = false;
}
HXDLIN( 952) if (_hx_tmp17) {
HXLINE( 956) distances[index] = distance;
HXLINE( 957) neighbors->push(index);
}
else {
HXLINE( 959) bool _hx_tmp20;
HXDLIN( 959) if (!(wideDiagonal)) {
HXLINE( 959) _hx_tmp20 = (distances->__get(index) == (int)-1);
}
else {
HXLINE( 959) _hx_tmp20 = false;
}
HXDLIN( 959) if (_hx_tmp20) {
HXLINE( 961) distances[index] = distance;
HXLINE( 962) neighbors->push(index);
}
}
}
}
}
_hx_goto_48:;
HXLINE( 968) distance = (distance + (int)1);
}
HXLINE( 970) if (!(foundEnd)) {
HXLINE( 972) distances = null();
}
HXLINE( 975) return distances;
}
HX_DEFINE_DYNAMIC_FUNC4(FlxBaseTilemap_obj,computePathDistance,return )
void FlxBaseTilemap_obj::walkPath(::Array< int > Data,int Start,::Array< ::Dynamic> Points){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_986_walkPath)
HXLINE( 987) Points->push(this->getTileCoordsByIndex(Start,null()));
HXLINE( 989) if ((Data->__get(Start) == (int)0)) {
HXLINE( 991) return;
}
HXLINE( 995) bool left = (hx::Mod(Start,this->widthInTiles) > (int)0);
HXLINE( 996) int right = hx::Mod(Start,this->widthInTiles);
HXDLIN( 996) bool right1 = (right < (this->widthInTiles - (int)1));
HXLINE( 997) bool up = (((Float)Start / (Float)this->widthInTiles) > (int)0);
HXLINE( 998) Float down = ((Float)Start / (Float)this->widthInTiles);
HXDLIN( 998) bool down1 = (down < (this->heightInTiles - (int)1));
HXLINE(1000) int current = Data->__get(Start);
HXLINE(1001) int i;
HXLINE(1003) if (up) {
HXLINE(1005) i = (Start - this->widthInTiles);
HXLINE(1007) bool _hx_tmp;
HXDLIN(1007) bool _hx_tmp1;
HXDLIN(1007) if ((i >= (int)0)) {
HXLINE(1007) _hx_tmp1 = (Data->__get(i) >= (int)0);
}
else {
HXLINE(1007) _hx_tmp1 = false;
}
HXDLIN(1007) if (_hx_tmp1) {
HXLINE(1007) _hx_tmp = (Data->__get(i) < current);
}
else {
HXLINE(1007) _hx_tmp = false;
}
HXDLIN(1007) if (_hx_tmp) {
HXLINE(1009) this->walkPath(Data,i,Points);
HXDLIN(1009) return;
}
}
HXLINE(1012) if (right1) {
HXLINE(1014) i = (Start + (int)1);
HXLINE(1016) bool _hx_tmp2;
HXDLIN(1016) bool _hx_tmp3;
HXDLIN(1016) if ((i >= (int)0)) {
HXLINE(1016) _hx_tmp3 = (Data->__get(i) >= (int)0);
}
else {
HXLINE(1016) _hx_tmp3 = false;
}
HXDLIN(1016) if (_hx_tmp3) {
HXLINE(1016) _hx_tmp2 = (Data->__get(i) < current);
}
else {
HXLINE(1016) _hx_tmp2 = false;
}
HXDLIN(1016) if (_hx_tmp2) {
HXLINE(1018) this->walkPath(Data,i,Points);
HXDLIN(1018) return;
}
}
HXLINE(1021) if (down1) {
HXLINE(1023) i = (Start + this->widthInTiles);
HXLINE(1025) bool _hx_tmp4;
HXDLIN(1025) bool _hx_tmp5;
HXDLIN(1025) if ((i >= (int)0)) {
HXLINE(1025) _hx_tmp5 = (Data->__get(i) >= (int)0);
}
else {
HXLINE(1025) _hx_tmp5 = false;
}
HXDLIN(1025) if (_hx_tmp5) {
HXLINE(1025) _hx_tmp4 = (Data->__get(i) < current);
}
else {
HXLINE(1025) _hx_tmp4 = false;
}
HXDLIN(1025) if (_hx_tmp4) {
HXLINE(1027) this->walkPath(Data,i,Points);
HXDLIN(1027) return;
}
}
HXLINE(1030) if (left) {
HXLINE(1032) i = (Start - (int)1);
HXLINE(1034) bool _hx_tmp6;
HXDLIN(1034) bool _hx_tmp7;
HXDLIN(1034) if ((i >= (int)0)) {
HXLINE(1034) _hx_tmp7 = (Data->__get(i) >= (int)0);
}
else {
HXLINE(1034) _hx_tmp7 = false;
}
HXDLIN(1034) if (_hx_tmp7) {
HXLINE(1034) _hx_tmp6 = (Data->__get(i) < current);
}
else {
HXLINE(1034) _hx_tmp6 = false;
}
HXDLIN(1034) if (_hx_tmp6) {
HXLINE(1036) this->walkPath(Data,i,Points);
HXDLIN(1036) return;
}
}
HXLINE(1039) bool _hx_tmp8;
HXDLIN(1039) if (up) {
HXLINE(1039) _hx_tmp8 = right1;
}
else {
HXLINE(1039) _hx_tmp8 = false;
}
HXDLIN(1039) if (_hx_tmp8) {
HXLINE(1041) i = ((Start - this->widthInTiles) + (int)1);
HXLINE(1043) bool _hx_tmp9;
HXDLIN(1043) bool _hx_tmp10;
HXDLIN(1043) if ((i >= (int)0)) {
HXLINE(1043) _hx_tmp10 = (Data->__get(i) >= (int)0);
}
else {
HXLINE(1043) _hx_tmp10 = false;
}
HXDLIN(1043) if (_hx_tmp10) {
HXLINE(1043) _hx_tmp9 = (Data->__get(i) < current);
}
else {
HXLINE(1043) _hx_tmp9 = false;
}
HXDLIN(1043) if (_hx_tmp9) {
HXLINE(1045) this->walkPath(Data,i,Points);
HXDLIN(1045) return;
}
}
HXLINE(1048) bool _hx_tmp11;
HXDLIN(1048) if (right1) {
HXLINE(1048) _hx_tmp11 = down1;
}
else {
HXLINE(1048) _hx_tmp11 = false;
}
HXDLIN(1048) if (_hx_tmp11) {
HXLINE(1050) i = ((Start + this->widthInTiles) + (int)1);
HXLINE(1052) bool _hx_tmp12;
HXDLIN(1052) bool _hx_tmp13;
HXDLIN(1052) if ((i >= (int)0)) {
HXLINE(1052) _hx_tmp13 = (Data->__get(i) >= (int)0);
}
else {
HXLINE(1052) _hx_tmp13 = false;
}
HXDLIN(1052) if (_hx_tmp13) {
HXLINE(1052) _hx_tmp12 = (Data->__get(i) < current);
}
else {
HXLINE(1052) _hx_tmp12 = false;
}
HXDLIN(1052) if (_hx_tmp12) {
HXLINE(1054) this->walkPath(Data,i,Points);
HXDLIN(1054) return;
}
}
HXLINE(1057) bool _hx_tmp14;
HXDLIN(1057) if (left) {
HXLINE(1057) _hx_tmp14 = down1;
}
else {
HXLINE(1057) _hx_tmp14 = false;
}
HXDLIN(1057) if (_hx_tmp14) {
HXLINE(1059) i = ((Start + this->widthInTiles) - (int)1);
HXLINE(1061) bool _hx_tmp15;
HXDLIN(1061) bool _hx_tmp16;
HXDLIN(1061) if ((i >= (int)0)) {
HXLINE(1061) _hx_tmp16 = (Data->__get(i) >= (int)0);
}
else {
HXLINE(1061) _hx_tmp16 = false;
}
HXDLIN(1061) if (_hx_tmp16) {
HXLINE(1061) _hx_tmp15 = (Data->__get(i) < current);
}
else {
HXLINE(1061) _hx_tmp15 = false;
}
HXDLIN(1061) if (_hx_tmp15) {
HXLINE(1063) this->walkPath(Data,i,Points);
HXDLIN(1063) return;
}
}
HXLINE(1066) bool _hx_tmp17;
HXDLIN(1066) if (up) {
HXLINE(1066) _hx_tmp17 = left;
}
else {
HXLINE(1066) _hx_tmp17 = false;
}
HXDLIN(1066) if (_hx_tmp17) {
HXLINE(1068) i = ((Start - this->widthInTiles) - (int)1);
HXLINE(1070) bool _hx_tmp18;
HXDLIN(1070) bool _hx_tmp19;
HXDLIN(1070) if ((i >= (int)0)) {
HXLINE(1070) _hx_tmp19 = (Data->__get(i) >= (int)0);
}
else {
HXLINE(1070) _hx_tmp19 = false;
}
HXDLIN(1070) if (_hx_tmp19) {
HXLINE(1070) _hx_tmp18 = (Data->__get(i) < current);
}
else {
HXLINE(1070) _hx_tmp18 = false;
}
HXDLIN(1070) if (_hx_tmp18) {
HXLINE(1072) this->walkPath(Data,i,Points);
HXDLIN(1072) return;
}
}
HXLINE(1076) return;
}
HX_DEFINE_DYNAMIC_FUNC3(FlxBaseTilemap_obj,walkPath,(void))
void FlxBaseTilemap_obj::simplifyPath(::Array< ::Dynamic> Points){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_1085_simplifyPath)
HXLINE(1086) Float deltaPrevious;
HXLINE(1087) Float deltaNext;
HXLINE(1088) ::flixel::math::FlxPoint last = Points->__get((int)0).StaticCast< ::flixel::math::FlxPoint >();
HXLINE(1089) ::flixel::math::FlxPoint node;
HXLINE(1090) int i = (int)1;
HXLINE(1091) int l = (Points->length - (int)1);
HXLINE(1093) while((i < l)){
HXLINE(1095) node = Points->__get(i).StaticCast< ::flixel::math::FlxPoint >();
HXLINE(1096) Float deltaPrevious1 = (node->x - last->x);
HXDLIN(1096) deltaPrevious = ((Float)deltaPrevious1 / (Float)(node->y - last->y));
HXLINE(1097) Float deltaNext1 = (node->x - Points->__get((i + (int)1)).StaticCast< ::flixel::math::FlxPoint >()->x);
HXDLIN(1097) deltaNext = ((Float)deltaNext1 / (Float)(node->y - Points->__get((i + (int)1)).StaticCast< ::flixel::math::FlxPoint >()->y));
HXLINE(1099) bool _hx_tmp;
HXDLIN(1099) bool _hx_tmp1;
HXDLIN(1099) if ((last->x != Points->__get((i + (int)1)).StaticCast< ::flixel::math::FlxPoint >()->x)) {
HXLINE(1099) _hx_tmp1 = (last->y == Points->__get((i + (int)1)).StaticCast< ::flixel::math::FlxPoint >()->y);
}
else {
HXLINE(1099) _hx_tmp1 = true;
}
HXDLIN(1099) if (!(_hx_tmp1)) {
HXLINE(1099) _hx_tmp = (deltaPrevious == deltaNext);
}
else {
HXLINE(1099) _hx_tmp = true;
}
HXDLIN(1099) if (_hx_tmp) {
HXLINE(1101) Points[i] = null();
}
else {
HXLINE(1105) last = node;
}
HXLINE(1108) i = (i + (int)1);
}
}
HX_DEFINE_DYNAMIC_FUNC1(FlxBaseTilemap_obj,simplifyPath,(void))
void FlxBaseTilemap_obj::raySimplifyPath(::Array< ::Dynamic> Points){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_1118_raySimplifyPath)
HXLINE(1119) ::flixel::math::FlxPoint source = Points->__get((int)0).StaticCast< ::flixel::math::FlxPoint >();
HXLINE(1120) int lastIndex = (int)-1;
HXLINE(1121) ::flixel::math::FlxPoint node;
HXLINE(1122) int i = (int)1;
HXLINE(1123) int l = Points->length;
HXLINE(1125) while((i < l)){
HXLINE(1127) i = (i + (int)1);
HXDLIN(1127) node = Points->__get((i - (int)1)).StaticCast< ::flixel::math::FlxPoint >();
HXLINE(1129) if (hx::IsNull( node )) {
HXLINE(1131) continue;
}
HXLINE(1134) if (this->ray(source,node,this->_point,null())) {
HXLINE(1136) if ((lastIndex >= (int)0)) {
HXLINE(1138) Points[lastIndex] = null();
}
}
else {
HXLINE(1143) source = Points->__get(lastIndex).StaticCast< ::flixel::math::FlxPoint >();
}
HXLINE(1146) lastIndex = (i - (int)1);
}
}
HX_DEFINE_DYNAMIC_FUNC1(FlxBaseTilemap_obj,raySimplifyPath,(void))
bool FlxBaseTilemap_obj::overlaps( ::flixel::FlxBasic ObjectOrGroup,hx::Null< bool > __o_InScreenSpace, ::flixel::FlxCamera Camera){
bool InScreenSpace = __o_InScreenSpace.Default(false);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_1162_overlaps)
HXLINE(1163) ::flixel::group::FlxTypedGroup group = ::flixel::group::FlxTypedGroup_obj::resolveGroup(ObjectOrGroup);
HXLINE(1164) if (hx::IsNotNull( group )) {
HXLINE(1166) return ::flixel::group::FlxTypedGroup_obj::overlaps(this->tilemapOverlapsCallback_dyn(),group,(int)0,(int)0,InScreenSpace,Camera);
}
else {
HXLINE(1168) Float X = (int)0;
HXDLIN(1168) Float Y = (int)0;
HXDLIN(1168) bool _hx_tmp;
HXDLIN(1168) bool _hx_tmp1;
HXDLIN(1168) if ((ObjectOrGroup->flixelType != (int)1)) {
HXLINE(1168) _hx_tmp1 = (ObjectOrGroup->flixelType == (int)3);
}
else {
HXLINE(1168) _hx_tmp1 = true;
}
HXDLIN(1168) if (_hx_tmp1) {
HXLINE(1168) _hx_tmp = this->overlapsWithCallback(( ( ::flixel::FlxObject)(ObjectOrGroup) ),null(),null(),null());
}
else {
HXLINE(1168) _hx_tmp = this->overlaps(ObjectOrGroup,false,null());
}
HXDLIN(1168) if (_hx_tmp) {
HXLINE(1170) return true;
}
}
HXLINE(1172) return false;
}
bool FlxBaseTilemap_obj::tilemapOverlapsCallback( ::flixel::FlxBasic ObjectOrGroup,hx::Null< Float > __o_X,hx::Null< Float > __o_Y,hx::Null< bool > __o_InScreenSpace, ::flixel::FlxCamera Camera){
Float X = __o_X.Default(0);
Float Y = __o_Y.Default(0);
bool InScreenSpace = __o_InScreenSpace.Default(false);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_1177_tilemapOverlapsCallback)
HXDLIN(1177) bool _hx_tmp;
HXDLIN(1177) if ((ObjectOrGroup->flixelType != (int)1)) {
HXDLIN(1177) _hx_tmp = (ObjectOrGroup->flixelType == (int)3);
}
else {
HXDLIN(1177) _hx_tmp = true;
}
HXDLIN(1177) if (_hx_tmp) {
HXLINE(1179) return this->overlapsWithCallback(( ( ::flixel::FlxObject)(ObjectOrGroup) ),null(),null(),null());
}
else {
HXLINE(1183) return this->overlaps(ObjectOrGroup,InScreenSpace,Camera);
}
HXLINE(1177) return false;
}
HX_DEFINE_DYNAMIC_FUNC5(FlxBaseTilemap_obj,tilemapOverlapsCallback,return )
bool FlxBaseTilemap_obj::overlapsAt(Float X,Float Y, ::flixel::FlxBasic ObjectOrGroup,hx::Null< bool > __o_InScreenSpace, ::flixel::FlxCamera Camera){
bool InScreenSpace = __o_InScreenSpace.Default(false);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_1201_overlapsAt)
HXLINE(1202) ::flixel::group::FlxTypedGroup group = ::flixel::group::FlxTypedGroup_obj::resolveGroup(ObjectOrGroup);
HXLINE(1203) if (hx::IsNotNull( group )) {
HXLINE(1205) return ::flixel::group::FlxTypedGroup_obj::overlaps(this->tilemapOverlapsAtCallback_dyn(),group,X,Y,InScreenSpace,Camera);
}
else {
HXLINE(1207) bool _hx_tmp;
HXDLIN(1207) bool _hx_tmp1;
HXDLIN(1207) if ((ObjectOrGroup->flixelType != (int)1)) {
HXLINE(1207) _hx_tmp1 = (ObjectOrGroup->flixelType == (int)3);
}
else {
HXLINE(1207) _hx_tmp1 = true;
}
HXDLIN(1207) if (_hx_tmp1) {
HXLINE(1207) _hx_tmp = this->overlapsWithCallback(( ( ::flixel::FlxObject)(ObjectOrGroup) ),null(),false,this->_point->set(X,Y));
}
else {
HXLINE(1207) _hx_tmp = this->overlapsAt(X,Y,ObjectOrGroup,InScreenSpace,Camera);
}
HXDLIN(1207) if (_hx_tmp) {
HXLINE(1209) return true;
}
}
HXLINE(1212) return false;
}
bool FlxBaseTilemap_obj::tilemapOverlapsAtCallback( ::flixel::FlxBasic ObjectOrGroup,Float X,Float Y,bool InScreenSpace, ::flixel::FlxCamera Camera){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_1217_tilemapOverlapsAtCallback)
HXDLIN(1217) bool _hx_tmp;
HXDLIN(1217) if ((ObjectOrGroup->flixelType != (int)1)) {
HXDLIN(1217) _hx_tmp = (ObjectOrGroup->flixelType == (int)3);
}
else {
HXDLIN(1217) _hx_tmp = true;
}
HXDLIN(1217) if (_hx_tmp) {
HXLINE(1219) return this->overlapsWithCallback(( ( ::flixel::FlxObject)(ObjectOrGroup) ),null(),false,this->_point->set(X,Y));
}
else {
HXLINE(1223) return this->overlapsAt(X,Y,ObjectOrGroup,InScreenSpace,Camera);
}
HXLINE(1217) return false;
}
HX_DEFINE_DYNAMIC_FUNC5(FlxBaseTilemap_obj,tilemapOverlapsAtCallback,return )
bool FlxBaseTilemap_obj::overlapsPoint( ::flixel::math::FlxPoint WorldPoint,hx::Null< bool > __o_InScreenSpace, ::flixel::FlxCamera Camera){
bool InScreenSpace = __o_InScreenSpace.Default(false);
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_1236_overlapsPoint)
HXLINE(1237) if (!(InScreenSpace)) {
HXLINE(1238) return this->tileAtPointAllowsCollisions(WorldPoint);
}
HXLINE(1240) if (hx::IsNull( Camera )) {
HXLINE(1241) Camera = ::flixel::FlxG_obj::camera;
}
HXLINE(1243) WorldPoint->subtractPoint(Camera->scroll);
HXLINE(1244) if (WorldPoint->_weak) {
HXLINE(1244) WorldPoint->put();
}
HXLINE(1245) return this->tileAtPointAllowsCollisions(WorldPoint);
}
bool FlxBaseTilemap_obj::tileAtPointAllowsCollisions( ::flixel::math::FlxPoint point){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_1249_tileAtPointAllowsCollisions)
HXLINE(1250) int tileIndex = this->getTileIndexByCoords(point);
HXLINE(1251) bool _hx_tmp;
HXDLIN(1251) if ((tileIndex >= (int)0)) {
HXLINE(1251) _hx_tmp = (tileIndex >= this->_data->length);
}
else {
HXLINE(1251) _hx_tmp = true;
}
HXDLIN(1251) if (_hx_tmp) {
HXLINE(1252) return false;
}
HXLINE(1253) ::cpp::VirtualArray _hx_tmp1 = this->_tileObjects;
HXDLIN(1253) return (( ( ::flixel::FlxObject)(_hx_tmp1->__get(this->_data->__get(tileIndex))) )->allowCollisions > (int)0);
}
HX_DEFINE_DYNAMIC_FUNC1(FlxBaseTilemap_obj,tileAtPointAllowsCollisions,return )
::flixel::math::FlxRect FlxBaseTilemap_obj::getBounds( ::flixel::math::FlxRect Bounds){
HX_STACKFRAME(&_hx_pos_36d94048d9e4941f_1263_getBounds)
HXLINE(1264) if (hx::IsNull( Bounds )) {
HXLINE(1265) ::flixel::math::FlxRect _this = ::flixel::math::FlxRect_obj::_pool->get();
HXDLIN(1265) _this->x = (int)0;
HXDLIN(1265) _this->y = (int)0;
HXDLIN(1265) _this->width = (int)0;
HXDLIN(1265) _this->height = (int)0;
HXDLIN(1265) ::flixel::math::FlxRect rect = _this;
HXDLIN(1265) rect->_inPool = false;
HXDLIN(1265) Bounds = rect;
}
HXLINE(1267) Float X = this->x;
HXDLIN(1267) Float Y = this->y;
HXDLIN(1267) Float Width = this->get_width();
HXDLIN(1267) Float Height = this->get_height();
HXDLIN(1267) Bounds->x = X;
HXDLIN(1267) Bounds->y = Y;
HXDLIN(1267) Bounds->width = Width;
HXDLIN(1267) Bounds->height = Height;
HXDLIN(1267) return Bounds;
}
HX_DEFINE_DYNAMIC_FUNC1(FlxBaseTilemap_obj,getBounds,return )
hx::ObjectPtr< FlxBaseTilemap_obj > FlxBaseTilemap_obj::__new() {
hx::ObjectPtr< FlxBaseTilemap_obj > __this = new FlxBaseTilemap_obj();
__this->__construct();
return __this;
}
hx::ObjectPtr< FlxBaseTilemap_obj > FlxBaseTilemap_obj::__alloc(hx::Ctx *_hx_ctx) {
FlxBaseTilemap_obj *__this = (FlxBaseTilemap_obj*)(hx::Ctx::alloc(_hx_ctx, sizeof(FlxBaseTilemap_obj), true, "flixel.tile.FlxBaseTilemap"));
*(void **)__this = FlxBaseTilemap_obj::_hx_vtable;
__this->__construct();
return __this;
}
FlxBaseTilemap_obj::FlxBaseTilemap_obj()
{
}
void FlxBaseTilemap_obj::__Mark(HX_MARK_PARAMS)
{
HX_MARK_BEGIN_CLASS(FlxBaseTilemap);
HX_MARK_MEMBER_NAME(_hx_auto,"auto");
HX_MARK_MEMBER_NAME(widthInTiles,"widthInTiles");
HX_MARK_MEMBER_NAME(heightInTiles,"heightInTiles");
HX_MARK_MEMBER_NAME(totalTiles,"totalTiles");
HX_MARK_MEMBER_NAME(customTileRemap,"customTileRemap");
HX_MARK_MEMBER_NAME(_randomIndices,"_randomIndices");
HX_MARK_MEMBER_NAME(_randomChoices,"_randomChoices");
HX_MARK_MEMBER_NAME(_randomLambda,"_randomLambda");
HX_MARK_MEMBER_NAME(_tileObjects,"_tileObjects");
HX_MARK_MEMBER_NAME(_startingIndex,"_startingIndex");
HX_MARK_MEMBER_NAME(_data,"_data");
HX_MARK_MEMBER_NAME(_drawIndex,"_drawIndex");
HX_MARK_MEMBER_NAME(_collideIndex,"_collideIndex");
::flixel::FlxObject_obj::__Mark(HX_MARK_ARG);
HX_MARK_END_CLASS();
}
void FlxBaseTilemap_obj::__Visit(HX_VISIT_PARAMS)
{
HX_VISIT_MEMBER_NAME(_hx_auto,"auto");
HX_VISIT_MEMBER_NAME(widthInTiles,"widthInTiles");
HX_VISIT_MEMBER_NAME(heightInTiles,"heightInTiles");
HX_VISIT_MEMBER_NAME(totalTiles,"totalTiles");
HX_VISIT_MEMBER_NAME(customTileRemap,"customTileRemap");
HX_VISIT_MEMBER_NAME(_randomIndices,"_randomIndices");
HX_VISIT_MEMBER_NAME(_randomChoices,"_randomChoices");
HX_VISIT_MEMBER_NAME(_randomLambda,"_randomLambda");
HX_VISIT_MEMBER_NAME(_tileObjects,"_tileObjects");
HX_VISIT_MEMBER_NAME(_startingIndex,"_startingIndex");
HX_VISIT_MEMBER_NAME(_data,"_data");
HX_VISIT_MEMBER_NAME(_drawIndex,"_drawIndex");
HX_VISIT_MEMBER_NAME(_collideIndex,"_collideIndex");
::flixel::FlxObject_obj::__Visit(HX_VISIT_ARG);
}
hx::Val FlxBaseTilemap_obj::__Field(const ::String &inName,hx::PropertyAccess inCallProp)
{
switch(inName.length) {
case 3:
if (HX_FIELD_EQ(inName,"ray") ) { return hx::Val( ray_dyn() ); }
break;
case 4:
if (HX_FIELD_EQ(inName,"auto") ) { return hx::Val( _hx_auto ); }
break;
case 5:
if (HX_FIELD_EQ(inName,"_data") ) { return hx::Val( _data ); }
break;
case 7:
if (HX_FIELD_EQ(inName,"destroy") ) { return hx::Val( destroy_dyn() ); }
if (HX_FIELD_EQ(inName,"getTile") ) { return hx::Val( getTile_dyn() ); }
if (HX_FIELD_EQ(inName,"setTile") ) { return hx::Val( setTile_dyn() ); }
if (HX_FIELD_EQ(inName,"getData") ) { return hx::Val( getData_dyn() ); }
break;
case 8:
if (HX_FIELD_EQ(inName,"setDirty") ) { return hx::Val( setDirty_dyn() ); }
if (HX_FIELD_EQ(inName,"autoTile") ) { return hx::Val( autoTile_dyn() ); }
if (HX_FIELD_EQ(inName,"findPath") ) { return hx::Val( findPath_dyn() ); }
if (HX_FIELD_EQ(inName,"walkPath") ) { return hx::Val( walkPath_dyn() ); }
if (HX_FIELD_EQ(inName,"overlaps") ) { return hx::Val( overlaps_dyn() ); }
break;
case 9:
if (HX_FIELD_EQ(inName,"updateMap") ) { return hx::Val( updateMap_dyn() ); }
if (HX_FIELD_EQ(inName,"getBounds") ) { return hx::Val( getBounds_dyn() ); }
break;
case 10:
if (HX_FIELD_EQ(inName,"totalTiles") ) { return hx::Val( totalTiles ); }
if (HX_FIELD_EQ(inName,"_drawIndex") ) { return hx::Val( _drawIndex ); }
if (HX_FIELD_EQ(inName,"updateTile") ) { return hx::Val( updateTile_dyn() ); }
if (HX_FIELD_EQ(inName,"overlapsAt") ) { return hx::Val( overlapsAt_dyn() ); }
break;
case 12:
if (HX_FIELD_EQ(inName,"widthInTiles") ) { return hx::Val( widthInTiles ); }
if (HX_FIELD_EQ(inName,"_tileObjects") ) { return hx::Val( _tileObjects ); }
if (HX_FIELD_EQ(inName,"simplifyPath") ) { return hx::Val( simplifyPath_dyn() ); }
break;
case 13:
if (HX_FIELD_EQ(inName,"heightInTiles") ) { return hx::Val( heightInTiles ); }
if (HX_FIELD_EQ(inName,"_randomLambda") ) { return hx::Val( _randomLambda ); }
if (HX_FIELD_EQ(inName,"_collideIndex") ) { return hx::Val( _collideIndex ); }
if (HX_FIELD_EQ(inName,"cacheGraphics") ) { return hx::Val( cacheGraphics_dyn() ); }
if (HX_FIELD_EQ(inName,"loadMapHelper") ) { return hx::Val( loadMapHelper_dyn() ); }
if (HX_FIELD_EQ(inName,"applyAutoTile") ) { return hx::Val( applyAutoTile_dyn() ); }
if (HX_FIELD_EQ(inName,"overlapsPoint") ) { return hx::Val( overlapsPoint_dyn() ); }
break;
case 14:
if (HX_FIELD_EQ(inName,"_randomIndices") ) { return hx::Val( _randomIndices ); }
if (HX_FIELD_EQ(inName,"_randomChoices") ) { return hx::Val( _randomChoices ); }
if (HX_FIELD_EQ(inName,"_startingIndex") ) { return hx::Val( _startingIndex ); }
if (HX_FIELD_EQ(inName,"loadMapFromCSV") ) { return hx::Val( loadMapFromCSV_dyn() ); }
if (HX_FIELD_EQ(inName,"getTileByIndex") ) { return hx::Val( getTileByIndex_dyn() ); }
if (HX_FIELD_EQ(inName,"setTileByIndex") ) { return hx::Val( setTileByIndex_dyn() ); }
break;
case 15:
if (HX_FIELD_EQ(inName,"customTileRemap") ) { return hx::Val( customTileRemap ); }
if (HX_FIELD_EQ(inName,"initTileObjects") ) { return hx::Val( initTileObjects_dyn() ); }
if (HX_FIELD_EQ(inName,"postGraphicLoad") ) { return hx::Val( postGraphicLoad_dyn() ); }
if (HX_FIELD_EQ(inName,"raySimplifyPath") ) { return hx::Val( raySimplifyPath_dyn() ); }
break;
case 16:
if (HX_FIELD_EQ(inName,"loadMapFromArray") ) { return hx::Val( loadMapFromArray_dyn() ); }
if (HX_FIELD_EQ(inName,"applyCustomRemap") ) { return hx::Val( applyCustomRemap_dyn() ); }
if (HX_FIELD_EQ(inName,"randomizeIndices") ) { return hx::Val( randomizeIndices_dyn() ); }
if (HX_FIELD_EQ(inName,"getTileInstances") ) { return hx::Val( getTileInstances_dyn() ); }
break;
case 17:
if (HX_FIELD_EQ(inName,"computeDimensions") ) { return hx::Val( computeDimensions_dyn() ); }
if (HX_FIELD_EQ(inName,"getTileCollisions") ) { return hx::Val( getTileCollisions_dyn() ); }
if (HX_FIELD_EQ(inName,"setTileProperties") ) { return hx::Val( setTileProperties_dyn() ); }
break;
case 18:
if (HX_FIELD_EQ(inName,"loadMapFrom2DArray") ) { return hx::Val( loadMapFrom2DArray_dyn() ); }
if (HX_FIELD_EQ(inName,"loadMapFromGraphic") ) { return hx::Val( loadMapFromGraphic_dyn() ); }
break;
case 19:
if (HX_FIELD_EQ(inName,"computePathDistance") ) { return hx::Val( computePathDistance_dyn() ); }
break;
case 20:
if (HX_FIELD_EQ(inName,"getTileIndexByCoords") ) { return hx::Val( getTileIndexByCoords_dyn() ); }
if (HX_FIELD_EQ(inName,"getTileCoordsByIndex") ) { return hx::Val( getTileCoordsByIndex_dyn() ); }
if (HX_FIELD_EQ(inName,"overlapsWithCallback") ) { return hx::Val( overlapsWithCallback_dyn() ); }
break;
case 21:
if (HX_FIELD_EQ(inName,"setCustomTileMappings") ) { return hx::Val( setCustomTileMappings_dyn() ); }
break;
case 23:
if (HX_FIELD_EQ(inName,"tilemapOverlapsCallback") ) { return hx::Val( tilemapOverlapsCallback_dyn() ); }
break;
case 25:
if (HX_FIELD_EQ(inName,"tilemapOverlapsAtCallback") ) { return hx::Val( tilemapOverlapsAtCallback_dyn() ); }
break;
case 27:
if (HX_FIELD_EQ(inName,"tileAtPointAllowsCollisions") ) { return hx::Val( tileAtPointAllowsCollisions_dyn() ); }
}
return super::__Field(inName,inCallProp);
}
hx::Val FlxBaseTilemap_obj::__SetField(const ::String &inName,const hx::Val &inValue,hx::PropertyAccess inCallProp)
{
switch(inName.length) {
case 4:
if (HX_FIELD_EQ(inName,"auto") ) { _hx_auto=inValue.Cast< ::flixel::tile::FlxTilemapAutoTiling >(); return inValue; }
break;
case 5:
if (HX_FIELD_EQ(inName,"_data") ) { _data=inValue.Cast< ::Array< int > >(); return inValue; }
break;
case 10:
if (HX_FIELD_EQ(inName,"totalTiles") ) { totalTiles=inValue.Cast< int >(); return inValue; }
if (HX_FIELD_EQ(inName,"_drawIndex") ) { _drawIndex=inValue.Cast< int >(); return inValue; }
break;
case 12:
if (HX_FIELD_EQ(inName,"widthInTiles") ) { widthInTiles=inValue.Cast< int >(); return inValue; }
if (HX_FIELD_EQ(inName,"_tileObjects") ) { _tileObjects=inValue.Cast< ::cpp::VirtualArray >(); return inValue; }
break;
case 13:
if (HX_FIELD_EQ(inName,"heightInTiles") ) { heightInTiles=inValue.Cast< int >(); return inValue; }
if (HX_FIELD_EQ(inName,"_randomLambda") ) { _randomLambda=inValue.Cast< ::Dynamic >(); return inValue; }
if (HX_FIELD_EQ(inName,"_collideIndex") ) { _collideIndex=inValue.Cast< int >(); return inValue; }
break;
case 14:
if (HX_FIELD_EQ(inName,"_randomIndices") ) { _randomIndices=inValue.Cast< ::Array< int > >(); return inValue; }
if (HX_FIELD_EQ(inName,"_randomChoices") ) { _randomChoices=inValue.Cast< ::Array< ::Dynamic> >(); return inValue; }
if (HX_FIELD_EQ(inName,"_startingIndex") ) { _startingIndex=inValue.Cast< int >(); return inValue; }
break;
case 15:
if (HX_FIELD_EQ(inName,"customTileRemap") ) { customTileRemap=inValue.Cast< ::Array< int > >(); return inValue; }
}
return super::__SetField(inName,inValue,inCallProp);
}
void FlxBaseTilemap_obj::__GetFields(Array< ::String> &outFields)
{
outFields->push(HX_HCSTRING("auto","\x6f","\xdf","\x76","\x40"));
outFields->push(HX_HCSTRING("widthInTiles","\xfa","\xb1","\x71","\xd4"));
outFields->push(HX_HCSTRING("heightInTiles","\x39","\xce","\x1a","\x97"));
outFields->push(HX_HCSTRING("totalTiles","\x21","\xf3","\xd5","\x16"));
outFields->push(HX_HCSTRING("customTileRemap","\xca","\x70","\xd3","\x8a"));
outFields->push(HX_HCSTRING("_randomIndices","\xa5","\xd3","\x07","\x36"));
outFields->push(HX_HCSTRING("_randomChoices","\x70","\x42","\xcb","\x2b"));
outFields->push(HX_HCSTRING("_tileObjects","\x47","\x55","\xbd","\x87"));
outFields->push(HX_HCSTRING("_startingIndex","\x73","\xa1","\x49","\x3d"));
outFields->push(HX_HCSTRING("_data","\x09","\x72","\x74","\xf5"));
outFields->push(HX_HCSTRING("_drawIndex","\x2f","\x4c","\xc2","\xe1"));
outFields->push(HX_HCSTRING("_collideIndex","\x93","\x05","\x8a","\xb4"));
super::__GetFields(outFields);
};
#if HXCPP_SCRIPTABLE
static hx::StorageInfo FlxBaseTilemap_obj_sMemberStorageInfo[] = {
{hx::fsObject /*::flixel::tile::FlxTilemapAutoTiling*/ ,(int)offsetof(FlxBaseTilemap_obj,_hx_auto),HX_HCSTRING("auto","\x6f","\xdf","\x76","\x40")},
{hx::fsInt,(int)offsetof(FlxBaseTilemap_obj,widthInTiles),HX_HCSTRING("widthInTiles","\xfa","\xb1","\x71","\xd4")},
{hx::fsInt,(int)offsetof(FlxBaseTilemap_obj,heightInTiles),HX_HCSTRING("heightInTiles","\x39","\xce","\x1a","\x97")},
{hx::fsInt,(int)offsetof(FlxBaseTilemap_obj,totalTiles),HX_HCSTRING("totalTiles","\x21","\xf3","\xd5","\x16")},
{hx::fsObject /*Array< int >*/ ,(int)offsetof(FlxBaseTilemap_obj,customTileRemap),HX_HCSTRING("customTileRemap","\xca","\x70","\xd3","\x8a")},
{hx::fsObject /*Array< int >*/ ,(int)offsetof(FlxBaseTilemap_obj,_randomIndices),HX_HCSTRING("_randomIndices","\xa5","\xd3","\x07","\x36")},
{hx::fsObject /*Array< ::Dynamic >*/ ,(int)offsetof(FlxBaseTilemap_obj,_randomChoices),HX_HCSTRING("_randomChoices","\x70","\x42","\xcb","\x2b")},
{hx::fsObject /*Dynamic*/ ,(int)offsetof(FlxBaseTilemap_obj,_randomLambda),HX_HCSTRING("_randomLambda","\x49","\x40","\x18","\x0b")},
{hx::fsObject /*cpp::ArrayBase*/ ,(int)offsetof(FlxBaseTilemap_obj,_tileObjects),HX_HCSTRING("_tileObjects","\x47","\x55","\xbd","\x87")},
{hx::fsInt,(int)offsetof(FlxBaseTilemap_obj,_startingIndex),HX_HCSTRING("_startingIndex","\x73","\xa1","\x49","\x3d")},
{hx::fsObject /*Array< int >*/ ,(int)offsetof(FlxBaseTilemap_obj,_data),HX_HCSTRING("_data","\x09","\x72","\x74","\xf5")},
{hx::fsInt,(int)offsetof(FlxBaseTilemap_obj,_drawIndex),HX_HCSTRING("_drawIndex","\x2f","\x4c","\xc2","\xe1")},
{hx::fsInt,(int)offsetof(FlxBaseTilemap_obj,_collideIndex),HX_HCSTRING("_collideIndex","\x93","\x05","\x8a","\xb4")},
{ hx::fsUnknown, 0, null()}
};
static hx::StaticInfo *FlxBaseTilemap_obj_sStaticStorageInfo = 0;
#endif
static ::String FlxBaseTilemap_obj_sMemberFields[] = {
HX_HCSTRING("auto","\x6f","\xdf","\x76","\x40"),
HX_HCSTRING("widthInTiles","\xfa","\xb1","\x71","\xd4"),
HX_HCSTRING("heightInTiles","\x39","\xce","\x1a","\x97"),
HX_HCSTRING("totalTiles","\x21","\xf3","\xd5","\x16"),
HX_HCSTRING("customTileRemap","\xca","\x70","\xd3","\x8a"),
HX_HCSTRING("_randomIndices","\xa5","\xd3","\x07","\x36"),
HX_HCSTRING("_randomChoices","\x70","\x42","\xcb","\x2b"),
HX_HCSTRING("_randomLambda","\x49","\x40","\x18","\x0b"),
HX_HCSTRING("_tileObjects","\x47","\x55","\xbd","\x87"),
HX_HCSTRING("_startingIndex","\x73","\xa1","\x49","\x3d"),
HX_HCSTRING("_data","\x09","\x72","\x74","\xf5"),
HX_HCSTRING("_drawIndex","\x2f","\x4c","\xc2","\xe1"),
HX_HCSTRING("_collideIndex","\x93","\x05","\x8a","\xb4"),
HX_HCSTRING("updateTile","\xd7","\xb5","\xb1","\x05"),
HX_HCSTRING("cacheGraphics","\x2d","\x61","\x95","\xfc"),
HX_HCSTRING("initTileObjects","\x16","\xbe","\x45","\x2e"),
HX_HCSTRING("updateMap","\x13","\xe8","\xdf","\x82"),
HX_HCSTRING("computeDimensions","\xa4","\xa4","\xeb","\xf3"),
HX_HCSTRING("getTileIndexByCoords","\x03","\x79","\x8b","\x76"),
HX_HCSTRING("getTileCoordsByIndex","\xb9","\x63","\x25","\xa1"),
HX_HCSTRING("ray","\xea","\xd5","\x56","\x00"),
HX_HCSTRING("overlapsWithCallback","\x17","\xc3","\x72","\xa8"),
HX_HCSTRING("setDirty","\x10","\xb9","\x04","\xe8"),
HX_HCSTRING("destroy","\xfa","\x2c","\x86","\x24"),
HX_HCSTRING("loadMapFromCSV","\x06","\x2b","\x38","\x8f"),
HX_HCSTRING("loadMapFromArray","\xd9","\x80","\xa3","\xdb"),
HX_HCSTRING("loadMapFrom2DArray","\xc7","\xd3","\x90","\xac"),
HX_HCSTRING("loadMapFromGraphic","\xe8","\xbd","\xb6","\xe5"),
HX_HCSTRING("loadMapHelper","\x24","\xaa","\x93","\x69"),
HX_HCSTRING("postGraphicLoad","\x6e","\x44","\x44","\x1d"),
HX_HCSTRING("applyAutoTile","\xcb","\x19","\x58","\x70"),
HX_HCSTRING("applyCustomRemap","\x8a","\x6c","\x0c","\xb4"),
HX_HCSTRING("randomizeIndices","\xf6","\x8d","\x4c","\x14"),
HX_HCSTRING("autoTile","\x3d","\xba","\x22","\x30"),
HX_HCSTRING("setCustomTileMappings","\x86","\x00","\x11","\x09"),
HX_HCSTRING("getTile","\xe4","\x7a","\x7f","\x1f"),
HX_HCSTRING("getTileByIndex","\x37","\xbb","\xaa","\xc4"),
HX_HCSTRING("getTileCollisions","\xc5","\x3f","\x3d","\xc8"),
HX_HCSTRING("getTileInstances","\xba","\x6b","\x01","\x25"),
HX_HCSTRING("setTile","\xf0","\x0b","\x81","\x12"),
HX_HCSTRING("setTileByIndex","\xab","\xa3","\xca","\xe4"),
HX_HCSTRING("setTileProperties","\x03","\x58","\xa1","\x54"),
HX_HCSTRING("getData","\xe0","\x05","\xe6","\x14"),
HX_HCSTRING("findPath","\x7e","\xf2","\xe5","\x9c"),
HX_HCSTRING("computePathDistance","\x11","\x4c","\x56","\x20"),
HX_HCSTRING("walkPath","\x4e","\x27","\xab","\x57"),
HX_HCSTRING("simplifyPath","\x4e","\x21","\x2f","\x66"),
HX_HCSTRING("raySimplifyPath","\x58","\x7a","\xf6","\x41"),
HX_HCSTRING("overlaps","\x0c","\xd3","\x2a","\x45"),
HX_HCSTRING("tilemapOverlapsCallback","\x3f","\x9d","\xf8","\xac"),
HX_HCSTRING("overlapsAt","\x1f","\xe7","\xce","\x03"),
HX_HCSTRING("tilemapOverlapsAtCallback","\xd2","\xab","\x68","\xdb"),
HX_HCSTRING("overlapsPoint","\xa4","\xc5","\xbd","\x35"),
HX_HCSTRING("tileAtPointAllowsCollisions","\x1a","\x5b","\x2f","\xf6"),
HX_HCSTRING("getBounds","\xab","\x0f","\x74","\xe2"),
::String(null()) };
static void FlxBaseTilemap_obj_sMarkStatics(HX_MARK_PARAMS) {
HX_MARK_MEMBER_NAME(FlxBaseTilemap_obj::__mClass,"__mClass");
};
#ifdef HXCPP_VISIT_ALLOCS
static void FlxBaseTilemap_obj_sVisitStatics(HX_VISIT_PARAMS) {
HX_VISIT_MEMBER_NAME(FlxBaseTilemap_obj::__mClass,"__mClass");
};
#endif
hx::Class FlxBaseTilemap_obj::__mClass;
void FlxBaseTilemap_obj::__register()
{
hx::Object *dummy = new FlxBaseTilemap_obj;
FlxBaseTilemap_obj::_hx_vtable = *(void **)dummy;
hx::Static(__mClass) = new hx::Class_obj();
__mClass->mName = HX_HCSTRING("flixel.tile.FlxBaseTilemap","\x19","\xd7","\xa6","\x6a");
__mClass->mSuper = &super::__SGetClass();
__mClass->mConstructEmpty = &__CreateEmpty;
__mClass->mConstructArgs = &__Create;
__mClass->mGetStaticField = &hx::Class_obj::GetNoStaticField;
__mClass->mSetStaticField = &hx::Class_obj::SetNoStaticField;
__mClass->mMarkFunc = FlxBaseTilemap_obj_sMarkStatics;
__mClass->mStatics = hx::Class_obj::dupFunctions(0 /* sStaticFields */);
__mClass->mMembers = hx::Class_obj::dupFunctions(FlxBaseTilemap_obj_sMemberFields);
__mClass->mCanCast = hx::TCanCast< FlxBaseTilemap_obj >;
#ifdef HXCPP_VISIT_ALLOCS
__mClass->mVisitFunc = FlxBaseTilemap_obj_sVisitStatics;
#endif
#ifdef HXCPP_SCRIPTABLE
__mClass->mMemberStorageInfo = FlxBaseTilemap_obj_sMemberStorageInfo;
#endif
#ifdef HXCPP_SCRIPTABLE
__mClass->mStaticStorageInfo = FlxBaseTilemap_obj_sStaticStorageInfo;
#endif
hx::_hx_RegisterClass(__mClass->mName, __mClass);
}
} // end namespace flixel
} // end namespace tile
| [
"jwat445@gmail.com"
] | jwat445@gmail.com |
8c89e2908f81e6c6b2061001aabd176cb25c6dff | 477c8309420eb102b8073ce067d8df0afc5a79b1 | /Plugins/SQToolkit/IntersectionSetColorMapper.h | 46921b20b1334d01c6be430c27259eca2d8b370e | [
"LicenseRef-scancode-paraview-1.2"
] | permissive | aashish24/paraview-climate-3.11.1 | e0058124e9492b7adfcb70fa2a8c96419297fbe6 | c8ea429f56c10059dfa4450238b8f5bac3208d3a | refs/heads/uvcdat-master | 2021-07-03T11:16:20.129505 | 2013-05-10T13:14:30 | 2013-05-10T13:14:30 | 4,238,077 | 1 | 0 | NOASSERTION | 2020-10-12T21:28:23 | 2012-05-06T02:32:44 | C++ | UTF-8 | C++ | false | false | 6,145 | h | /*
____ _ __ ____ __ ____
/ __/___(_) / ___ ____/ __ \__ _____ ___ / /_ / _/__ ____
_\ \/ __/ / _ \/ -_) __/ /_/ / // / -_|_-</ __/ _/ // _ \/ __/
/___/\__/_/_.__/\__/_/ \___\_\_,_/\__/___/\__/ /___/_//_/\__(_)
Copyright 2008 SciberQuest Inc.
*/
#ifndef IntersectionSetColorMapper_h
#define IntersectionSetColorMapper_h
#include "IntersectionSet.h"
#include <vector>
using std::vector;
#include<iostream>
using std::cerr;
using std::endl;
#include<string>
using std::string;
#include<sstream>
using std::ostringstream;
#include "vtkIntArray.h"
#include "minmax.h"
/**
/// Class that manages color assignement operation for insterection sets.
Class that manages color assignement operation for insterection sets. This class
assigns an intersection based on the intersection set surface ids and the number of
surfaces. Two sets, S1 and S2, are equivalent (and tehrefor are assigned the same
color) when S1=(a b) and S2=(b a).
*/
class IntersectionSetColorMapper
{
public:
/// Construct in an invalid state.
IntersectionSetColorMapper() : NSurfaces(0) {};
/// Copy construct.
IntersectionSetColorMapper(const IntersectionSetColorMapper &other){
*this=other;
}
/// Assignment.
const IntersectionSetColorMapper &operator=(const IntersectionSetColorMapper &other){
if (this!=&other)
{
this->NSurfaces=other.NSurfaces;
this->Colors=other.Colors;
}
return *this;
}
/// Set the number of surfaces, this allocates space for the colors.
/// and appropriately initializes them.
void SetNumberOfSurfaces(int nSurfaces){
this->BuildColorMap(nSurfaces);
}
/// Allocates space for the color map and appropriately initializes
/// them as a function of surface pairs. A legend is also generated
/// if a the surfaceName vector is provided these are used in the
/// legend.
void BuildColorMap(int nSurfaces){
vector<string> names(nSurfaces);
for (int i=0; i<nSurfaces; ++i)
{
ostringstream os;
os << i;
names[i]=os.str();
}
this->BuildColorMap(nSurfaces,names);
}
void BuildColorMap(int nSurfaces, vector<string> &names){
// Store the color values in the upper triangle of a nxn matrix.
// Note that we only need n=sum_{i=1}^{n+1}i colors, but using the
// matrix sinmplifies look ups.
this->NSurfaces=nSurfaces;
const int nColors=(nSurfaces+1)*(nSurfaces+1);
this->Colors.clear();
this->Colors.resize(nColors,-1);
this->ColorsUsed.resize(nColors,0);
this->ColorLegend.resize(nColors);
int color=0;
for (int j=0; j<nSurfaces+1; ++j)
{
for (int i=j; i<nSurfaces+1; ++i)
{
// set the color entry
int x=max(i,j);
int y=min(i,j);
int idx=x+(nSurfaces+1)*y;
this->Colors[idx]=color;
++color;
// set its legend entry
ostringstream os;
os << "(" << names[x] << ", " << names[y] << ")";
this->ColorLegend[idx]=os.str();
}
}
}
/// Get color associated with an intersection set.
int LookupColor(const IntersectionSet &iset){
int s1=iset.GetForwardIntersectionId()+1;
int s2=iset.GetBackwardIntersectionId()+1;
return this->LookupColor(s1,s2);
}
/// Get color associated with 2 surfaces.
int LookupColor(const int s1, const int s2){
int x=max(s1,s2);
int y=min(s1,s2);
int idx=x+(this->NSurfaces+1)*y;
this->ColorsUsed[idx]=1;
return this->Colors[idx];
}
/// reduce the number of colors to those which are used.
void SqueezeColorMap(vtkIntArray *scalar){
int procId=0;
MPI_Comm_rank(MPI_COMM_WORLD,&procId);
// Walk the color map, for any used color replace it with
// the number of colors used thus far. This will reduce
// the color map to only the used colors.
vtkIdType nCells=scalar->GetNumberOfTuples();
int *pScalar=scalar->GetPointer(0);
int nUsed=0;
for (int j=0; j<this->NSurfaces+1; ++j)
{
for (int i=j; i<this->NSurfaces+1; ++i)
{
int x=max(i,j);
int y=min(i,j);
int idx=x+(this->NSurfaces+1)*y;
int color=this->Colors[idx];
int colorUsed=0;
MPI_Allreduce(&this->ColorsUsed[idx],&colorUsed,1,MPI_INT,MPI_SUM,MPI_COMM_WORLD);
if (colorUsed)
{
// print the lengend.
if (procId==0)
{
cerr << this->ColorLegend[idx] << "->" << nUsed << endl;
}
for (vtkIdType q=0; q<nCells; ++q)
{
// search and replace the old value with the new.
if (pScalar[q]==color)
{
pScalar[q]=nUsed;
}
}
// next new color.
++nUsed;
}
}
}
}
/// Process 0 send the used colors in the color map to the terminal.
void PrintUsed(){
int procId=0;
MPI_Comm_rank(MPI_COMM_WORLD,&procId);
for (int j=0; j<this->NSurfaces+1; ++j)
{
for (int i=j; i<this->NSurfaces+1; ++i)
{
int x=max(i,j);
int y=min(i,j);
int idx=x+(this->NSurfaces+1)*y;
int colorUsed=0;
MPI_Allreduce(&this->ColorsUsed[idx],&colorUsed,1,MPI_INT,MPI_SUM,MPI_COMM_WORLD);
if (colorUsed)
{
// print the lengend.
if (procId==0)
{
cerr << this->ColorLegend[idx] << "->" << this->Colors[idx] << endl;
}
}
}
}
}
/// Process 0 send the color map to the terminal.
void PrintAll()
{
int procId=0;
MPI_Comm_rank(MPI_COMM_WORLD,&procId);
if (procId!=0)
{
return;
}
for (int j=0; j<this->NSurfaces+1; ++j)
{
for (int i=j; i<this->NSurfaces+1; ++i)
{
int x=max(i,j);
int y=min(i,j);
int idx=x+(this->NSurfaces+1)*y;
// print the lengend.
cerr << this->ColorLegend[idx] << "->" << this->Colors[idx] << endl;
}
}
}
private:
int NSurfaces;
vector<int> Colors;
vector<int> ColorsUsed;
vector<string> ColorLegend;
};
#endif
| [
"aashish.chaudhary@kitware.com"
] | aashish.chaudhary@kitware.com |
c0e4c25d76c953313929e78cf3302d6e845c4679 | be5d88e25f246ce63638f326744408178a1419a5 | /FEZ_07_09/button_tutorial.h | 48b79e4d02dd0b1e83d1899d2863a8c5a367d3a4 | [] | no_license | himiya56/FEZ_0709 | 3dce8fe8152981cd05eb65455bf8cdf23e64a00b | 2f21d510c140943c934cda90b06cad7d5a9c62a0 | refs/heads/master | 2023-08-14T16:50:30.294473 | 2021-09-07T09:56:05 | 2021-09-07T09:56:05 | 385,079,280 | 0 | 0 | null | 2021-09-07T09:56:12 | 2021-07-12T00:14:53 | C++ | SHIFT_JIS | C++ | false | false | 1,470 | h | //=============================================================================
//
// チュートリアルボタン [button_tutorial.h]
// Author : 二階堂汰一
//
//=============================================================================
#ifndef _BUTTON_TUTORIAL_H_
#define _BUTTON_TUTORIAL_H_
//*****************************************************************************
// ヘッダファイルのインクルード
//*****************************************************************************
#include "button.h"
//*****************************************************************************
// マクロ定義
//*****************************************************************************
//*****************************************************************************
// 前方宣言
//*****************************************************************************
//*****************************************************************************
// クラス定義
//*****************************************************************************
class CTutorialButton :public CButton
{
public:
CTutorialButton();
~CTutorialButton();
static HRESULT TextureLoad(void);
static void TextureUnload(void);
static CTutorialButton * Create(D3DXVECTOR3 Position);
HRESULT Init(void);
void Uninit(void);
void Update(void);
void Draw(void);
void Press(void);
private:
static LPDIRECT3DTEXTURE9 m_pTexture; //テクスチャのポインタ
};
#endif | [
"himisho56@gmail.com"
] | himisho56@gmail.com |
0538e5c8fcb7aa91ba54d3445d4fcb05c9bb493c | 52507f7928ba44b7266eddf0f1a9bf6fae7322a4 | /SDK/BP_InformationDialog_classes.h | aa1f3a4647a9c7f1b4b76908227ce5492cff9819 | [] | no_license | LuaFan2/mordhau-sdk | 7268c9c65745b7af511429cfd3bf16aa109bc20c | ab10ad70bc80512e51a0319c2f9b5effddd47249 | refs/heads/master | 2022-11-30T08:14:30.825803 | 2020-08-13T16:31:27 | 2020-08-13T16:31:27 | 287,329,560 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,855 | h | #pragma once
// Name: Mordhau, Version: 1.0.0
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
namespace SDK
{
//---------------------------------------------------------------------------
// Classes
//---------------------------------------------------------------------------
// WidgetBlueprintGeneratedClass BP_InformationDialog.BP_InformationDialog_C
// 0x0040 (0x0248 - 0x0208)
class UBP_InformationDialog_C : public UMordhauDialog
{
public:
struct FPointerToUberGraphFrame UberGraphFrame; // 0x0208(0x0008) (Transient, DuplicateTransient)
class UBP_OneButtonDialog_C* BP_OneButtonDialog; // 0x0210(0x0008) (BlueprintVisible, ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
class UTextBlock* TextBlock_1; // 0x0218(0x0008) (ExportObject, ZeroConstructor, InstancedReference, IsPlainOldData, RepSkip, RepNotify, Interp, NonTransactional, EditorOnly, NoDestructor, AutoWeak, ContainsInstancedReference, AssetRegistrySearchable, SimpleDisplay, AdvancedDisplay, Protected, BlueprintCallable, BlueprintAuthorityOnly, TextExportTransient, NonPIEDuplicateTransient, ExposeOnSpawn, PersistentInstance, UObjectWrapper, HasGetValueTypeHash, NativeAccessSpecifierPublic, NativeAccessSpecifierProtected, NativeAccessSpecifierPrivate)
struct FText InfoText; // 0x0220(0x0018) (Edit, BlueprintVisible, DisableEditOnInstance)
struct FScriptMulticastDelegate ButtonClicked; // 0x0238(0x0010) (Edit, BlueprintVisible, ZeroConstructor, DisableEditOnInstance, BlueprintAssignable)
static UClass* StaticClass()
{
static auto ptr = UObject::FindClass("WidgetBlueprintGeneratedClass BP_InformationDialog.BP_InformationDialog_C");
return ptr;
}
void SetButtonText(const struct FText& ButtonText);
void SetTitleText(const struct FText& TitleText);
struct FText GetInfoText();
void BndEvt__BP_OneButtonDialog_K2Node_ComponentBoundEvent_14_ButtonClicked__DelegateSignature();
void Show();
void Hide();
void ExecuteUbergraph_BP_InformationDialog(int EntryPoint);
void ButtonClicked__DelegateSignature();
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"51294434+LuaFan2@users.noreply.github.com"
] | 51294434+LuaFan2@users.noreply.github.com |
bc272f76c58e649019baef90c94eb1407ee24241 | 7e1107c4995489a26c4007e41b53ea8d00ab2134 | /game/code/data/memcard/allmemcard.cpp | 62071e4263c962dcad7ec45914b2277a307910fa | [] | no_license | Svxy/The-Simpsons-Hit-and-Run | 83837eb2bfb79d5ddb008346313aad42cd39f10d | eb4b3404aa00220d659e532151dab13d642c17a3 | refs/heads/main | 2023-07-14T07:19:13.324803 | 2023-05-31T21:31:32 | 2023-05-31T21:31:32 | 647,840,572 | 591 | 45 | null | null | null | null | UTF-8 | C++ | false | false | 46 | cpp | #include <data/memcard/memorycardmanager.cpp>
| [
"aidan61605@gmail.com"
] | aidan61605@gmail.com |
86bf88d6069e93752fe2f029a1ed2c69e6c4c408 | c920079b644668fcea120937ec7bec392d2029bd | /B4---C++-Programming/cpp_bomberman/include/Tuto.hpp | b0102929a3a3c566631ad61a52293a321690f260 | [] | no_license | Ankirama/Epitech | d23fc8912d19ef657b925496ce0ffcc58dc51d3b | 3690ab3ec0c8325edee1802b6b0ce6952e3ae182 | refs/heads/master | 2021-01-19T08:11:27.374033 | 2018-01-03T10:06:20 | 2018-01-03T10:06:20 | 105,794,978 | 0 | 5 | null | null | null | null | UTF-8 | C++ | false | false | 972 | hpp | # include "GameEngine.hh"
class AObject {
public:
AObject():
_position(0,0,0),
_rotation(0,0,0),
_scale(1,1,1) {
}
virtual ~AObject()
{}
virtual bool initialize(){
return (true);
}
virtual void update (gdl::Clock const &, gdl::Input &){
}
virtual void draw (gdl::AShader &shader, gdl::Clock const &clock) = 0;
void translate(glm::vec3 const &v) {
_position += v;
}
void rotate(glm::vec3 const &axis, float angle){
_rotation += axis * angle;
}
void scale(glm::vec3 const & scale){
_scale *= scale;
}
glm::mat4 getTransformation(){
glm::mat4 tranform(1);
tranform = glm::rotate(tranform, _rotation.y, glm::vec3(0, 1, 0));
tranform = glm::rotate(tranform, _rotation.z, glm::vec3(0, 0, 1));
tranform = glm::translate(tranform, _position);
tranform = glm::scale(tranform, _scale);
return (tranform);
}
protected:
glm::vec3 _position;
glm::vec3 _rotation;
glm::vec3 _scale;
};
| [
"fabien.martinez@epitech.eu"
] | fabien.martinez@epitech.eu |
5159a241076c33bcd712deaec3e2194f7cb7955a | 882a20fdf88ec1598b1e0031c2f21f521fbbb3f6 | /duff2/Source/MarkerFileLocationForm.h | 6c84f52ac92fcd1f460b68a8a6e689deafb54e35 | [] | no_license | presscad/duff | 39fb6db6884c0e46f7b2862842334915ec17375e | eabfd1aa440883cbd5fd172aa9c10e2b6902d068 | refs/heads/master | 2021-04-17T09:16:21.042836 | 2012-01-30T22:42:40 | 2012-01-30T22:42:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,413 | h | #if !defined(AFX_FILELOCATIONMARKERFORM_H__EDDDC4CE_68BB_4BCA_AE70_2A7B47E75270__INCLUDED_)
#define AFX_FILELOCATIONMARKERFORM_H__EDDDC4CE_68BB_4BCA_AE70_2A7B47E75270__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// FileLocationMarkerForm.h : header file
//
#include "FilenameEdit.h"
/////////////////////////////////////////////////////////////////////////////
// CFileLocationMarkerForm dialog
class CFileLocationMarkerForm : public CDialog
{
// Construction
public:
CFileLocationMarkerForm(CWnd* pParent = NULL); // standard constructor
// Dialog Data
//{{AFX_DATA(CFileLocationMarkerForm)
enum { IDD = IDD_FILE_LOCATION_MARKER_FORM };
CFilenameEdit m_Path;
CButton m_SubDirs;
//}}AFX_DATA
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CFileLocationMarkerForm)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
//}}AFX_VIRTUAL
// Implementation
protected:
// Generated message map functions
//{{AFX_MSG(CFileLocationMarkerForm)
virtual BOOL OnInitDialog();
afx_msg void OnBrowse();
virtual void OnOK();
virtual void OnCancel();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_FILELOCATIONMARKERFORM_H__EDDDC4CE_68BB_4BCA_AE70_2A7B47E75270__INCLUDED_)
| [
"ger@hobbelt.com"
] | ger@hobbelt.com |
c3516d262bc154390d781c2d3b59f205bc450bb4 | 136e369ec44e329567e305bcc13400592b203c11 | /kaue/tc/520/WhichDay.cpp | 2e80c47aea0fa61d3ec51ac6f6b79f8b90e2b850 | [] | no_license | kssilveira/mara | 8ea9a544aba232297c8cb3a5e25e07aaf6434b1f | 4deb0a8bfecae7408b0d6e561e4c7fb154c9ff2a | refs/heads/master | 2021-01-23T05:39:20.554801 | 2012-06-19T22:39:00 | 2012-06-19T22:39:00 | 2,374,687 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,829 | cpp | #include <algorithm>
#include <bitset>
#include <cassert>
#include <cctype>
#include <cfloat>
#include <climits>
#include <cmath>
#include <cstdio>
#include <cstdlib>
#include <cstring>
#include <ctime>
#include <deque>
#include <functional>
#include <iostream>
#include <limits>
#include <list>
#include <map>
#include <queue>
#include <set>
#include <sstream>
#include <stack>
#include <streambuf>
#include <string>
#include <utility>
#include <vector>
#define r(i, n) rb(i, 0, n)
#define rb(i, b, n) rbc(i, b, n, <)
#define re(i, n) rbe(i, 0, n)
#define rbe(i, b, n) rbc(i, b, n, <=)
#define rbc(i, b, n, c) for(int i = (b); i c ((int)(n)); i++)
#define ri r(i, n)
#define rj r(j, n)
#define rk r(k, n)
#define rim r(i, m)
#define rjm r(j, m)
#define rkm r(k, m)
#define s(v) ((int) v.size())
using namespace std;
class WhichDay {
public:
string getDay(vector <string> notOnThisDay) {
string res;
return "Monday";
}
// BEGIN CUT HERE
public:
void run_test(int Case) { if ((Case == -1) || (Case == 0)) test_case_0(); if ((Case == -1) || (Case == 1)) test_case_1(); if ((Case == -1) || (Case == 2)) test_case_2(); if ((Case == -1) || (Case == 3)) test_case_3(); }
private:
template <typename T> string print_array(const vector<T> &V) { ostringstream os; os << "{ "; for (typename vector<T>::const_iterator iter = V.begin(); iter != V.end(); ++iter) os << '\"' << *iter << "\","; os << " }"; return os.str(); }
void verify_case(int Case, const string &Expected, const string &Received) { cerr << "Test Case #" << Case << "..."; if (Expected == Received) cerr << "PASSED" << endl; else { cerr << "FAILED" << endl; cerr << "\tExpected: \"" << Expected << '\"' << endl; cerr << "\tReceived: \"" << Received << '\"' << endl; } }
void test_case_0() { string Arr0[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Thursday", "Friday"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "Saturday"; verify_case(0, Arg1, getDay(Arg0)); }
void test_case_1() { string Arr0[] = {"Sunday", "Monday", "Tuesday", "Wednesday", "Friday", "Thursday"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "Saturday"; verify_case(1, Arg1, getDay(Arg0)); }
void test_case_2() { string Arr0[] = {"Sunday", "Monday", "Tuesday", "Thursday", "Friday", "Saturday"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "Wednesday"; verify_case(2, Arg1, getDay(Arg0)); }
void test_case_3() { string Arr0[] = {"Sunday", "Friday", "Tuesday", "Wednesday", "Monday", "Saturday"}; vector <string> Arg0(Arr0, Arr0 + (sizeof(Arr0) / sizeof(Arr0[0]))); string Arg1 = "Thursday"; verify_case(3, Arg1, getDay(Arg0)); }
// END CUT HERE
};
// BEGIN CUT HERE
int main()
{
WhichDay ___test;
___test.run_test(-1);
}
// END CUT HERE
| [
"silveira.kaue@gmail.com"
] | silveira.kaue@gmail.com |
e93e9b41ad738c6d9496df320ff0c0d28c70a057 | f0085b9eabab3e19e5af59363520b0dc87e23dc4 | /src/divide-sweep.cpp | fd91a14c8993d01a8b9961b750d703d16c476abd | [] | no_license | privefl/inplace | b85956a928898d624b5689330ddb15f0f01b59cd | 54479172e0e0fef0b98b1fb0c66dd69d89f2d33d | refs/heads/master | 2021-07-01T01:58:04.712284 | 2020-08-24T12:08:27 | 2020-08-24T12:08:27 | 135,786,310 | 9 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,953 | cpp | /******************************************************************************/
#include <accessors.h>
/******************************************************************************/
#define ON_MAT_ROW(RTYPE, CTYPE) { \
Matrix<RTYPE> x2(x); \
Vector<RTYPE> val2(val); \
divide_mat1_mult(x2, val2); \
break; \
}
#define ON_MAT_COL(RTYPE, CTYPE) { \
Matrix<RTYPE> x2(x); \
Vector<RTYPE> val2(val); \
divide_mat2_mult(x2, val2); \
break; \
}
/******************************************************************************/
template <int RTYPE>
void divide_mat1_mult(Matrix<RTYPE>& x, const Vector<RTYPE>& val) {
myassert(x.nrow() == val.size(), ERROR_DIM);
int i, j, n = x.nrow(), m = x.ncol();
for (j = 0; j < m; j++)
for (i = 0; i < n; i++)
x(i, j) /= val[i];
}
template <int RTYPE>
void divide_mat2_mult(Matrix<RTYPE>& x, const Vector<RTYPE>& val) {
myassert(x.ncol() == val.size(), ERROR_DIM);
int i, j, n = x.nrow(), m = x.ncol();
for (j = 0; j < m; j++)
for (i = 0; i < n; i++)
x(i, j) /= val[j];
}
/******************************************************************************/
// [[Rcpp::export]]
void divide_sweep1(SEXP x, SEXP val) {
DISPATCH(ON_MAT_ROW)
}
// [[Rcpp::export]]
void divide_sweep2(SEXP x, SEXP val) {
DISPATCH(ON_MAT_COL)
}
/******************************************************************************/
| [
"florian.prive.21@gmail.com"
] | florian.prive.21@gmail.com |
48e70f24c3ec7baf0e82204acdbf745e57141536 | d65bdc296ce4ab1361a3adfff4f8ade6767a463e | /CatAndMouse.h | e671d4e8165d7c60187c58b6244eaac1ceefec8f | [] | no_license | Slavkadav/graphicLab_qt | 7149e8ed5726cb233bffbc61db5188862546bd81 | fcdb0234209cd711054ca1235e328ce6cf8df39a | refs/heads/master | 2021-08-07T05:01:36.080268 | 2017-11-07T15:44:07 | 2017-11-07T15:44:07 | 108,754,608 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 472 | h | //
// Created by dev on 28.10.17.
//
#ifndef GRAPHIC_LAB_2_CATANDMOUSE_H
#define GRAPHIC_LAB_2_CATANDMOUSE_H
#include <QtWidgets/QWidget>
#include <QtCore/QTimer>
#include "Figures/Mouse/Mouse.h"
#include "Figures/Cat/Cat.h"
class CatAndMouse : public QWidget {
public:
CatAndMouse();
private:
void paintEvent(QPaintEvent *qEvent) override;
Mouse *mouse;
QTimer *timer;
int iteration = 0;
Cat *cat;
};
#endif //GRAPHIC_LAB_2_CATANDMOUSE_H
| [
"slavkadav@gmail.com"
] | slavkadav@gmail.com |
032a0247aef1d6db00ec658292f90f526bd1f128 | 82feeca430a8f4ef9e7aacab9e5e46004705b766 | /myShell/myShell/MyShell.cpp | fd5a9f3192990c10921f7e9f6257f4cd549be834 | [] | no_license | vasthorizon/OS_MyShell | bbe23186723a908b630e0a18b9b439e47f1b38b2 | 0c69cdcc4c47332d23371a7910fd4680fa8e5286 | refs/heads/master | 2021-01-10T19:37:41.502318 | 2014-09-05T14:04:43 | 2014-09-05T14:04:43 | null | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 729 | cpp |
#include <stdio.h>
#include <tchar.h>
#include <locale.h>
#include <windows.h>
#include "global.h"
#include "command.h"
int _tmain(int argc, TCHAR * argv[])
{
// 한글 입력을 가능케 하기 위해.
_tsetlocale(LC_ALL, _T("Korean"));
if (argc >= 2) // 매개변수 전달인자가 있는 경우.
{
for (int i = 1; i<argc; i++)
_tcscpy_s(cmdTokenList[i - 1], argv[i]);
CmdProcessing(argc - 1);
}
int isExit = NULL;
while (1)
{
int tokenNum = CmdReadTokenize();
if (tokenNum == 0) //Enter 입력시 처리를 위해...
continue;
isExit = CmdProcessing(tokenNum);
if (isExit == TRUE)
{
_fputts(_T("명령어 처리를 종료합니다. \n"), stdout);
break;
}
}
return 0;
}
| [
"vasthorizon@nhnnext.org"
] | vasthorizon@nhnnext.org |
46b7f3f28fdb7db9e8bcb93b7fc1a175e91c6be2 | c0668407f94cad329a31169e57e970df0e8c3c57 | /src/qt/mocha/settings/settingsbackupwallet.h | 179fbc05dc9cceb32044393a12d36d9ea5ad68e8 | [
"MIT"
] | permissive | crypTuron/mocha | 5d7ad9befdcba88e717d4e91d094400f1f158f12 | e3d6c6d13ef7c5aa918ccc44770f22138835b336 | refs/heads/master | 2022-09-23T15:10:05.410444 | 2020-05-31T21:04:52 | 2020-05-31T21:04:52 | 269,326,681 | 0 | 0 | NOASSERTION | 2020-06-04T10:15:09 | 2020-06-04T10:15:08 | null | UTF-8 | C++ | false | false | 769 | h | // Copyright (c) 2019-2023 The MOCHA developers
// Copyright (c) 2019 The PIVX developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef SETTINGSBACKUPWALLET_H
#define SETTINGSBACKUPWALLET_H
#include <QWidget>
#include "qt/mocha/pwidget.h"
namespace Ui {
class SettingsBackupWallet;
}
class SettingsBackupWallet : public PWidget
{
Q_OBJECT
public:
explicit SettingsBackupWallet(MOCHAGUI* _window, QWidget *parent = nullptr);
~SettingsBackupWallet();
private slots:
void backupWallet();
void selectFileOutput();
void changePassphrase();
private:
Ui::SettingsBackupWallet *ui;
QString filename;
};
#endif // SETTINGSBACKUPWALLET_H
| [
"whoffman1031@gmail.com"
] | whoffman1031@gmail.com |
6e6502bac1bdd2646b2fc92da3e99cf83fd59ddf | 905fb4f295e7e56e8719d9555e6ff2c7251b5f42 | /6DSDKUnitySampleApp/Classes/Native/System.Core.cpp | 06e919b3fa743b15d44438b09ae3932b60cf98f7 | [] | no_license | jinczing/6dunitytest | e7941bc67b5b1fa0ba5879e72dbc9f24efe23a65 | 44959db1f90e8e877504998543bded84e64a4c0d | refs/heads/master | 2020-07-21T11:07:28.120418 | 2019-09-07T05:41:52 | 2019-09-07T05:41:52 | 206,843,194 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 616,759 | cpp | #include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <cstring>
#include <string.h>
#include <stdio.h>
#include <cmath>
#include <limits>
#include <assert.h>
#include <stdint.h>
#include "codegen/il2cpp-codegen.h"
#include "il2cpp-object-internals.h"
template <typename R>
struct VirtFuncInvoker0
{
typedef R (*Func)(void*, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename R, typename T1, typename T2>
struct VirtFuncInvoker2
{
typedef R (*Func)(void*, T1, T2, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1, T2 p2)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
template <typename T1>
struct VirtActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
struct VirtActionInvoker0
{
typedef void (*Action)(void*, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeObject* obj)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
((Action)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename R, typename T1>
struct VirtFuncInvoker1
{
typedef R (*Func)(void*, T1, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeObject* obj, T1 p1)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_virtual_invoke_data(slot, obj);
return ((Func)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
struct InterfaceActionInvoker0
{
typedef void (*Action)(void*, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
((Action)invokeData.methodPtr)(obj, invokeData.method);
}
};
// Microsoft.Win32.SafeHandles.SafeWaitHandle
struct SafeWaitHandle_t51DB35FF382E636FF3B868D87816733894D46CF2;
// Mono.Security.Cryptography.SymmetricTransform
struct SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750;
// System.ArgumentException
struct ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1;
// System.ArgumentNullException
struct ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD;
// System.ArgumentOutOfRangeException
struct ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA;
// System.Byte[]
struct ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821;
// System.Char[]
struct CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2;
// System.Collections.IDictionary
struct IDictionary_t1BD5C1546718A374EA8122FBD6C6EE45331E8CE7;
// System.Diagnostics.StackTrace[]
struct StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196;
// System.Exception
struct Exception_t;
// System.Globalization.CultureInfo
struct CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F;
// System.IntPtr[]
struct IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD;
// System.InvalidOperationException
struct InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1;
// System.LocalDataStoreHolder
struct LocalDataStoreHolder_tE0636E08496405406FD63190AC51EEB2EE51E304;
// System.LocalDataStoreMgr
struct LocalDataStoreMgr_t1964DDB9F2BE154BE3159A7507D0D0CCBF8FDCA9;
// System.MulticastDelegate
struct MulticastDelegate_t;
// System.ObjectDisposedException
struct ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A;
// System.Object[]
struct ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A;
// System.Runtime.Serialization.SafeSerializationManager
struct SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770;
// System.Security.Cryptography.Aes
struct Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653;
// System.Security.Cryptography.AesCryptoServiceProvider
struct AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3;
// System.Security.Cryptography.AesManaged
struct AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3;
// System.Security.Cryptography.AesTransform
struct AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208;
// System.Security.Cryptography.CryptographicException
struct CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A;
// System.Security.Cryptography.ICryptoTransform
struct ICryptoTransform_t43C29A7F3A8C2DDAC9F3BF9BF739B03E4D5DE9A9;
// System.Security.Cryptography.KeySizes[]
struct KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E;
// System.Security.Cryptography.RandomNumberGenerator
struct RandomNumberGenerator_t12277F7F965BA79C54E4B3BFABD27A5FFB725EE2;
// System.Security.Cryptography.RijndaelManaged
struct RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182;
// System.Security.Cryptography.SymmetricAlgorithm
struct SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789;
// System.Security.Principal.IPrincipal
struct IPrincipal_t63FD7F58FBBE134C8FE4D31710AAEA00B000F0BF;
// System.String
struct String_t;
// System.Threading.AsyncLocal`1<System.Globalization.CultureInfo>
struct AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A;
// System.Threading.AutoResetEvent
struct AutoResetEvent_t2A1182CEEE4E184587D4DEAA4F382B810B21D3B7;
// System.Threading.EventWaitHandle
struct EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98;
// System.Threading.ExecutionContext
struct ExecutionContext_t0E11C30308A4CC964D8A2EA9132F9BDCE5362C70;
// System.Threading.InternalThread
struct InternalThread_tA4C58C2A7D15AF43C3E7507375E6D31DBBE7D192;
// System.Threading.LockRecursionException
struct LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9;
// System.Threading.ManualResetEvent
struct ManualResetEvent_tDFAF117B200ECA4CCF4FD09593F949A016D55408;
// System.Threading.ReaderWriterCount
struct ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900;
// System.Threading.ReaderWriterLockSlim
struct ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315;
// System.Threading.SynchronizationLockException
struct SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4;
// System.Threading.Thread
struct Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7;
// System.UInt32[]
struct UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB;
// System.Void
struct Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017;
IL2CPP_EXTERN_C RuntimeClass* AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* AutoResetEvent_t2A1182CEEE4E184587D4DEAA4F382B810B21D3B7_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* IDisposable_t7218B22548186B208D65EA5B7870503810A2D15A_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ManualResetEvent_tDFAF117B200ECA4CCF4FD09593F949A016D55408_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeField* U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____0AA802CD6847EB893FE786B5EA5168B2FDCD7B93_0_FieldInfo_var;
IL2CPP_EXTERN_C RuntimeField* U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____0C4110BC17D746F018F47B49E0EB0D6590F69939_1_FieldInfo_var;
IL2CPP_EXTERN_C RuntimeField* U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____20733E1283D873EBE47133A95C233E11B76F5F11_2_FieldInfo_var;
IL2CPP_EXTERN_C RuntimeField* U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____21F4CBF8283FF1CAEB4A39316A97FC1D6DF1D35E_3_FieldInfo_var;
IL2CPP_EXTERN_C RuntimeField* U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____23DFDCA6F045D4257BF5AC8CB1CF2EFADAFE9B94_4_FieldInfo_var;
IL2CPP_EXTERN_C RuntimeField* U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____30A0358B25B1372DD598BB4B1AC56AD6B8F08A47_5_FieldInfo_var;
IL2CPP_EXTERN_C RuntimeField* U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____5B5DF5A459E902D96F7DB0FB235A25346CA85C5D_6_FieldInfo_var;
IL2CPP_EXTERN_C RuntimeField* U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____5BE411F1438EAEF33726D855E99011D5FECDDD4E_7_FieldInfo_var;
IL2CPP_EXTERN_C RuntimeField* U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____8F22C9ECE1331718CBD268A9BBFD2F5E451441E3_8_FieldInfo_var;
IL2CPP_EXTERN_C RuntimeField* U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____A02DD1D8604EA8EC2D2BDA717A93A4EE85F13E53_9_FieldInfo_var;
IL2CPP_EXTERN_C RuntimeField* U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____AE2F76ECEF8B08F0BC7EA95DCFE945E1727927C9_10_FieldInfo_var;
IL2CPP_EXTERN_C String_t* _stringLiteral0F26F65FFEB0A0C184512B25B278A5DF73E93D09;
IL2CPP_EXTERN_C String_t* _stringLiteral109DA2C2B37EAF7931CB49917D2F04C935D39886;
IL2CPP_EXTERN_C String_t* _stringLiteral10C80EDD83941DF788671EE857634D37829B4A25;
IL2CPP_EXTERN_C String_t* _stringLiteral234A8A5D65EA3192A7CCFA46C3B46E9647D3D6F4;
IL2CPP_EXTERN_C String_t* _stringLiteral2B946DDAE90DF50F553375CBADEDE63EF5DCC8B0;
IL2CPP_EXTERN_C String_t* _stringLiteral2ECBD375CE3135E79828D5011999895D360C96FF;
IL2CPP_EXTERN_C String_t* _stringLiteral482B665E48FCB8584375B0A83CB92F4C37CED919;
IL2CPP_EXTERN_C String_t* _stringLiteral4CB242DE8E5548B98BD01BE41F233316CF712862;
IL2CPP_EXTERN_C String_t* _stringLiteral5249E2CEECA370436A4C6708678965453623EC52;
IL2CPP_EXTERN_C String_t* _stringLiteral55A76F0C6A7878D7B9E3BBE71A039630E24CDF5E;
IL2CPP_EXTERN_C String_t* _stringLiteral5F28FB22DC8DFDC53D50B181C7DCB2A4029CE2ED;
IL2CPP_EXTERN_C String_t* _stringLiteral69F29D02EF38F7D5571FFBD7DFC80325B1377895;
IL2CPP_EXTERN_C String_t* _stringLiteral6F3695F7633E8B0DBDDF0AA3265EA7BEB1344779;
IL2CPP_EXTERN_C String_t* _stringLiteral9BA1F37E186819E10410F7100555F559D85A26C8;
IL2CPP_EXTERN_C String_t* _stringLiteral9D9BED981884AC3D4D16BF22ED725A5686CEF15B;
IL2CPP_EXTERN_C String_t* _stringLiteralA62F2225BF70BFACCBC7F1EF2A397836717377DE;
IL2CPP_EXTERN_C String_t* _stringLiteralB4F59191955C7D4FEB657A298BB9D296BE7E3278;
IL2CPP_EXTERN_C String_t* _stringLiteralBB863394E44E7F0AB103B463E68E0DE654F40669;
IL2CPP_EXTERN_C String_t* _stringLiteralC24C570C80332D3F38155C328F3AF1A671970FE7;
IL2CPP_EXTERN_C String_t* _stringLiteralC4CDA1BBE106A03CCFAA2F8227D0ACC029A16555;
IL2CPP_EXTERN_C String_t* _stringLiteralC7C98D2F3A743BCA3032E11738A7C2CD9E0DAF5A;
IL2CPP_EXTERN_C String_t* _stringLiteralCD72BFB00B20A1600AF561C7F666CA5EA98BBB38;
IL2CPP_EXTERN_C String_t* _stringLiteralDAA18AA61E2D46E829CB9DF89DCA6C1C54E91FDC;
IL2CPP_EXTERN_C String_t* _stringLiteralFF1C30AC5539B024798DA89177C788C04C382338;
IL2CPP_EXTERN_C const RuntimeMethod* AesCryptoServiceProvider_CreateDecryptor_m3842B2AC283063BE4D9902818C8F68CFB4100139_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* AesCryptoServiceProvider_CreateEncryptor_mACCCC00AED5CBBF5E9437BCA907DD67C6D123672_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* AesCryptoServiceProvider_set_Mode_mC7EE07E709C918D0745E5A207A66D89F08EA57EA_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* AesManaged_CreateDecryptor_mEBE041A905F0848F846901916BA23485F85C65F1_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* AesManaged_CreateEncryptor_mA914CA875EF777EDB202343570182CC0D9D89A91_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* AesManaged__ctor_mB2BB25E2F795428300A966DF7C4706BDDB65FB64_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* AesManaged_set_Mode_mE06717F04195261B88A558FBD08AEB847D9320D8_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* AesTransform__ctor_m1BC6B0F208747D4E35A58075D74DEBD5F72DB7DD_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* ReaderWriterLockSlim_Dispose_m227307FAFA9FC458348241A75B6FCEF94CC63A29_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* ReaderWriterLockSlim_ExitReadLock_m7DF8D92A2E02017583EB8DB8380E61933ADAEE37_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* ReaderWriterLockSlim_ExitUpgradeableReadLock_m4B7266ABD40B93FED0664E00B6AD371B69CBC471_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* ReaderWriterLockSlim_ExitWriteLock_mE1E51CB12C3C895C5EB5CF0D42854A476502EAB3_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* ReaderWriterLockSlim_TryEnterReadLockCore_m946546F9F496EF40AB1C4B24FA8466A4E2D4E1DA_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* ReaderWriterLockSlim_TryEnterUpgradeableReadLockCore_m2275C4016382DCDD9A5B2EA8B1239C710486EBFB_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* ReaderWriterLockSlim_TryEnterWriteLockCore_m89767DB508CA2EDBAD19B727B0814DF5EA959F9E_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* TimeoutTracker__ctor_m2238A5B6D938E911C2F7742E5A90E1E670F570F9_RuntimeMethod_var;
IL2CPP_EXTERN_C const uint32_t AesCryptoServiceProvider_CreateDecryptor_m3842B2AC283063BE4D9902818C8F68CFB4100139_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t AesCryptoServiceProvider_CreateEncryptor_mACCCC00AED5CBBF5E9437BCA907DD67C6D123672_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t AesCryptoServiceProvider__ctor_m8AA4C1503DBE1849070CFE727ED227BE5043373E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t AesCryptoServiceProvider_set_Mode_mC7EE07E709C918D0745E5A207A66D89F08EA57EA_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t AesManaged_CreateDecryptor_mEBE041A905F0848F846901916BA23485F85C65F1_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t AesManaged_CreateEncryptor_mA914CA875EF777EDB202343570182CC0D9D89A91_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t AesManaged_Dispose_m57258CB76A9CCEF03FF4D4C5DE02E9A31056F8ED_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t AesManaged__ctor_mB2BB25E2F795428300A966DF7C4706BDDB65FB64_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t AesManaged_set_Mode_mE06717F04195261B88A558FBD08AEB847D9320D8_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t AesTransform_Decrypt128_m1AE10B230A47A294B5B10EFD9C8243B02DBEA463_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t AesTransform_Encrypt128_m09C945A0345FD32E8DB3F4AF4B4E184CADD754DA_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t AesTransform_SubByte_mEDB43A2A4E83017475094E5616E7DBC56F945A24_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t AesTransform__cctor_mDEA197C50BA055FF76B7ECFEB5C1FD7900CE4325_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t AesTransform__ctor_m1BC6B0F208747D4E35A58075D74DEBD5F72DB7DD_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Error_ArgumentNull_mCA126ED8F4F3B343A70E201C44B3A509690F1EA7_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Error_ArgumentOutOfRange_mACFCB068F4E0C4EEF9E6EDDD59E798901C32C6C9_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t Error_MoreThanOneMatch_m85C3617F782E9F2333FC1FDF42821BE069F24623_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ReaderWriterLockSlim_Dispose_m227307FAFA9FC458348241A75B6FCEF94CC63A29_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ReaderWriterLockSlim_ExitReadLock_m7DF8D92A2E02017583EB8DB8380E61933ADAEE37_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ReaderWriterLockSlim_ExitUpgradeableReadLock_m4B7266ABD40B93FED0664E00B6AD371B69CBC471_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ReaderWriterLockSlim_ExitWriteLock_mE1E51CB12C3C895C5EB5CF0D42854A476502EAB3_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAFSystem_Core_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ReaderWriterLockSlim_LazyCreateEvent_mF1FB4CDE744ADC2CADEE4F020F095896E1C64D1A_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ReaderWriterLockSlim_TryEnterReadLockCore_m946546F9F496EF40AB1C4B24FA8466A4E2D4E1DA_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ReaderWriterLockSlim_TryEnterUpgradeableReadLockCore_m2275C4016382DCDD9A5B2EA8B1239C710486EBFB_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ReaderWriterLockSlim_TryEnterWriteLockCore_m89767DB508CA2EDBAD19B727B0814DF5EA959F9E_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t ReaderWriterLockSlim__ctor_mF9D168D6A94D7B6F669313541D7302A6BD9C7FF1_MetadataUsageId;
IL2CPP_EXTERN_C const uint32_t TimeoutTracker__ctor_m2238A5B6D938E911C2F7742E5A90E1E670F570F9_MetadataUsageId;
struct Exception_t_marshaled_com;
struct Exception_t_marshaled_pinvoke;
struct ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821;
struct ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A;
struct UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB;
IL2CPP_EXTERN_C_BEGIN
IL2CPP_EXTERN_C_END
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// <Module>
struct U3CModuleU3E_t3EC8D1595A762E18CA2FD2325511B3DE2C4947AA
{
public:
public:
};
// System.Object
// SR
struct SR_t1A3040F0EAC57FC373952ED457F5E7EFCF7CE44D : public RuntimeObject
{
public:
public:
};
struct Il2CppArrayBounds;
// System.Array
// System.Linq.Enumerable
struct Enumerable_tECC271C86C6E8F72E4E27C7C8FD5DB7B63D5D737 : public RuntimeObject
{
public:
public:
};
// System.Linq.Error
struct Error_tDED49FF03F09C0230D8754901206DAAF2D798834 : public RuntimeObject
{
public:
public:
};
// System.MarshalByRefObject
struct MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF : public RuntimeObject
{
public:
// System.Object System.MarshalByRefObject::_identity
RuntimeObject * ____identity_0;
public:
inline static int32_t get_offset_of__identity_0() { return static_cast<int32_t>(offsetof(MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF, ____identity_0)); }
inline RuntimeObject * get__identity_0() const { return ____identity_0; }
inline RuntimeObject ** get_address_of__identity_0() { return &____identity_0; }
inline void set__identity_0(RuntimeObject * value)
{
____identity_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&____identity_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.MarshalByRefObject
struct MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF_marshaled_pinvoke
{
Il2CppIUnknown* ____identity_0;
};
// Native definition for COM marshalling of System.MarshalByRefObject
struct MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF_marshaled_com
{
Il2CppIUnknown* ____identity_0;
};
// System.Runtime.ConstrainedExecution.CriticalFinalizerObject
struct CriticalFinalizerObject_t8B006E1DEE084E781F5C0F3283E9226E28894DD9 : public RuntimeObject
{
public:
public:
};
// System.String
struct String_t : public RuntimeObject
{
public:
// System.Int32 System.String::m_stringLength
int32_t ___m_stringLength_0;
// System.Char System.String::m_firstChar
Il2CppChar ___m_firstChar_1;
public:
inline static int32_t get_offset_of_m_stringLength_0() { return static_cast<int32_t>(offsetof(String_t, ___m_stringLength_0)); }
inline int32_t get_m_stringLength_0() const { return ___m_stringLength_0; }
inline int32_t* get_address_of_m_stringLength_0() { return &___m_stringLength_0; }
inline void set_m_stringLength_0(int32_t value)
{
___m_stringLength_0 = value;
}
inline static int32_t get_offset_of_m_firstChar_1() { return static_cast<int32_t>(offsetof(String_t, ___m_firstChar_1)); }
inline Il2CppChar get_m_firstChar_1() const { return ___m_firstChar_1; }
inline Il2CppChar* get_address_of_m_firstChar_1() { return &___m_firstChar_1; }
inline void set_m_firstChar_1(Il2CppChar value)
{
___m_firstChar_1 = value;
}
};
struct String_t_StaticFields
{
public:
// System.String System.String::Empty
String_t* ___Empty_5;
public:
inline static int32_t get_offset_of_Empty_5() { return static_cast<int32_t>(offsetof(String_t_StaticFields, ___Empty_5)); }
inline String_t* get_Empty_5() const { return ___Empty_5; }
inline String_t** get_address_of_Empty_5() { return &___Empty_5; }
inline void set_Empty_5(String_t* value)
{
___Empty_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Empty_5), (void*)value);
}
};
// System.Threading.ReaderWriterCount
struct ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 : public RuntimeObject
{
public:
// System.Int64 System.Threading.ReaderWriterCount::lockID
int64_t ___lockID_0;
// System.Int32 System.Threading.ReaderWriterCount::readercount
int32_t ___readercount_1;
// System.Int32 System.Threading.ReaderWriterCount::writercount
int32_t ___writercount_2;
// System.Int32 System.Threading.ReaderWriterCount::upgradecount
int32_t ___upgradecount_3;
// System.Threading.ReaderWriterCount System.Threading.ReaderWriterCount::next
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * ___next_4;
public:
inline static int32_t get_offset_of_lockID_0() { return static_cast<int32_t>(offsetof(ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900, ___lockID_0)); }
inline int64_t get_lockID_0() const { return ___lockID_0; }
inline int64_t* get_address_of_lockID_0() { return &___lockID_0; }
inline void set_lockID_0(int64_t value)
{
___lockID_0 = value;
}
inline static int32_t get_offset_of_readercount_1() { return static_cast<int32_t>(offsetof(ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900, ___readercount_1)); }
inline int32_t get_readercount_1() const { return ___readercount_1; }
inline int32_t* get_address_of_readercount_1() { return &___readercount_1; }
inline void set_readercount_1(int32_t value)
{
___readercount_1 = value;
}
inline static int32_t get_offset_of_writercount_2() { return static_cast<int32_t>(offsetof(ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900, ___writercount_2)); }
inline int32_t get_writercount_2() const { return ___writercount_2; }
inline int32_t* get_address_of_writercount_2() { return &___writercount_2; }
inline void set_writercount_2(int32_t value)
{
___writercount_2 = value;
}
inline static int32_t get_offset_of_upgradecount_3() { return static_cast<int32_t>(offsetof(ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900, ___upgradecount_3)); }
inline int32_t get_upgradecount_3() const { return ___upgradecount_3; }
inline int32_t* get_address_of_upgradecount_3() { return &___upgradecount_3; }
inline void set_upgradecount_3(int32_t value)
{
___upgradecount_3 = value;
}
inline static int32_t get_offset_of_next_4() { return static_cast<int32_t>(offsetof(ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900, ___next_4)); }
inline ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * get_next_4() const { return ___next_4; }
inline ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 ** get_address_of_next_4() { return &___next_4; }
inline void set_next_4(ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * value)
{
___next_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___next_4), (void*)value);
}
};
// System.Threading.ReaderWriterLockSlim
struct ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 : public RuntimeObject
{
public:
// System.Boolean System.Threading.ReaderWriterLockSlim::fIsReentrant
bool ___fIsReentrant_0;
// System.Int32 System.Threading.ReaderWriterLockSlim::myLock
int32_t ___myLock_1;
// System.UInt32 System.Threading.ReaderWriterLockSlim::numWriteWaiters
uint32_t ___numWriteWaiters_2;
// System.UInt32 System.Threading.ReaderWriterLockSlim::numReadWaiters
uint32_t ___numReadWaiters_3;
// System.UInt32 System.Threading.ReaderWriterLockSlim::numWriteUpgradeWaiters
uint32_t ___numWriteUpgradeWaiters_4;
// System.UInt32 System.Threading.ReaderWriterLockSlim::numUpgradeWaiters
uint32_t ___numUpgradeWaiters_5;
// System.Boolean System.Threading.ReaderWriterLockSlim::fNoWaiters
bool ___fNoWaiters_6;
// System.Int32 System.Threading.ReaderWriterLockSlim::upgradeLockOwnerId
int32_t ___upgradeLockOwnerId_7;
// System.Int32 System.Threading.ReaderWriterLockSlim::writeLockOwnerId
int32_t ___writeLockOwnerId_8;
// System.Threading.EventWaitHandle System.Threading.ReaderWriterLockSlim::writeEvent
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * ___writeEvent_9;
// System.Threading.EventWaitHandle System.Threading.ReaderWriterLockSlim::readEvent
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * ___readEvent_10;
// System.Threading.EventWaitHandle System.Threading.ReaderWriterLockSlim::upgradeEvent
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * ___upgradeEvent_11;
// System.Threading.EventWaitHandle System.Threading.ReaderWriterLockSlim::waitUpgradeEvent
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * ___waitUpgradeEvent_12;
// System.Int64 System.Threading.ReaderWriterLockSlim::lockID
int64_t ___lockID_14;
// System.Boolean System.Threading.ReaderWriterLockSlim::fUpgradeThreadHoldingRead
bool ___fUpgradeThreadHoldingRead_16;
// System.UInt32 System.Threading.ReaderWriterLockSlim::owners
uint32_t ___owners_17;
// System.Boolean System.Threading.ReaderWriterLockSlim::fDisposed
bool ___fDisposed_18;
public:
inline static int32_t get_offset_of_fIsReentrant_0() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___fIsReentrant_0)); }
inline bool get_fIsReentrant_0() const { return ___fIsReentrant_0; }
inline bool* get_address_of_fIsReentrant_0() { return &___fIsReentrant_0; }
inline void set_fIsReentrant_0(bool value)
{
___fIsReentrant_0 = value;
}
inline static int32_t get_offset_of_myLock_1() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___myLock_1)); }
inline int32_t get_myLock_1() const { return ___myLock_1; }
inline int32_t* get_address_of_myLock_1() { return &___myLock_1; }
inline void set_myLock_1(int32_t value)
{
___myLock_1 = value;
}
inline static int32_t get_offset_of_numWriteWaiters_2() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___numWriteWaiters_2)); }
inline uint32_t get_numWriteWaiters_2() const { return ___numWriteWaiters_2; }
inline uint32_t* get_address_of_numWriteWaiters_2() { return &___numWriteWaiters_2; }
inline void set_numWriteWaiters_2(uint32_t value)
{
___numWriteWaiters_2 = value;
}
inline static int32_t get_offset_of_numReadWaiters_3() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___numReadWaiters_3)); }
inline uint32_t get_numReadWaiters_3() const { return ___numReadWaiters_3; }
inline uint32_t* get_address_of_numReadWaiters_3() { return &___numReadWaiters_3; }
inline void set_numReadWaiters_3(uint32_t value)
{
___numReadWaiters_3 = value;
}
inline static int32_t get_offset_of_numWriteUpgradeWaiters_4() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___numWriteUpgradeWaiters_4)); }
inline uint32_t get_numWriteUpgradeWaiters_4() const { return ___numWriteUpgradeWaiters_4; }
inline uint32_t* get_address_of_numWriteUpgradeWaiters_4() { return &___numWriteUpgradeWaiters_4; }
inline void set_numWriteUpgradeWaiters_4(uint32_t value)
{
___numWriteUpgradeWaiters_4 = value;
}
inline static int32_t get_offset_of_numUpgradeWaiters_5() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___numUpgradeWaiters_5)); }
inline uint32_t get_numUpgradeWaiters_5() const { return ___numUpgradeWaiters_5; }
inline uint32_t* get_address_of_numUpgradeWaiters_5() { return &___numUpgradeWaiters_5; }
inline void set_numUpgradeWaiters_5(uint32_t value)
{
___numUpgradeWaiters_5 = value;
}
inline static int32_t get_offset_of_fNoWaiters_6() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___fNoWaiters_6)); }
inline bool get_fNoWaiters_6() const { return ___fNoWaiters_6; }
inline bool* get_address_of_fNoWaiters_6() { return &___fNoWaiters_6; }
inline void set_fNoWaiters_6(bool value)
{
___fNoWaiters_6 = value;
}
inline static int32_t get_offset_of_upgradeLockOwnerId_7() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___upgradeLockOwnerId_7)); }
inline int32_t get_upgradeLockOwnerId_7() const { return ___upgradeLockOwnerId_7; }
inline int32_t* get_address_of_upgradeLockOwnerId_7() { return &___upgradeLockOwnerId_7; }
inline void set_upgradeLockOwnerId_7(int32_t value)
{
___upgradeLockOwnerId_7 = value;
}
inline static int32_t get_offset_of_writeLockOwnerId_8() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___writeLockOwnerId_8)); }
inline int32_t get_writeLockOwnerId_8() const { return ___writeLockOwnerId_8; }
inline int32_t* get_address_of_writeLockOwnerId_8() { return &___writeLockOwnerId_8; }
inline void set_writeLockOwnerId_8(int32_t value)
{
___writeLockOwnerId_8 = value;
}
inline static int32_t get_offset_of_writeEvent_9() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___writeEvent_9)); }
inline EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * get_writeEvent_9() const { return ___writeEvent_9; }
inline EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 ** get_address_of_writeEvent_9() { return &___writeEvent_9; }
inline void set_writeEvent_9(EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * value)
{
___writeEvent_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___writeEvent_9), (void*)value);
}
inline static int32_t get_offset_of_readEvent_10() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___readEvent_10)); }
inline EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * get_readEvent_10() const { return ___readEvent_10; }
inline EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 ** get_address_of_readEvent_10() { return &___readEvent_10; }
inline void set_readEvent_10(EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * value)
{
___readEvent_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___readEvent_10), (void*)value);
}
inline static int32_t get_offset_of_upgradeEvent_11() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___upgradeEvent_11)); }
inline EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * get_upgradeEvent_11() const { return ___upgradeEvent_11; }
inline EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 ** get_address_of_upgradeEvent_11() { return &___upgradeEvent_11; }
inline void set_upgradeEvent_11(EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * value)
{
___upgradeEvent_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___upgradeEvent_11), (void*)value);
}
inline static int32_t get_offset_of_waitUpgradeEvent_12() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___waitUpgradeEvent_12)); }
inline EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * get_waitUpgradeEvent_12() const { return ___waitUpgradeEvent_12; }
inline EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 ** get_address_of_waitUpgradeEvent_12() { return &___waitUpgradeEvent_12; }
inline void set_waitUpgradeEvent_12(EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * value)
{
___waitUpgradeEvent_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&___waitUpgradeEvent_12), (void*)value);
}
inline static int32_t get_offset_of_lockID_14() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___lockID_14)); }
inline int64_t get_lockID_14() const { return ___lockID_14; }
inline int64_t* get_address_of_lockID_14() { return &___lockID_14; }
inline void set_lockID_14(int64_t value)
{
___lockID_14 = value;
}
inline static int32_t get_offset_of_fUpgradeThreadHoldingRead_16() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___fUpgradeThreadHoldingRead_16)); }
inline bool get_fUpgradeThreadHoldingRead_16() const { return ___fUpgradeThreadHoldingRead_16; }
inline bool* get_address_of_fUpgradeThreadHoldingRead_16() { return &___fUpgradeThreadHoldingRead_16; }
inline void set_fUpgradeThreadHoldingRead_16(bool value)
{
___fUpgradeThreadHoldingRead_16 = value;
}
inline static int32_t get_offset_of_owners_17() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___owners_17)); }
inline uint32_t get_owners_17() const { return ___owners_17; }
inline uint32_t* get_address_of_owners_17() { return &___owners_17; }
inline void set_owners_17(uint32_t value)
{
___owners_17 = value;
}
inline static int32_t get_offset_of_fDisposed_18() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315, ___fDisposed_18)); }
inline bool get_fDisposed_18() const { return ___fDisposed_18; }
inline bool* get_address_of_fDisposed_18() { return &___fDisposed_18; }
inline void set_fDisposed_18(bool value)
{
___fDisposed_18 = value;
}
};
struct ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_StaticFields
{
public:
// System.Int64 System.Threading.ReaderWriterLockSlim::s_nextLockID
int64_t ___s_nextLockID_13;
public:
inline static int32_t get_offset_of_s_nextLockID_13() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_StaticFields, ___s_nextLockID_13)); }
inline int64_t get_s_nextLockID_13() const { return ___s_nextLockID_13; }
inline int64_t* get_address_of_s_nextLockID_13() { return &___s_nextLockID_13; }
inline void set_s_nextLockID_13(int64_t value)
{
___s_nextLockID_13 = value;
}
};
struct ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_ThreadStaticFields
{
public:
// System.Threading.ReaderWriterCount System.Threading.ReaderWriterLockSlim::t_rwc
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * ___t_rwc_15;
public:
inline static int32_t get_offset_of_t_rwc_15() { return static_cast<int32_t>(offsetof(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_ThreadStaticFields, ___t_rwc_15)); }
inline ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * get_t_rwc_15() const { return ___t_rwc_15; }
inline ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 ** get_address_of_t_rwc_15() { return &___t_rwc_15; }
inline void set_t_rwc_15(ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * value)
{
___t_rwc_15 = value;
Il2CppCodeGenWriteBarrier((void**)(&___t_rwc_15), (void*)value);
}
};
// System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF : public RuntimeObject
{
public:
public:
};
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF_marshaled_com
{
};
// <PrivateImplementationDetails>___StaticArrayInitTypeSizeU3D1024
struct __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C
{
public:
union
{
struct
{
union
{
};
};
uint8_t __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C__padding[1024];
};
public:
};
// <PrivateImplementationDetails>___StaticArrayInitTypeSizeU3D120
struct __StaticArrayInitTypeSizeU3D120_t83E233123DD538AA6101D1CB5AE4F5DC639EBC9D
{
public:
union
{
struct
{
union
{
};
};
uint8_t __StaticArrayInitTypeSizeU3D120_t83E233123DD538AA6101D1CB5AE4F5DC639EBC9D__padding[120];
};
public:
};
// <PrivateImplementationDetails>___StaticArrayInitTypeSizeU3D256
struct __StaticArrayInitTypeSizeU3D256_tCCCC326240ED0A827344379DD68205BF9340FF47
{
public:
union
{
struct
{
union
{
};
};
uint8_t __StaticArrayInitTypeSizeU3D256_tCCCC326240ED0A827344379DD68205BF9340FF47__padding[256];
};
public:
};
// System.Boolean
struct Boolean_tB53F6830F670160873277339AA58F15CAED4399C
{
public:
// System.Boolean System.Boolean::m_value
bool ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Boolean_tB53F6830F670160873277339AA58F15CAED4399C, ___m_value_0)); }
inline bool get_m_value_0() const { return ___m_value_0; }
inline bool* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(bool value)
{
___m_value_0 = value;
}
};
struct Boolean_tB53F6830F670160873277339AA58F15CAED4399C_StaticFields
{
public:
// System.String System.Boolean::TrueString
String_t* ___TrueString_5;
// System.String System.Boolean::FalseString
String_t* ___FalseString_6;
public:
inline static int32_t get_offset_of_TrueString_5() { return static_cast<int32_t>(offsetof(Boolean_tB53F6830F670160873277339AA58F15CAED4399C_StaticFields, ___TrueString_5)); }
inline String_t* get_TrueString_5() const { return ___TrueString_5; }
inline String_t** get_address_of_TrueString_5() { return &___TrueString_5; }
inline void set_TrueString_5(String_t* value)
{
___TrueString_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___TrueString_5), (void*)value);
}
inline static int32_t get_offset_of_FalseString_6() { return static_cast<int32_t>(offsetof(Boolean_tB53F6830F670160873277339AA58F15CAED4399C_StaticFields, ___FalseString_6)); }
inline String_t* get_FalseString_6() const { return ___FalseString_6; }
inline String_t** get_address_of_FalseString_6() { return &___FalseString_6; }
inline void set_FalseString_6(String_t* value)
{
___FalseString_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___FalseString_6), (void*)value);
}
};
// System.Byte
struct Byte_tF87C579059BD4633E6840EBBBEEF899C6E33EF07
{
public:
// System.Byte System.Byte::m_value
uint8_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Byte_tF87C579059BD4633E6840EBBBEEF899C6E33EF07, ___m_value_0)); }
inline uint8_t get_m_value_0() const { return ___m_value_0; }
inline uint8_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint8_t value)
{
___m_value_0 = value;
}
};
// System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521 : public ValueType_t4D0C27076F7C36E76190FB3328E232BCB1CD1FFF
{
public:
public:
};
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_StaticFields
{
public:
// System.Char[] System.Enum::enumSeperatorCharArray
CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* ___enumSeperatorCharArray_0;
public:
inline static int32_t get_offset_of_enumSeperatorCharArray_0() { return static_cast<int32_t>(offsetof(Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_StaticFields, ___enumSeperatorCharArray_0)); }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* get_enumSeperatorCharArray_0() const { return ___enumSeperatorCharArray_0; }
inline CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2** get_address_of_enumSeperatorCharArray_0() { return &___enumSeperatorCharArray_0; }
inline void set_enumSeperatorCharArray_0(CharU5BU5D_t4CC6ABF0AD71BEC97E3C2F1E9C5677E46D3A75C2* value)
{
___enumSeperatorCharArray_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___enumSeperatorCharArray_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t2AF27C02B8653AE29442467390005ABC74D8F521_marshaled_com
{
};
// System.Int32
struct Int32_t585191389E07734F19F3156FF88FB3EF4800D102
{
public:
// System.Int32 System.Int32::m_value
int32_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int32_t585191389E07734F19F3156FF88FB3EF4800D102, ___m_value_0)); }
inline int32_t get_m_value_0() const { return ___m_value_0; }
inline int32_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int32_t value)
{
___m_value_0 = value;
}
};
// System.Int64
struct Int64_t7A386C2FF7B0280A0F516992401DDFCF0FF7B436
{
public:
// System.Int64 System.Int64::m_value
int64_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(Int64_t7A386C2FF7B0280A0F516992401DDFCF0FF7B436, ___m_value_0)); }
inline int64_t get_m_value_0() const { return ___m_value_0; }
inline int64_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(int64_t value)
{
___m_value_0 = value;
}
};
// System.IntPtr
struct IntPtr_t
{
public:
// System.Void* System.IntPtr::m_value
void* ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(IntPtr_t, ___m_value_0)); }
inline void* get_m_value_0() const { return ___m_value_0; }
inline void** get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(void* value)
{
___m_value_0 = value;
}
};
struct IntPtr_t_StaticFields
{
public:
// System.IntPtr System.IntPtr::Zero
intptr_t ___Zero_1;
public:
inline static int32_t get_offset_of_Zero_1() { return static_cast<int32_t>(offsetof(IntPtr_t_StaticFields, ___Zero_1)); }
inline intptr_t get_Zero_1() const { return ___Zero_1; }
inline intptr_t* get_address_of_Zero_1() { return &___Zero_1; }
inline void set_Zero_1(intptr_t value)
{
___Zero_1 = value;
}
};
// System.Threading.ReaderWriterLockSlim_TimeoutTracker
struct TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757
{
public:
// System.Int32 System.Threading.ReaderWriterLockSlim_TimeoutTracker::m_total
int32_t ___m_total_0;
// System.Int32 System.Threading.ReaderWriterLockSlim_TimeoutTracker::m_start
int32_t ___m_start_1;
public:
inline static int32_t get_offset_of_m_total_0() { return static_cast<int32_t>(offsetof(TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757, ___m_total_0)); }
inline int32_t get_m_total_0() const { return ___m_total_0; }
inline int32_t* get_address_of_m_total_0() { return &___m_total_0; }
inline void set_m_total_0(int32_t value)
{
___m_total_0 = value;
}
inline static int32_t get_offset_of_m_start_1() { return static_cast<int32_t>(offsetof(TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757, ___m_start_1)); }
inline int32_t get_m_start_1() const { return ___m_start_1; }
inline int32_t* get_address_of_m_start_1() { return &___m_start_1; }
inline void set_m_start_1(int32_t value)
{
___m_start_1 = value;
}
};
// System.Threading.Thread
struct Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 : public CriticalFinalizerObject_t8B006E1DEE084E781F5C0F3283E9226E28894DD9
{
public:
// System.Threading.InternalThread System.Threading.Thread::internal_thread
InternalThread_tA4C58C2A7D15AF43C3E7507375E6D31DBBE7D192 * ___internal_thread_6;
// System.Object System.Threading.Thread::m_ThreadStartArg
RuntimeObject * ___m_ThreadStartArg_7;
// System.Object System.Threading.Thread::pending_exception
RuntimeObject * ___pending_exception_8;
// System.Security.Principal.IPrincipal System.Threading.Thread::principal
RuntimeObject* ___principal_9;
// System.Int32 System.Threading.Thread::principal_version
int32_t ___principal_version_10;
// System.MulticastDelegate System.Threading.Thread::m_Delegate
MulticastDelegate_t * ___m_Delegate_12;
// System.Threading.ExecutionContext System.Threading.Thread::m_ExecutionContext
ExecutionContext_t0E11C30308A4CC964D8A2EA9132F9BDCE5362C70 * ___m_ExecutionContext_13;
// System.Boolean System.Threading.Thread::m_ExecutionContextBelongsToOuterScope
bool ___m_ExecutionContextBelongsToOuterScope_14;
public:
inline static int32_t get_offset_of_internal_thread_6() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___internal_thread_6)); }
inline InternalThread_tA4C58C2A7D15AF43C3E7507375E6D31DBBE7D192 * get_internal_thread_6() const { return ___internal_thread_6; }
inline InternalThread_tA4C58C2A7D15AF43C3E7507375E6D31DBBE7D192 ** get_address_of_internal_thread_6() { return &___internal_thread_6; }
inline void set_internal_thread_6(InternalThread_tA4C58C2A7D15AF43C3E7507375E6D31DBBE7D192 * value)
{
___internal_thread_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___internal_thread_6), (void*)value);
}
inline static int32_t get_offset_of_m_ThreadStartArg_7() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___m_ThreadStartArg_7)); }
inline RuntimeObject * get_m_ThreadStartArg_7() const { return ___m_ThreadStartArg_7; }
inline RuntimeObject ** get_address_of_m_ThreadStartArg_7() { return &___m_ThreadStartArg_7; }
inline void set_m_ThreadStartArg_7(RuntimeObject * value)
{
___m_ThreadStartArg_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_ThreadStartArg_7), (void*)value);
}
inline static int32_t get_offset_of_pending_exception_8() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___pending_exception_8)); }
inline RuntimeObject * get_pending_exception_8() const { return ___pending_exception_8; }
inline RuntimeObject ** get_address_of_pending_exception_8() { return &___pending_exception_8; }
inline void set_pending_exception_8(RuntimeObject * value)
{
___pending_exception_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&___pending_exception_8), (void*)value);
}
inline static int32_t get_offset_of_principal_9() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___principal_9)); }
inline RuntimeObject* get_principal_9() const { return ___principal_9; }
inline RuntimeObject** get_address_of_principal_9() { return &___principal_9; }
inline void set_principal_9(RuntimeObject* value)
{
___principal_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___principal_9), (void*)value);
}
inline static int32_t get_offset_of_principal_version_10() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___principal_version_10)); }
inline int32_t get_principal_version_10() const { return ___principal_version_10; }
inline int32_t* get_address_of_principal_version_10() { return &___principal_version_10; }
inline void set_principal_version_10(int32_t value)
{
___principal_version_10 = value;
}
inline static int32_t get_offset_of_m_Delegate_12() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___m_Delegate_12)); }
inline MulticastDelegate_t * get_m_Delegate_12() const { return ___m_Delegate_12; }
inline MulticastDelegate_t ** get_address_of_m_Delegate_12() { return &___m_Delegate_12; }
inline void set_m_Delegate_12(MulticastDelegate_t * value)
{
___m_Delegate_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_Delegate_12), (void*)value);
}
inline static int32_t get_offset_of_m_ExecutionContext_13() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___m_ExecutionContext_13)); }
inline ExecutionContext_t0E11C30308A4CC964D8A2EA9132F9BDCE5362C70 * get_m_ExecutionContext_13() const { return ___m_ExecutionContext_13; }
inline ExecutionContext_t0E11C30308A4CC964D8A2EA9132F9BDCE5362C70 ** get_address_of_m_ExecutionContext_13() { return &___m_ExecutionContext_13; }
inline void set_m_ExecutionContext_13(ExecutionContext_t0E11C30308A4CC964D8A2EA9132F9BDCE5362C70 * value)
{
___m_ExecutionContext_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_ExecutionContext_13), (void*)value);
}
inline static int32_t get_offset_of_m_ExecutionContextBelongsToOuterScope_14() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7, ___m_ExecutionContextBelongsToOuterScope_14)); }
inline bool get_m_ExecutionContextBelongsToOuterScope_14() const { return ___m_ExecutionContextBelongsToOuterScope_14; }
inline bool* get_address_of_m_ExecutionContextBelongsToOuterScope_14() { return &___m_ExecutionContextBelongsToOuterScope_14; }
inline void set_m_ExecutionContextBelongsToOuterScope_14(bool value)
{
___m_ExecutionContextBelongsToOuterScope_14 = value;
}
};
struct Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_StaticFields
{
public:
// System.LocalDataStoreMgr System.Threading.Thread::s_LocalDataStoreMgr
LocalDataStoreMgr_t1964DDB9F2BE154BE3159A7507D0D0CCBF8FDCA9 * ___s_LocalDataStoreMgr_0;
// System.Threading.AsyncLocal`1<System.Globalization.CultureInfo> System.Threading.Thread::s_asyncLocalCurrentCulture
AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A * ___s_asyncLocalCurrentCulture_4;
// System.Threading.AsyncLocal`1<System.Globalization.CultureInfo> System.Threading.Thread::s_asyncLocalCurrentUICulture
AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A * ___s_asyncLocalCurrentUICulture_5;
public:
inline static int32_t get_offset_of_s_LocalDataStoreMgr_0() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_StaticFields, ___s_LocalDataStoreMgr_0)); }
inline LocalDataStoreMgr_t1964DDB9F2BE154BE3159A7507D0D0CCBF8FDCA9 * get_s_LocalDataStoreMgr_0() const { return ___s_LocalDataStoreMgr_0; }
inline LocalDataStoreMgr_t1964DDB9F2BE154BE3159A7507D0D0CCBF8FDCA9 ** get_address_of_s_LocalDataStoreMgr_0() { return &___s_LocalDataStoreMgr_0; }
inline void set_s_LocalDataStoreMgr_0(LocalDataStoreMgr_t1964DDB9F2BE154BE3159A7507D0D0CCBF8FDCA9 * value)
{
___s_LocalDataStoreMgr_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_LocalDataStoreMgr_0), (void*)value);
}
inline static int32_t get_offset_of_s_asyncLocalCurrentCulture_4() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_StaticFields, ___s_asyncLocalCurrentCulture_4)); }
inline AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A * get_s_asyncLocalCurrentCulture_4() const { return ___s_asyncLocalCurrentCulture_4; }
inline AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A ** get_address_of_s_asyncLocalCurrentCulture_4() { return &___s_asyncLocalCurrentCulture_4; }
inline void set_s_asyncLocalCurrentCulture_4(AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A * value)
{
___s_asyncLocalCurrentCulture_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_asyncLocalCurrentCulture_4), (void*)value);
}
inline static int32_t get_offset_of_s_asyncLocalCurrentUICulture_5() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_StaticFields, ___s_asyncLocalCurrentUICulture_5)); }
inline AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A * get_s_asyncLocalCurrentUICulture_5() const { return ___s_asyncLocalCurrentUICulture_5; }
inline AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A ** get_address_of_s_asyncLocalCurrentUICulture_5() { return &___s_asyncLocalCurrentUICulture_5; }
inline void set_s_asyncLocalCurrentUICulture_5(AsyncLocal_1_tD39651C2EDD14B144FF3D9B9C716F807EB57655A * value)
{
___s_asyncLocalCurrentUICulture_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_asyncLocalCurrentUICulture_5), (void*)value);
}
};
struct Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_ThreadStaticFields
{
public:
// System.LocalDataStoreHolder System.Threading.Thread::s_LocalDataStore
LocalDataStoreHolder_tE0636E08496405406FD63190AC51EEB2EE51E304 * ___s_LocalDataStore_1;
// System.Globalization.CultureInfo System.Threading.Thread::m_CurrentCulture
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * ___m_CurrentCulture_2;
// System.Globalization.CultureInfo System.Threading.Thread::m_CurrentUICulture
CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * ___m_CurrentUICulture_3;
// System.Threading.Thread System.Threading.Thread::current_thread
Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * ___current_thread_11;
public:
inline static int32_t get_offset_of_s_LocalDataStore_1() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_ThreadStaticFields, ___s_LocalDataStore_1)); }
inline LocalDataStoreHolder_tE0636E08496405406FD63190AC51EEB2EE51E304 * get_s_LocalDataStore_1() const { return ___s_LocalDataStore_1; }
inline LocalDataStoreHolder_tE0636E08496405406FD63190AC51EEB2EE51E304 ** get_address_of_s_LocalDataStore_1() { return &___s_LocalDataStore_1; }
inline void set_s_LocalDataStore_1(LocalDataStoreHolder_tE0636E08496405406FD63190AC51EEB2EE51E304 * value)
{
___s_LocalDataStore_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_LocalDataStore_1), (void*)value);
}
inline static int32_t get_offset_of_m_CurrentCulture_2() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_ThreadStaticFields, ___m_CurrentCulture_2)); }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * get_m_CurrentCulture_2() const { return ___m_CurrentCulture_2; }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F ** get_address_of_m_CurrentCulture_2() { return &___m_CurrentCulture_2; }
inline void set_m_CurrentCulture_2(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * value)
{
___m_CurrentCulture_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_CurrentCulture_2), (void*)value);
}
inline static int32_t get_offset_of_m_CurrentUICulture_3() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_ThreadStaticFields, ___m_CurrentUICulture_3)); }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * get_m_CurrentUICulture_3() const { return ___m_CurrentUICulture_3; }
inline CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F ** get_address_of_m_CurrentUICulture_3() { return &___m_CurrentUICulture_3; }
inline void set_m_CurrentUICulture_3(CultureInfo_t345AC6924134F039ED9A11F3E03F8E91B6A3225F * value)
{
___m_CurrentUICulture_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_CurrentUICulture_3), (void*)value);
}
inline static int32_t get_offset_of_current_thread_11() { return static_cast<int32_t>(offsetof(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7_ThreadStaticFields, ___current_thread_11)); }
inline Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * get_current_thread_11() const { return ___current_thread_11; }
inline Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 ** get_address_of_current_thread_11() { return &___current_thread_11; }
inline void set_current_thread_11(Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * value)
{
___current_thread_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___current_thread_11), (void*)value);
}
};
// System.UInt32
struct UInt32_t4980FA09003AFAAB5A6E361BA2748EA9A005709B
{
public:
// System.UInt32 System.UInt32::m_value
uint32_t ___m_value_0;
public:
inline static int32_t get_offset_of_m_value_0() { return static_cast<int32_t>(offsetof(UInt32_t4980FA09003AFAAB5A6E361BA2748EA9A005709B, ___m_value_0)); }
inline uint32_t get_m_value_0() const { return ___m_value_0; }
inline uint32_t* get_address_of_m_value_0() { return &___m_value_0; }
inline void set_m_value_0(uint32_t value)
{
___m_value_0 = value;
}
};
// System.Void
struct Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017
{
public:
union
{
struct
{
};
uint8_t Void_t22962CB4C05B1D89B55A6E1139F0E87A90987017__padding[1];
};
public:
};
// <PrivateImplementationDetails>
struct U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C : public RuntimeObject
{
public:
public:
};
struct U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C_StaticFields
{
public:
// <PrivateImplementationDetails>___StaticArrayInitTypeSizeU3D120 <PrivateImplementationDetails>::0AA802CD6847EB893FE786B5EA5168B2FDCD7B93
__StaticArrayInitTypeSizeU3D120_t83E233123DD538AA6101D1CB5AE4F5DC639EBC9D ___0AA802CD6847EB893FE786B5EA5168B2FDCD7B93_0;
// <PrivateImplementationDetails>___StaticArrayInitTypeSizeU3D256 <PrivateImplementationDetails>::0C4110BC17D746F018F47B49E0EB0D6590F69939
__StaticArrayInitTypeSizeU3D256_tCCCC326240ED0A827344379DD68205BF9340FF47 ___0C4110BC17D746F018F47B49E0EB0D6590F69939_1;
// <PrivateImplementationDetails>___StaticArrayInitTypeSizeU3D1024 <PrivateImplementationDetails>::20733E1283D873EBE47133A95C233E11B76F5F11
__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C ___20733E1283D873EBE47133A95C233E11B76F5F11_2;
// <PrivateImplementationDetails>___StaticArrayInitTypeSizeU3D1024 <PrivateImplementationDetails>::21F4CBF8283FF1CAEB4A39316A97FC1D6DF1D35E
__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C ___21F4CBF8283FF1CAEB4A39316A97FC1D6DF1D35E_3;
// <PrivateImplementationDetails>___StaticArrayInitTypeSizeU3D1024 <PrivateImplementationDetails>::23DFDCA6F045D4257BF5AC8CB1CF2EFADAFE9B94
__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C ___23DFDCA6F045D4257BF5AC8CB1CF2EFADAFE9B94_4;
// <PrivateImplementationDetails>___StaticArrayInitTypeSizeU3D1024 <PrivateImplementationDetails>::30A0358B25B1372DD598BB4B1AC56AD6B8F08A47
__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C ___30A0358B25B1372DD598BB4B1AC56AD6B8F08A47_5;
// <PrivateImplementationDetails>___StaticArrayInitTypeSizeU3D1024 <PrivateImplementationDetails>::5B5DF5A459E902D96F7DB0FB235A25346CA85C5D
__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C ___5B5DF5A459E902D96F7DB0FB235A25346CA85C5D_6;
// <PrivateImplementationDetails>___StaticArrayInitTypeSizeU3D1024 <PrivateImplementationDetails>::5BE411F1438EAEF33726D855E99011D5FECDDD4E
__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C ___5BE411F1438EAEF33726D855E99011D5FECDDD4E_7;
// <PrivateImplementationDetails>___StaticArrayInitTypeSizeU3D256 <PrivateImplementationDetails>::8F22C9ECE1331718CBD268A9BBFD2F5E451441E3
__StaticArrayInitTypeSizeU3D256_tCCCC326240ED0A827344379DD68205BF9340FF47 ___8F22C9ECE1331718CBD268A9BBFD2F5E451441E3_8;
// <PrivateImplementationDetails>___StaticArrayInitTypeSizeU3D1024 <PrivateImplementationDetails>::A02DD1D8604EA8EC2D2BDA717A93A4EE85F13E53
__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C ___A02DD1D8604EA8EC2D2BDA717A93A4EE85F13E53_9;
// <PrivateImplementationDetails>___StaticArrayInitTypeSizeU3D1024 <PrivateImplementationDetails>::AE2F76ECEF8B08F0BC7EA95DCFE945E1727927C9
__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C ___AE2F76ECEF8B08F0BC7EA95DCFE945E1727927C9_10;
public:
inline static int32_t get_offset_of_U30AA802CD6847EB893FE786B5EA5168B2FDCD7B93_0() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C_StaticFields, ___0AA802CD6847EB893FE786B5EA5168B2FDCD7B93_0)); }
inline __StaticArrayInitTypeSizeU3D120_t83E233123DD538AA6101D1CB5AE4F5DC639EBC9D get_U30AA802CD6847EB893FE786B5EA5168B2FDCD7B93_0() const { return ___0AA802CD6847EB893FE786B5EA5168B2FDCD7B93_0; }
inline __StaticArrayInitTypeSizeU3D120_t83E233123DD538AA6101D1CB5AE4F5DC639EBC9D * get_address_of_U30AA802CD6847EB893FE786B5EA5168B2FDCD7B93_0() { return &___0AA802CD6847EB893FE786B5EA5168B2FDCD7B93_0; }
inline void set_U30AA802CD6847EB893FE786B5EA5168B2FDCD7B93_0(__StaticArrayInitTypeSizeU3D120_t83E233123DD538AA6101D1CB5AE4F5DC639EBC9D value)
{
___0AA802CD6847EB893FE786B5EA5168B2FDCD7B93_0 = value;
}
inline static int32_t get_offset_of_U30C4110BC17D746F018F47B49E0EB0D6590F69939_1() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C_StaticFields, ___0C4110BC17D746F018F47B49E0EB0D6590F69939_1)); }
inline __StaticArrayInitTypeSizeU3D256_tCCCC326240ED0A827344379DD68205BF9340FF47 get_U30C4110BC17D746F018F47B49E0EB0D6590F69939_1() const { return ___0C4110BC17D746F018F47B49E0EB0D6590F69939_1; }
inline __StaticArrayInitTypeSizeU3D256_tCCCC326240ED0A827344379DD68205BF9340FF47 * get_address_of_U30C4110BC17D746F018F47B49E0EB0D6590F69939_1() { return &___0C4110BC17D746F018F47B49E0EB0D6590F69939_1; }
inline void set_U30C4110BC17D746F018F47B49E0EB0D6590F69939_1(__StaticArrayInitTypeSizeU3D256_tCCCC326240ED0A827344379DD68205BF9340FF47 value)
{
___0C4110BC17D746F018F47B49E0EB0D6590F69939_1 = value;
}
inline static int32_t get_offset_of_U320733E1283D873EBE47133A95C233E11B76F5F11_2() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C_StaticFields, ___20733E1283D873EBE47133A95C233E11B76F5F11_2)); }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C get_U320733E1283D873EBE47133A95C233E11B76F5F11_2() const { return ___20733E1283D873EBE47133A95C233E11B76F5F11_2; }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C * get_address_of_U320733E1283D873EBE47133A95C233E11B76F5F11_2() { return &___20733E1283D873EBE47133A95C233E11B76F5F11_2; }
inline void set_U320733E1283D873EBE47133A95C233E11B76F5F11_2(__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C value)
{
___20733E1283D873EBE47133A95C233E11B76F5F11_2 = value;
}
inline static int32_t get_offset_of_U321F4CBF8283FF1CAEB4A39316A97FC1D6DF1D35E_3() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C_StaticFields, ___21F4CBF8283FF1CAEB4A39316A97FC1D6DF1D35E_3)); }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C get_U321F4CBF8283FF1CAEB4A39316A97FC1D6DF1D35E_3() const { return ___21F4CBF8283FF1CAEB4A39316A97FC1D6DF1D35E_3; }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C * get_address_of_U321F4CBF8283FF1CAEB4A39316A97FC1D6DF1D35E_3() { return &___21F4CBF8283FF1CAEB4A39316A97FC1D6DF1D35E_3; }
inline void set_U321F4CBF8283FF1CAEB4A39316A97FC1D6DF1D35E_3(__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C value)
{
___21F4CBF8283FF1CAEB4A39316A97FC1D6DF1D35E_3 = value;
}
inline static int32_t get_offset_of_U323DFDCA6F045D4257BF5AC8CB1CF2EFADAFE9B94_4() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C_StaticFields, ___23DFDCA6F045D4257BF5AC8CB1CF2EFADAFE9B94_4)); }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C get_U323DFDCA6F045D4257BF5AC8CB1CF2EFADAFE9B94_4() const { return ___23DFDCA6F045D4257BF5AC8CB1CF2EFADAFE9B94_4; }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C * get_address_of_U323DFDCA6F045D4257BF5AC8CB1CF2EFADAFE9B94_4() { return &___23DFDCA6F045D4257BF5AC8CB1CF2EFADAFE9B94_4; }
inline void set_U323DFDCA6F045D4257BF5AC8CB1CF2EFADAFE9B94_4(__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C value)
{
___23DFDCA6F045D4257BF5AC8CB1CF2EFADAFE9B94_4 = value;
}
inline static int32_t get_offset_of_U330A0358B25B1372DD598BB4B1AC56AD6B8F08A47_5() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C_StaticFields, ___30A0358B25B1372DD598BB4B1AC56AD6B8F08A47_5)); }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C get_U330A0358B25B1372DD598BB4B1AC56AD6B8F08A47_5() const { return ___30A0358B25B1372DD598BB4B1AC56AD6B8F08A47_5; }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C * get_address_of_U330A0358B25B1372DD598BB4B1AC56AD6B8F08A47_5() { return &___30A0358B25B1372DD598BB4B1AC56AD6B8F08A47_5; }
inline void set_U330A0358B25B1372DD598BB4B1AC56AD6B8F08A47_5(__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C value)
{
___30A0358B25B1372DD598BB4B1AC56AD6B8F08A47_5 = value;
}
inline static int32_t get_offset_of_U35B5DF5A459E902D96F7DB0FB235A25346CA85C5D_6() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C_StaticFields, ___5B5DF5A459E902D96F7DB0FB235A25346CA85C5D_6)); }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C get_U35B5DF5A459E902D96F7DB0FB235A25346CA85C5D_6() const { return ___5B5DF5A459E902D96F7DB0FB235A25346CA85C5D_6; }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C * get_address_of_U35B5DF5A459E902D96F7DB0FB235A25346CA85C5D_6() { return &___5B5DF5A459E902D96F7DB0FB235A25346CA85C5D_6; }
inline void set_U35B5DF5A459E902D96F7DB0FB235A25346CA85C5D_6(__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C value)
{
___5B5DF5A459E902D96F7DB0FB235A25346CA85C5D_6 = value;
}
inline static int32_t get_offset_of_U35BE411F1438EAEF33726D855E99011D5FECDDD4E_7() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C_StaticFields, ___5BE411F1438EAEF33726D855E99011D5FECDDD4E_7)); }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C get_U35BE411F1438EAEF33726D855E99011D5FECDDD4E_7() const { return ___5BE411F1438EAEF33726D855E99011D5FECDDD4E_7; }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C * get_address_of_U35BE411F1438EAEF33726D855E99011D5FECDDD4E_7() { return &___5BE411F1438EAEF33726D855E99011D5FECDDD4E_7; }
inline void set_U35BE411F1438EAEF33726D855E99011D5FECDDD4E_7(__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C value)
{
___5BE411F1438EAEF33726D855E99011D5FECDDD4E_7 = value;
}
inline static int32_t get_offset_of_U38F22C9ECE1331718CBD268A9BBFD2F5E451441E3_8() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C_StaticFields, ___8F22C9ECE1331718CBD268A9BBFD2F5E451441E3_8)); }
inline __StaticArrayInitTypeSizeU3D256_tCCCC326240ED0A827344379DD68205BF9340FF47 get_U38F22C9ECE1331718CBD268A9BBFD2F5E451441E3_8() const { return ___8F22C9ECE1331718CBD268A9BBFD2F5E451441E3_8; }
inline __StaticArrayInitTypeSizeU3D256_tCCCC326240ED0A827344379DD68205BF9340FF47 * get_address_of_U38F22C9ECE1331718CBD268A9BBFD2F5E451441E3_8() { return &___8F22C9ECE1331718CBD268A9BBFD2F5E451441E3_8; }
inline void set_U38F22C9ECE1331718CBD268A9BBFD2F5E451441E3_8(__StaticArrayInitTypeSizeU3D256_tCCCC326240ED0A827344379DD68205BF9340FF47 value)
{
___8F22C9ECE1331718CBD268A9BBFD2F5E451441E3_8 = value;
}
inline static int32_t get_offset_of_A02DD1D8604EA8EC2D2BDA717A93A4EE85F13E53_9() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C_StaticFields, ___A02DD1D8604EA8EC2D2BDA717A93A4EE85F13E53_9)); }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C get_A02DD1D8604EA8EC2D2BDA717A93A4EE85F13E53_9() const { return ___A02DD1D8604EA8EC2D2BDA717A93A4EE85F13E53_9; }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C * get_address_of_A02DD1D8604EA8EC2D2BDA717A93A4EE85F13E53_9() { return &___A02DD1D8604EA8EC2D2BDA717A93A4EE85F13E53_9; }
inline void set_A02DD1D8604EA8EC2D2BDA717A93A4EE85F13E53_9(__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C value)
{
___A02DD1D8604EA8EC2D2BDA717A93A4EE85F13E53_9 = value;
}
inline static int32_t get_offset_of_AE2F76ECEF8B08F0BC7EA95DCFE945E1727927C9_10() { return static_cast<int32_t>(offsetof(U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C_StaticFields, ___AE2F76ECEF8B08F0BC7EA95DCFE945E1727927C9_10)); }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C get_AE2F76ECEF8B08F0BC7EA95DCFE945E1727927C9_10() const { return ___AE2F76ECEF8B08F0BC7EA95DCFE945E1727927C9_10; }
inline __StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C * get_address_of_AE2F76ECEF8B08F0BC7EA95DCFE945E1727927C9_10() { return &___AE2F76ECEF8B08F0BC7EA95DCFE945E1727927C9_10; }
inline void set_AE2F76ECEF8B08F0BC7EA95DCFE945E1727927C9_10(__StaticArrayInitTypeSizeU3D1024_t336389AC57307AEC77791F09CF655CD3EF917B7C value)
{
___AE2F76ECEF8B08F0BC7EA95DCFE945E1727927C9_10 = value;
}
};
// System.Exception
struct Exception_t : public RuntimeObject
{
public:
// System.String System.Exception::_className
String_t* ____className_1;
// System.String System.Exception::_message
String_t* ____message_2;
// System.Collections.IDictionary System.Exception::_data
RuntimeObject* ____data_3;
// System.Exception System.Exception::_innerException
Exception_t * ____innerException_4;
// System.String System.Exception::_helpURL
String_t* ____helpURL_5;
// System.Object System.Exception::_stackTrace
RuntimeObject * ____stackTrace_6;
// System.String System.Exception::_stackTraceString
String_t* ____stackTraceString_7;
// System.String System.Exception::_remoteStackTraceString
String_t* ____remoteStackTraceString_8;
// System.Int32 System.Exception::_remoteStackIndex
int32_t ____remoteStackIndex_9;
// System.Object System.Exception::_dynamicMethods
RuntimeObject * ____dynamicMethods_10;
// System.Int32 System.Exception::_HResult
int32_t ____HResult_11;
// System.String System.Exception::_source
String_t* ____source_12;
// System.Runtime.Serialization.SafeSerializationManager System.Exception::_safeSerializationManager
SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * ____safeSerializationManager_13;
// System.Diagnostics.StackTrace[] System.Exception::captured_traces
StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* ___captured_traces_14;
// System.IntPtr[] System.Exception::native_trace_ips
IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* ___native_trace_ips_15;
public:
inline static int32_t get_offset_of__className_1() { return static_cast<int32_t>(offsetof(Exception_t, ____className_1)); }
inline String_t* get__className_1() const { return ____className_1; }
inline String_t** get_address_of__className_1() { return &____className_1; }
inline void set__className_1(String_t* value)
{
____className_1 = value;
Il2CppCodeGenWriteBarrier((void**)(&____className_1), (void*)value);
}
inline static int32_t get_offset_of__message_2() { return static_cast<int32_t>(offsetof(Exception_t, ____message_2)); }
inline String_t* get__message_2() const { return ____message_2; }
inline String_t** get_address_of__message_2() { return &____message_2; }
inline void set__message_2(String_t* value)
{
____message_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&____message_2), (void*)value);
}
inline static int32_t get_offset_of__data_3() { return static_cast<int32_t>(offsetof(Exception_t, ____data_3)); }
inline RuntimeObject* get__data_3() const { return ____data_3; }
inline RuntimeObject** get_address_of__data_3() { return &____data_3; }
inline void set__data_3(RuntimeObject* value)
{
____data_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&____data_3), (void*)value);
}
inline static int32_t get_offset_of__innerException_4() { return static_cast<int32_t>(offsetof(Exception_t, ____innerException_4)); }
inline Exception_t * get__innerException_4() const { return ____innerException_4; }
inline Exception_t ** get_address_of__innerException_4() { return &____innerException_4; }
inline void set__innerException_4(Exception_t * value)
{
____innerException_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&____innerException_4), (void*)value);
}
inline static int32_t get_offset_of__helpURL_5() { return static_cast<int32_t>(offsetof(Exception_t, ____helpURL_5)); }
inline String_t* get__helpURL_5() const { return ____helpURL_5; }
inline String_t** get_address_of__helpURL_5() { return &____helpURL_5; }
inline void set__helpURL_5(String_t* value)
{
____helpURL_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&____helpURL_5), (void*)value);
}
inline static int32_t get_offset_of__stackTrace_6() { return static_cast<int32_t>(offsetof(Exception_t, ____stackTrace_6)); }
inline RuntimeObject * get__stackTrace_6() const { return ____stackTrace_6; }
inline RuntimeObject ** get_address_of__stackTrace_6() { return &____stackTrace_6; }
inline void set__stackTrace_6(RuntimeObject * value)
{
____stackTrace_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&____stackTrace_6), (void*)value);
}
inline static int32_t get_offset_of__stackTraceString_7() { return static_cast<int32_t>(offsetof(Exception_t, ____stackTraceString_7)); }
inline String_t* get__stackTraceString_7() const { return ____stackTraceString_7; }
inline String_t** get_address_of__stackTraceString_7() { return &____stackTraceString_7; }
inline void set__stackTraceString_7(String_t* value)
{
____stackTraceString_7 = value;
Il2CppCodeGenWriteBarrier((void**)(&____stackTraceString_7), (void*)value);
}
inline static int32_t get_offset_of__remoteStackTraceString_8() { return static_cast<int32_t>(offsetof(Exception_t, ____remoteStackTraceString_8)); }
inline String_t* get__remoteStackTraceString_8() const { return ____remoteStackTraceString_8; }
inline String_t** get_address_of__remoteStackTraceString_8() { return &____remoteStackTraceString_8; }
inline void set__remoteStackTraceString_8(String_t* value)
{
____remoteStackTraceString_8 = value;
Il2CppCodeGenWriteBarrier((void**)(&____remoteStackTraceString_8), (void*)value);
}
inline static int32_t get_offset_of__remoteStackIndex_9() { return static_cast<int32_t>(offsetof(Exception_t, ____remoteStackIndex_9)); }
inline int32_t get__remoteStackIndex_9() const { return ____remoteStackIndex_9; }
inline int32_t* get_address_of__remoteStackIndex_9() { return &____remoteStackIndex_9; }
inline void set__remoteStackIndex_9(int32_t value)
{
____remoteStackIndex_9 = value;
}
inline static int32_t get_offset_of__dynamicMethods_10() { return static_cast<int32_t>(offsetof(Exception_t, ____dynamicMethods_10)); }
inline RuntimeObject * get__dynamicMethods_10() const { return ____dynamicMethods_10; }
inline RuntimeObject ** get_address_of__dynamicMethods_10() { return &____dynamicMethods_10; }
inline void set__dynamicMethods_10(RuntimeObject * value)
{
____dynamicMethods_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&____dynamicMethods_10), (void*)value);
}
inline static int32_t get_offset_of__HResult_11() { return static_cast<int32_t>(offsetof(Exception_t, ____HResult_11)); }
inline int32_t get__HResult_11() const { return ____HResult_11; }
inline int32_t* get_address_of__HResult_11() { return &____HResult_11; }
inline void set__HResult_11(int32_t value)
{
____HResult_11 = value;
}
inline static int32_t get_offset_of__source_12() { return static_cast<int32_t>(offsetof(Exception_t, ____source_12)); }
inline String_t* get__source_12() const { return ____source_12; }
inline String_t** get_address_of__source_12() { return &____source_12; }
inline void set__source_12(String_t* value)
{
____source_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&____source_12), (void*)value);
}
inline static int32_t get_offset_of__safeSerializationManager_13() { return static_cast<int32_t>(offsetof(Exception_t, ____safeSerializationManager_13)); }
inline SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * get__safeSerializationManager_13() const { return ____safeSerializationManager_13; }
inline SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 ** get_address_of__safeSerializationManager_13() { return &____safeSerializationManager_13; }
inline void set__safeSerializationManager_13(SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * value)
{
____safeSerializationManager_13 = value;
Il2CppCodeGenWriteBarrier((void**)(&____safeSerializationManager_13), (void*)value);
}
inline static int32_t get_offset_of_captured_traces_14() { return static_cast<int32_t>(offsetof(Exception_t, ___captured_traces_14)); }
inline StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* get_captured_traces_14() const { return ___captured_traces_14; }
inline StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196** get_address_of_captured_traces_14() { return &___captured_traces_14; }
inline void set_captured_traces_14(StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* value)
{
___captured_traces_14 = value;
Il2CppCodeGenWriteBarrier((void**)(&___captured_traces_14), (void*)value);
}
inline static int32_t get_offset_of_native_trace_ips_15() { return static_cast<int32_t>(offsetof(Exception_t, ___native_trace_ips_15)); }
inline IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* get_native_trace_ips_15() const { return ___native_trace_ips_15; }
inline IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD** get_address_of_native_trace_ips_15() { return &___native_trace_ips_15; }
inline void set_native_trace_ips_15(IntPtrU5BU5D_t4DC01DCB9A6DF6C9792A6513595D7A11E637DCDD* value)
{
___native_trace_ips_15 = value;
Il2CppCodeGenWriteBarrier((void**)(&___native_trace_ips_15), (void*)value);
}
};
struct Exception_t_StaticFields
{
public:
// System.Object System.Exception::s_EDILock
RuntimeObject * ___s_EDILock_0;
public:
inline static int32_t get_offset_of_s_EDILock_0() { return static_cast<int32_t>(offsetof(Exception_t_StaticFields, ___s_EDILock_0)); }
inline RuntimeObject * get_s_EDILock_0() const { return ___s_EDILock_0; }
inline RuntimeObject ** get_address_of_s_EDILock_0() { return &___s_EDILock_0; }
inline void set_s_EDILock_0(RuntimeObject * value)
{
___s_EDILock_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_EDILock_0), (void*)value);
}
};
// Native definition for P/Invoke marshalling of System.Exception
struct Exception_t_marshaled_pinvoke
{
char* ____className_1;
char* ____message_2;
RuntimeObject* ____data_3;
Exception_t_marshaled_pinvoke* ____innerException_4;
char* ____helpURL_5;
Il2CppIUnknown* ____stackTrace_6;
char* ____stackTraceString_7;
char* ____remoteStackTraceString_8;
int32_t ____remoteStackIndex_9;
Il2CppIUnknown* ____dynamicMethods_10;
int32_t ____HResult_11;
char* ____source_12;
SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * ____safeSerializationManager_13;
StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* ___captured_traces_14;
Il2CppSafeArray/*INT*/* ___native_trace_ips_15;
};
// Native definition for COM marshalling of System.Exception
struct Exception_t_marshaled_com
{
Il2CppChar* ____className_1;
Il2CppChar* ____message_2;
RuntimeObject* ____data_3;
Exception_t_marshaled_com* ____innerException_4;
Il2CppChar* ____helpURL_5;
Il2CppIUnknown* ____stackTrace_6;
Il2CppChar* ____stackTraceString_7;
Il2CppChar* ____remoteStackTraceString_8;
int32_t ____remoteStackIndex_9;
Il2CppIUnknown* ____dynamicMethods_10;
int32_t ____HResult_11;
Il2CppChar* ____source_12;
SafeSerializationManager_t4A754D86B0F784B18CBC36C073BA564BED109770 * ____safeSerializationManager_13;
StackTraceU5BU5D_t855F09649EA34DEE7C1B6F088E0538E3CCC3F196* ___captured_traces_14;
Il2CppSafeArray/*INT*/* ___native_trace_ips_15;
};
// System.RuntimeFieldHandle
struct RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF
{
public:
// System.IntPtr System.RuntimeFieldHandle::value
intptr_t ___value_0;
public:
inline static int32_t get_offset_of_value_0() { return static_cast<int32_t>(offsetof(RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF, ___value_0)); }
inline intptr_t get_value_0() const { return ___value_0; }
inline intptr_t* get_address_of_value_0() { return &___value_0; }
inline void set_value_0(intptr_t value)
{
___value_0 = value;
}
};
// System.Security.Cryptography.CipherMode
struct CipherMode_t1DC3069D617AC3D17A2608F5BB36C0F115D229DF
{
public:
// System.Int32 System.Security.Cryptography.CipherMode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(CipherMode_t1DC3069D617AC3D17A2608F5BB36C0F115D229DF, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Security.Cryptography.PaddingMode
struct PaddingMode_tA6F228B2795D29C9554F2D6824DB9FF67519A0E0
{
public:
// System.Int32 System.Security.Cryptography.PaddingMode::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(PaddingMode_tA6F228B2795D29C9554F2D6824DB9FF67519A0E0, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Threading.LockRecursionPolicy
struct LockRecursionPolicy_t027CC8D80475596F2EE49E46723799BAAEFE774B
{
public:
// System.Int32 System.Threading.LockRecursionPolicy::value__
int32_t ___value___2;
public:
inline static int32_t get_offset_of_value___2() { return static_cast<int32_t>(offsetof(LockRecursionPolicy_t027CC8D80475596F2EE49E46723799BAAEFE774B, ___value___2)); }
inline int32_t get_value___2() const { return ___value___2; }
inline int32_t* get_address_of_value___2() { return &___value___2; }
inline void set_value___2(int32_t value)
{
___value___2 = value;
}
};
// System.Threading.WaitHandle
struct WaitHandle_tFD46B5B45A6BB296EA3A104C91DF2A7C03C10AC6 : public MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF
{
public:
// System.IntPtr System.Threading.WaitHandle::waitHandle
intptr_t ___waitHandle_3;
// Microsoft.Win32.SafeHandles.SafeWaitHandle modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.WaitHandle::safeWaitHandle
SafeWaitHandle_t51DB35FF382E636FF3B868D87816733894D46CF2 * ___safeWaitHandle_4;
// System.Boolean System.Threading.WaitHandle::hasThreadAffinity
bool ___hasThreadAffinity_5;
public:
inline static int32_t get_offset_of_waitHandle_3() { return static_cast<int32_t>(offsetof(WaitHandle_tFD46B5B45A6BB296EA3A104C91DF2A7C03C10AC6, ___waitHandle_3)); }
inline intptr_t get_waitHandle_3() const { return ___waitHandle_3; }
inline intptr_t* get_address_of_waitHandle_3() { return &___waitHandle_3; }
inline void set_waitHandle_3(intptr_t value)
{
___waitHandle_3 = value;
}
inline static int32_t get_offset_of_safeWaitHandle_4() { return static_cast<int32_t>(offsetof(WaitHandle_tFD46B5B45A6BB296EA3A104C91DF2A7C03C10AC6, ___safeWaitHandle_4)); }
inline SafeWaitHandle_t51DB35FF382E636FF3B868D87816733894D46CF2 * get_safeWaitHandle_4() const { return ___safeWaitHandle_4; }
inline SafeWaitHandle_t51DB35FF382E636FF3B868D87816733894D46CF2 ** get_address_of_safeWaitHandle_4() { return &___safeWaitHandle_4; }
inline void set_safeWaitHandle_4(SafeWaitHandle_t51DB35FF382E636FF3B868D87816733894D46CF2 * value)
{
___safeWaitHandle_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___safeWaitHandle_4), (void*)value);
}
inline static int32_t get_offset_of_hasThreadAffinity_5() { return static_cast<int32_t>(offsetof(WaitHandle_tFD46B5B45A6BB296EA3A104C91DF2A7C03C10AC6, ___hasThreadAffinity_5)); }
inline bool get_hasThreadAffinity_5() const { return ___hasThreadAffinity_5; }
inline bool* get_address_of_hasThreadAffinity_5() { return &___hasThreadAffinity_5; }
inline void set_hasThreadAffinity_5(bool value)
{
___hasThreadAffinity_5 = value;
}
};
struct WaitHandle_tFD46B5B45A6BB296EA3A104C91DF2A7C03C10AC6_StaticFields
{
public:
// System.IntPtr System.Threading.WaitHandle::InvalidHandle
intptr_t ___InvalidHandle_10;
public:
inline static int32_t get_offset_of_InvalidHandle_10() { return static_cast<int32_t>(offsetof(WaitHandle_tFD46B5B45A6BB296EA3A104C91DF2A7C03C10AC6_StaticFields, ___InvalidHandle_10)); }
inline intptr_t get_InvalidHandle_10() const { return ___InvalidHandle_10; }
inline intptr_t* get_address_of_InvalidHandle_10() { return &___InvalidHandle_10; }
inline void set_InvalidHandle_10(intptr_t value)
{
___InvalidHandle_10 = value;
}
};
// Native definition for P/Invoke marshalling of System.Threading.WaitHandle
struct WaitHandle_tFD46B5B45A6BB296EA3A104C91DF2A7C03C10AC6_marshaled_pinvoke : public MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF_marshaled_pinvoke
{
intptr_t ___waitHandle_3;
void* ___safeWaitHandle_4;
int32_t ___hasThreadAffinity_5;
};
// Native definition for COM marshalling of System.Threading.WaitHandle
struct WaitHandle_tFD46B5B45A6BB296EA3A104C91DF2A7C03C10AC6_marshaled_com : public MarshalByRefObject_tC4577953D0A44D0AB8597CFA868E01C858B1C9AF_marshaled_com
{
intptr_t ___waitHandle_3;
void* ___safeWaitHandle_4;
int32_t ___hasThreadAffinity_5;
};
// Mono.Security.Cryptography.SymmetricTransform
struct SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750 : public RuntimeObject
{
public:
// System.Security.Cryptography.SymmetricAlgorithm Mono.Security.Cryptography.SymmetricTransform::algo
SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * ___algo_0;
// System.Boolean Mono.Security.Cryptography.SymmetricTransform::encrypt
bool ___encrypt_1;
// System.Int32 Mono.Security.Cryptography.SymmetricTransform::BlockSizeByte
int32_t ___BlockSizeByte_2;
// System.Byte[] Mono.Security.Cryptography.SymmetricTransform::temp
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___temp_3;
// System.Byte[] Mono.Security.Cryptography.SymmetricTransform::temp2
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___temp2_4;
// System.Byte[] Mono.Security.Cryptography.SymmetricTransform::workBuff
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___workBuff_5;
// System.Byte[] Mono.Security.Cryptography.SymmetricTransform::workout
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___workout_6;
// System.Security.Cryptography.PaddingMode Mono.Security.Cryptography.SymmetricTransform::padmode
int32_t ___padmode_7;
// System.Int32 Mono.Security.Cryptography.SymmetricTransform::FeedBackByte
int32_t ___FeedBackByte_8;
// System.Boolean Mono.Security.Cryptography.SymmetricTransform::m_disposed
bool ___m_disposed_9;
// System.Boolean Mono.Security.Cryptography.SymmetricTransform::lastBlock
bool ___lastBlock_10;
// System.Security.Cryptography.RandomNumberGenerator Mono.Security.Cryptography.SymmetricTransform::_rng
RandomNumberGenerator_t12277F7F965BA79C54E4B3BFABD27A5FFB725EE2 * ____rng_11;
public:
inline static int32_t get_offset_of_algo_0() { return static_cast<int32_t>(offsetof(SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750, ___algo_0)); }
inline SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * get_algo_0() const { return ___algo_0; }
inline SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 ** get_address_of_algo_0() { return &___algo_0; }
inline void set_algo_0(SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * value)
{
___algo_0 = value;
Il2CppCodeGenWriteBarrier((void**)(&___algo_0), (void*)value);
}
inline static int32_t get_offset_of_encrypt_1() { return static_cast<int32_t>(offsetof(SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750, ___encrypt_1)); }
inline bool get_encrypt_1() const { return ___encrypt_1; }
inline bool* get_address_of_encrypt_1() { return &___encrypt_1; }
inline void set_encrypt_1(bool value)
{
___encrypt_1 = value;
}
inline static int32_t get_offset_of_BlockSizeByte_2() { return static_cast<int32_t>(offsetof(SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750, ___BlockSizeByte_2)); }
inline int32_t get_BlockSizeByte_2() const { return ___BlockSizeByte_2; }
inline int32_t* get_address_of_BlockSizeByte_2() { return &___BlockSizeByte_2; }
inline void set_BlockSizeByte_2(int32_t value)
{
___BlockSizeByte_2 = value;
}
inline static int32_t get_offset_of_temp_3() { return static_cast<int32_t>(offsetof(SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750, ___temp_3)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_temp_3() const { return ___temp_3; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_temp_3() { return &___temp_3; }
inline void set_temp_3(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___temp_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___temp_3), (void*)value);
}
inline static int32_t get_offset_of_temp2_4() { return static_cast<int32_t>(offsetof(SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750, ___temp2_4)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_temp2_4() const { return ___temp2_4; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_temp2_4() { return &___temp2_4; }
inline void set_temp2_4(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___temp2_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___temp2_4), (void*)value);
}
inline static int32_t get_offset_of_workBuff_5() { return static_cast<int32_t>(offsetof(SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750, ___workBuff_5)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_workBuff_5() const { return ___workBuff_5; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_workBuff_5() { return &___workBuff_5; }
inline void set_workBuff_5(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___workBuff_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___workBuff_5), (void*)value);
}
inline static int32_t get_offset_of_workout_6() { return static_cast<int32_t>(offsetof(SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750, ___workout_6)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_workout_6() const { return ___workout_6; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_workout_6() { return &___workout_6; }
inline void set_workout_6(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___workout_6 = value;
Il2CppCodeGenWriteBarrier((void**)(&___workout_6), (void*)value);
}
inline static int32_t get_offset_of_padmode_7() { return static_cast<int32_t>(offsetof(SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750, ___padmode_7)); }
inline int32_t get_padmode_7() const { return ___padmode_7; }
inline int32_t* get_address_of_padmode_7() { return &___padmode_7; }
inline void set_padmode_7(int32_t value)
{
___padmode_7 = value;
}
inline static int32_t get_offset_of_FeedBackByte_8() { return static_cast<int32_t>(offsetof(SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750, ___FeedBackByte_8)); }
inline int32_t get_FeedBackByte_8() const { return ___FeedBackByte_8; }
inline int32_t* get_address_of_FeedBackByte_8() { return &___FeedBackByte_8; }
inline void set_FeedBackByte_8(int32_t value)
{
___FeedBackByte_8 = value;
}
inline static int32_t get_offset_of_m_disposed_9() { return static_cast<int32_t>(offsetof(SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750, ___m_disposed_9)); }
inline bool get_m_disposed_9() const { return ___m_disposed_9; }
inline bool* get_address_of_m_disposed_9() { return &___m_disposed_9; }
inline void set_m_disposed_9(bool value)
{
___m_disposed_9 = value;
}
inline static int32_t get_offset_of_lastBlock_10() { return static_cast<int32_t>(offsetof(SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750, ___lastBlock_10)); }
inline bool get_lastBlock_10() const { return ___lastBlock_10; }
inline bool* get_address_of_lastBlock_10() { return &___lastBlock_10; }
inline void set_lastBlock_10(bool value)
{
___lastBlock_10 = value;
}
inline static int32_t get_offset_of__rng_11() { return static_cast<int32_t>(offsetof(SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750, ____rng_11)); }
inline RandomNumberGenerator_t12277F7F965BA79C54E4B3BFABD27A5FFB725EE2 * get__rng_11() const { return ____rng_11; }
inline RandomNumberGenerator_t12277F7F965BA79C54E4B3BFABD27A5FFB725EE2 ** get_address_of__rng_11() { return &____rng_11; }
inline void set__rng_11(RandomNumberGenerator_t12277F7F965BA79C54E4B3BFABD27A5FFB725EE2 * value)
{
____rng_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rng_11), (void*)value);
}
};
// System.Security.Cryptography.SymmetricAlgorithm
struct SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 : public RuntimeObject
{
public:
// System.Int32 System.Security.Cryptography.SymmetricAlgorithm::BlockSizeValue
int32_t ___BlockSizeValue_0;
// System.Int32 System.Security.Cryptography.SymmetricAlgorithm::FeedbackSizeValue
int32_t ___FeedbackSizeValue_1;
// System.Byte[] System.Security.Cryptography.SymmetricAlgorithm::IVValue
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___IVValue_2;
// System.Byte[] System.Security.Cryptography.SymmetricAlgorithm::KeyValue
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___KeyValue_3;
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.SymmetricAlgorithm::LegalBlockSizesValue
KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* ___LegalBlockSizesValue_4;
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.SymmetricAlgorithm::LegalKeySizesValue
KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* ___LegalKeySizesValue_5;
// System.Int32 System.Security.Cryptography.SymmetricAlgorithm::KeySizeValue
int32_t ___KeySizeValue_6;
// System.Security.Cryptography.CipherMode System.Security.Cryptography.SymmetricAlgorithm::ModeValue
int32_t ___ModeValue_7;
// System.Security.Cryptography.PaddingMode System.Security.Cryptography.SymmetricAlgorithm::PaddingValue
int32_t ___PaddingValue_8;
public:
inline static int32_t get_offset_of_BlockSizeValue_0() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789, ___BlockSizeValue_0)); }
inline int32_t get_BlockSizeValue_0() const { return ___BlockSizeValue_0; }
inline int32_t* get_address_of_BlockSizeValue_0() { return &___BlockSizeValue_0; }
inline void set_BlockSizeValue_0(int32_t value)
{
___BlockSizeValue_0 = value;
}
inline static int32_t get_offset_of_FeedbackSizeValue_1() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789, ___FeedbackSizeValue_1)); }
inline int32_t get_FeedbackSizeValue_1() const { return ___FeedbackSizeValue_1; }
inline int32_t* get_address_of_FeedbackSizeValue_1() { return &___FeedbackSizeValue_1; }
inline void set_FeedbackSizeValue_1(int32_t value)
{
___FeedbackSizeValue_1 = value;
}
inline static int32_t get_offset_of_IVValue_2() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789, ___IVValue_2)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_IVValue_2() const { return ___IVValue_2; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_IVValue_2() { return &___IVValue_2; }
inline void set_IVValue_2(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___IVValue_2 = value;
Il2CppCodeGenWriteBarrier((void**)(&___IVValue_2), (void*)value);
}
inline static int32_t get_offset_of_KeyValue_3() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789, ___KeyValue_3)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_KeyValue_3() const { return ___KeyValue_3; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_KeyValue_3() { return &___KeyValue_3; }
inline void set_KeyValue_3(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___KeyValue_3 = value;
Il2CppCodeGenWriteBarrier((void**)(&___KeyValue_3), (void*)value);
}
inline static int32_t get_offset_of_LegalBlockSizesValue_4() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789, ___LegalBlockSizesValue_4)); }
inline KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* get_LegalBlockSizesValue_4() const { return ___LegalBlockSizesValue_4; }
inline KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E** get_address_of_LegalBlockSizesValue_4() { return &___LegalBlockSizesValue_4; }
inline void set_LegalBlockSizesValue_4(KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* value)
{
___LegalBlockSizesValue_4 = value;
Il2CppCodeGenWriteBarrier((void**)(&___LegalBlockSizesValue_4), (void*)value);
}
inline static int32_t get_offset_of_LegalKeySizesValue_5() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789, ___LegalKeySizesValue_5)); }
inline KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* get_LegalKeySizesValue_5() const { return ___LegalKeySizesValue_5; }
inline KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E** get_address_of_LegalKeySizesValue_5() { return &___LegalKeySizesValue_5; }
inline void set_LegalKeySizesValue_5(KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* value)
{
___LegalKeySizesValue_5 = value;
Il2CppCodeGenWriteBarrier((void**)(&___LegalKeySizesValue_5), (void*)value);
}
inline static int32_t get_offset_of_KeySizeValue_6() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789, ___KeySizeValue_6)); }
inline int32_t get_KeySizeValue_6() const { return ___KeySizeValue_6; }
inline int32_t* get_address_of_KeySizeValue_6() { return &___KeySizeValue_6; }
inline void set_KeySizeValue_6(int32_t value)
{
___KeySizeValue_6 = value;
}
inline static int32_t get_offset_of_ModeValue_7() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789, ___ModeValue_7)); }
inline int32_t get_ModeValue_7() const { return ___ModeValue_7; }
inline int32_t* get_address_of_ModeValue_7() { return &___ModeValue_7; }
inline void set_ModeValue_7(int32_t value)
{
___ModeValue_7 = value;
}
inline static int32_t get_offset_of_PaddingValue_8() { return static_cast<int32_t>(offsetof(SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789, ___PaddingValue_8)); }
inline int32_t get_PaddingValue_8() const { return ___PaddingValue_8; }
inline int32_t* get_address_of_PaddingValue_8() { return &___PaddingValue_8; }
inline void set_PaddingValue_8(int32_t value)
{
___PaddingValue_8 = value;
}
};
// System.SystemException
struct SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782 : public Exception_t
{
public:
public:
};
// System.Threading.EventWaitHandle
struct EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 : public WaitHandle_tFD46B5B45A6BB296EA3A104C91DF2A7C03C10AC6
{
public:
public:
};
// System.Threading.LockRecursionException
struct LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 : public Exception_t
{
public:
public:
};
// System.ArgumentException
struct ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
// System.String System.ArgumentException::m_paramName
String_t* ___m_paramName_17;
public:
inline static int32_t get_offset_of_m_paramName_17() { return static_cast<int32_t>(offsetof(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1, ___m_paramName_17)); }
inline String_t* get_m_paramName_17() const { return ___m_paramName_17; }
inline String_t** get_address_of_m_paramName_17() { return &___m_paramName_17; }
inline void set_m_paramName_17(String_t* value)
{
___m_paramName_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_paramName_17), (void*)value);
}
};
// System.InvalidOperationException
struct InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
// System.Security.Cryptography.Aes
struct Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653 : public SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789
{
public:
public:
};
struct Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653_StaticFields
{
public:
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.Aes::s_legalBlockSizes
KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* ___s_legalBlockSizes_9;
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.Aes::s_legalKeySizes
KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* ___s_legalKeySizes_10;
public:
inline static int32_t get_offset_of_s_legalBlockSizes_9() { return static_cast<int32_t>(offsetof(Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653_StaticFields, ___s_legalBlockSizes_9)); }
inline KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* get_s_legalBlockSizes_9() const { return ___s_legalBlockSizes_9; }
inline KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E** get_address_of_s_legalBlockSizes_9() { return &___s_legalBlockSizes_9; }
inline void set_s_legalBlockSizes_9(KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* value)
{
___s_legalBlockSizes_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_legalBlockSizes_9), (void*)value);
}
inline static int32_t get_offset_of_s_legalKeySizes_10() { return static_cast<int32_t>(offsetof(Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653_StaticFields, ___s_legalKeySizes_10)); }
inline KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* get_s_legalKeySizes_10() const { return ___s_legalKeySizes_10; }
inline KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E** get_address_of_s_legalKeySizes_10() { return &___s_legalKeySizes_10; }
inline void set_s_legalKeySizes_10(KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* value)
{
___s_legalKeySizes_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_legalKeySizes_10), (void*)value);
}
};
// System.Security.Cryptography.AesTransform
struct AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208 : public SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750
{
public:
// System.UInt32[] System.Security.Cryptography.AesTransform::expandedKey
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___expandedKey_12;
// System.Int32 System.Security.Cryptography.AesTransform::Nk
int32_t ___Nk_13;
// System.Int32 System.Security.Cryptography.AesTransform::Nr
int32_t ___Nr_14;
public:
inline static int32_t get_offset_of_expandedKey_12() { return static_cast<int32_t>(offsetof(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208, ___expandedKey_12)); }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* get_expandedKey_12() const { return ___expandedKey_12; }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB** get_address_of_expandedKey_12() { return &___expandedKey_12; }
inline void set_expandedKey_12(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* value)
{
___expandedKey_12 = value;
Il2CppCodeGenWriteBarrier((void**)(&___expandedKey_12), (void*)value);
}
inline static int32_t get_offset_of_Nk_13() { return static_cast<int32_t>(offsetof(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208, ___Nk_13)); }
inline int32_t get_Nk_13() const { return ___Nk_13; }
inline int32_t* get_address_of_Nk_13() { return &___Nk_13; }
inline void set_Nk_13(int32_t value)
{
___Nk_13 = value;
}
inline static int32_t get_offset_of_Nr_14() { return static_cast<int32_t>(offsetof(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208, ___Nr_14)); }
inline int32_t get_Nr_14() const { return ___Nr_14; }
inline int32_t* get_address_of_Nr_14() { return &___Nr_14; }
inline void set_Nr_14(int32_t value)
{
___Nr_14 = value;
}
};
struct AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields
{
public:
// System.UInt32[] System.Security.Cryptography.AesTransform::Rcon
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___Rcon_15;
// System.Byte[] System.Security.Cryptography.AesTransform::SBox
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___SBox_16;
// System.Byte[] System.Security.Cryptography.AesTransform::iSBox
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___iSBox_17;
// System.UInt32[] System.Security.Cryptography.AesTransform::T0
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___T0_18;
// System.UInt32[] System.Security.Cryptography.AesTransform::T1
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___T1_19;
// System.UInt32[] System.Security.Cryptography.AesTransform::T2
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___T2_20;
// System.UInt32[] System.Security.Cryptography.AesTransform::T3
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___T3_21;
// System.UInt32[] System.Security.Cryptography.AesTransform::iT0
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___iT0_22;
// System.UInt32[] System.Security.Cryptography.AesTransform::iT1
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___iT1_23;
// System.UInt32[] System.Security.Cryptography.AesTransform::iT2
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___iT2_24;
// System.UInt32[] System.Security.Cryptography.AesTransform::iT3
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___iT3_25;
public:
inline static int32_t get_offset_of_Rcon_15() { return static_cast<int32_t>(offsetof(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields, ___Rcon_15)); }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* get_Rcon_15() const { return ___Rcon_15; }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB** get_address_of_Rcon_15() { return &___Rcon_15; }
inline void set_Rcon_15(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* value)
{
___Rcon_15 = value;
Il2CppCodeGenWriteBarrier((void**)(&___Rcon_15), (void*)value);
}
inline static int32_t get_offset_of_SBox_16() { return static_cast<int32_t>(offsetof(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields, ___SBox_16)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_SBox_16() const { return ___SBox_16; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_SBox_16() { return &___SBox_16; }
inline void set_SBox_16(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___SBox_16 = value;
Il2CppCodeGenWriteBarrier((void**)(&___SBox_16), (void*)value);
}
inline static int32_t get_offset_of_iSBox_17() { return static_cast<int32_t>(offsetof(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields, ___iSBox_17)); }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* get_iSBox_17() const { return ___iSBox_17; }
inline ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821** get_address_of_iSBox_17() { return &___iSBox_17; }
inline void set_iSBox_17(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* value)
{
___iSBox_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___iSBox_17), (void*)value);
}
inline static int32_t get_offset_of_T0_18() { return static_cast<int32_t>(offsetof(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields, ___T0_18)); }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* get_T0_18() const { return ___T0_18; }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB** get_address_of_T0_18() { return &___T0_18; }
inline void set_T0_18(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* value)
{
___T0_18 = value;
Il2CppCodeGenWriteBarrier((void**)(&___T0_18), (void*)value);
}
inline static int32_t get_offset_of_T1_19() { return static_cast<int32_t>(offsetof(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields, ___T1_19)); }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* get_T1_19() const { return ___T1_19; }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB** get_address_of_T1_19() { return &___T1_19; }
inline void set_T1_19(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* value)
{
___T1_19 = value;
Il2CppCodeGenWriteBarrier((void**)(&___T1_19), (void*)value);
}
inline static int32_t get_offset_of_T2_20() { return static_cast<int32_t>(offsetof(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields, ___T2_20)); }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* get_T2_20() const { return ___T2_20; }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB** get_address_of_T2_20() { return &___T2_20; }
inline void set_T2_20(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* value)
{
___T2_20 = value;
Il2CppCodeGenWriteBarrier((void**)(&___T2_20), (void*)value);
}
inline static int32_t get_offset_of_T3_21() { return static_cast<int32_t>(offsetof(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields, ___T3_21)); }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* get_T3_21() const { return ___T3_21; }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB** get_address_of_T3_21() { return &___T3_21; }
inline void set_T3_21(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* value)
{
___T3_21 = value;
Il2CppCodeGenWriteBarrier((void**)(&___T3_21), (void*)value);
}
inline static int32_t get_offset_of_iT0_22() { return static_cast<int32_t>(offsetof(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields, ___iT0_22)); }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* get_iT0_22() const { return ___iT0_22; }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB** get_address_of_iT0_22() { return &___iT0_22; }
inline void set_iT0_22(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* value)
{
___iT0_22 = value;
Il2CppCodeGenWriteBarrier((void**)(&___iT0_22), (void*)value);
}
inline static int32_t get_offset_of_iT1_23() { return static_cast<int32_t>(offsetof(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields, ___iT1_23)); }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* get_iT1_23() const { return ___iT1_23; }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB** get_address_of_iT1_23() { return &___iT1_23; }
inline void set_iT1_23(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* value)
{
___iT1_23 = value;
Il2CppCodeGenWriteBarrier((void**)(&___iT1_23), (void*)value);
}
inline static int32_t get_offset_of_iT2_24() { return static_cast<int32_t>(offsetof(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields, ___iT2_24)); }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* get_iT2_24() const { return ___iT2_24; }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB** get_address_of_iT2_24() { return &___iT2_24; }
inline void set_iT2_24(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* value)
{
___iT2_24 = value;
Il2CppCodeGenWriteBarrier((void**)(&___iT2_24), (void*)value);
}
inline static int32_t get_offset_of_iT3_25() { return static_cast<int32_t>(offsetof(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields, ___iT3_25)); }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* get_iT3_25() const { return ___iT3_25; }
inline UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB** get_address_of_iT3_25() { return &___iT3_25; }
inline void set_iT3_25(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* value)
{
___iT3_25 = value;
Il2CppCodeGenWriteBarrier((void**)(&___iT3_25), (void*)value);
}
};
// System.Security.Cryptography.CryptographicException
struct CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
// System.Security.Cryptography.Rijndael
struct Rijndael_t9C59A398CC1C66BF7FC586DE417CCB517CCEB1DC : public SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789
{
public:
public:
};
struct Rijndael_t9C59A398CC1C66BF7FC586DE417CCB517CCEB1DC_StaticFields
{
public:
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.Rijndael::s_legalBlockSizes
KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* ___s_legalBlockSizes_9;
// System.Security.Cryptography.KeySizes[] System.Security.Cryptography.Rijndael::s_legalKeySizes
KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* ___s_legalKeySizes_10;
public:
inline static int32_t get_offset_of_s_legalBlockSizes_9() { return static_cast<int32_t>(offsetof(Rijndael_t9C59A398CC1C66BF7FC586DE417CCB517CCEB1DC_StaticFields, ___s_legalBlockSizes_9)); }
inline KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* get_s_legalBlockSizes_9() const { return ___s_legalBlockSizes_9; }
inline KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E** get_address_of_s_legalBlockSizes_9() { return &___s_legalBlockSizes_9; }
inline void set_s_legalBlockSizes_9(KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* value)
{
___s_legalBlockSizes_9 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_legalBlockSizes_9), (void*)value);
}
inline static int32_t get_offset_of_s_legalKeySizes_10() { return static_cast<int32_t>(offsetof(Rijndael_t9C59A398CC1C66BF7FC586DE417CCB517CCEB1DC_StaticFields, ___s_legalKeySizes_10)); }
inline KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* get_s_legalKeySizes_10() const { return ___s_legalKeySizes_10; }
inline KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E** get_address_of_s_legalKeySizes_10() { return &___s_legalKeySizes_10; }
inline void set_s_legalKeySizes_10(KeySizesU5BU5D_t934CCA482596402177BAF86727F169872D74934E* value)
{
___s_legalKeySizes_10 = value;
Il2CppCodeGenWriteBarrier((void**)(&___s_legalKeySizes_10), (void*)value);
}
};
// System.Threading.AutoResetEvent
struct AutoResetEvent_t2A1182CEEE4E184587D4DEAA4F382B810B21D3B7 : public EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98
{
public:
public:
};
// System.Threading.ManualResetEvent
struct ManualResetEvent_tDFAF117B200ECA4CCF4FD09593F949A016D55408 : public EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98
{
public:
public:
};
// System.Threading.SynchronizationLockException
struct SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 : public SystemException_t5380468142AA850BE4A341D7AF3EAB9C78746782
{
public:
public:
};
// System.ArgumentNullException
struct ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD : public ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1
{
public:
public:
};
// System.ArgumentOutOfRangeException
struct ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA : public ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1
{
public:
// System.Object System.ArgumentOutOfRangeException::m_actualValue
RuntimeObject * ___m_actualValue_19;
public:
inline static int32_t get_offset_of_m_actualValue_19() { return static_cast<int32_t>(offsetof(ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA, ___m_actualValue_19)); }
inline RuntimeObject * get_m_actualValue_19() const { return ___m_actualValue_19; }
inline RuntimeObject ** get_address_of_m_actualValue_19() { return &___m_actualValue_19; }
inline void set_m_actualValue_19(RuntimeObject * value)
{
___m_actualValue_19 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_actualValue_19), (void*)value);
}
};
struct ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA_StaticFields
{
public:
// System.String modreq(System.Runtime.CompilerServices.IsVolatile) System.ArgumentOutOfRangeException::_rangeMessage
String_t* ____rangeMessage_18;
public:
inline static int32_t get_offset_of__rangeMessage_18() { return static_cast<int32_t>(offsetof(ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA_StaticFields, ____rangeMessage_18)); }
inline String_t* get__rangeMessage_18() const { return ____rangeMessage_18; }
inline String_t** get_address_of__rangeMessage_18() { return &____rangeMessage_18; }
inline void set__rangeMessage_18(String_t* value)
{
____rangeMessage_18 = value;
Il2CppCodeGenWriteBarrier((void**)(&____rangeMessage_18), (void*)value);
}
};
// System.ObjectDisposedException
struct ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A : public InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1
{
public:
// System.String System.ObjectDisposedException::objectName
String_t* ___objectName_17;
public:
inline static int32_t get_offset_of_objectName_17() { return static_cast<int32_t>(offsetof(ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A, ___objectName_17)); }
inline String_t* get_objectName_17() const { return ___objectName_17; }
inline String_t** get_address_of_objectName_17() { return &___objectName_17; }
inline void set_objectName_17(String_t* value)
{
___objectName_17 = value;
Il2CppCodeGenWriteBarrier((void**)(&___objectName_17), (void*)value);
}
};
// System.Security.Cryptography.AesCryptoServiceProvider
struct AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 : public Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653
{
public:
public:
};
// System.Security.Cryptography.AesManaged
struct AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 : public Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653
{
public:
// System.Security.Cryptography.RijndaelManaged System.Security.Cryptography.AesManaged::m_rijndael
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * ___m_rijndael_11;
public:
inline static int32_t get_offset_of_m_rijndael_11() { return static_cast<int32_t>(offsetof(AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3, ___m_rijndael_11)); }
inline RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * get_m_rijndael_11() const { return ___m_rijndael_11; }
inline RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 ** get_address_of_m_rijndael_11() { return &___m_rijndael_11; }
inline void set_m_rijndael_11(RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * value)
{
___m_rijndael_11 = value;
Il2CppCodeGenWriteBarrier((void**)(&___m_rijndael_11), (void*)value);
}
};
// System.Security.Cryptography.RijndaelManaged
struct RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 : public Rijndael_t9C59A398CC1C66BF7FC586DE417CCB517CCEB1DC
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// System.Byte[]
struct ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821 : public RuntimeArray
{
public:
ALIGN_FIELD (8) uint8_t m_Items[1];
public:
inline uint8_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline uint8_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, uint8_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline uint8_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline uint8_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, uint8_t value)
{
m_Items[index] = value;
}
};
// System.UInt32[]
struct UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB : public RuntimeArray
{
public:
ALIGN_FIELD (8) uint32_t m_Items[1];
public:
inline uint32_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline uint32_t* GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, uint32_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline uint32_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline uint32_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, uint32_t value)
{
m_Items[index] = value;
}
};
// System.Object[]
struct ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A : public RuntimeArray
{
public:
ALIGN_FIELD (8) RuntimeObject * m_Items[1];
public:
inline RuntimeObject * GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline RuntimeObject ** GetAddressAt(il2cpp_array_size_t index)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items + index;
}
inline void SetAt(il2cpp_array_size_t index, RuntimeObject * value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline RuntimeObject * GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline RuntimeObject ** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, RuntimeObject * value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// System.Void System.ArgumentNullException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * __this, String_t* ___paramName0, const RuntimeMethod* method);
// System.Void System.ArgumentOutOfRangeException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ArgumentOutOfRangeException__ctor_m6B36E60C989DC798A8B44556DB35960282B133A6 (ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA * __this, String_t* ___paramName0, const RuntimeMethod* method);
// System.Void System.InvalidOperationException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706 (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * __this, String_t* ___message0, const RuntimeMethod* method);
// System.Void System.Security.Cryptography.Aes::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Aes__ctor_m16C1BE841CDC7AD3484B027FADD635F4CC2F46C5 (Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653 * __this, const RuntimeMethod* method);
// System.Byte[] Mono.Security.Cryptography.KeyBuilder::IV(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* KeyBuilder_IV_m45A7513A2E5E3F6535B20B1861DFA209FD52232E (int32_t ___size0, const RuntimeMethod* method);
// System.Byte[] Mono.Security.Cryptography.KeyBuilder::Key(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* KeyBuilder_Key_mE2BA9CC6CF77F5A93BC03E878DCB6EFB6E1A0332 (int32_t ___size0, const RuntimeMethod* method);
// System.Void System.Security.Cryptography.CryptographicException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void CryptographicException__ctor_m0A5D357C12F9A830A9EBC51723094EBA5B854B98 (CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A * __this, String_t* ___message0, const RuntimeMethod* method);
// System.Void System.Security.Cryptography.AesTransform::.ctor(System.Security.Cryptography.Aes,System.Boolean,System.Byte[],System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesTransform__ctor_m1BC6B0F208747D4E35A58075D74DEBD5F72DB7DD (AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208 * __this, Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653 * ___algo0, bool ___encryption1, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___key2, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___iv3, const RuntimeMethod* method);
// System.Byte[] System.Security.Cryptography.SymmetricAlgorithm::get_IV()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* SymmetricAlgorithm_get_IV_m2F5791D5F7FD950502907C577DBAEA2C62DFA1A2 (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, const RuntimeMethod* method);
// System.Void System.Security.Cryptography.SymmetricAlgorithm::set_IV(System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SymmetricAlgorithm_set_IV_m3EA9F1066011BC02DC5E4460883AEC0CC5AC2F33 (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___value0, const RuntimeMethod* method);
// System.Byte[] System.Security.Cryptography.SymmetricAlgorithm::get_Key()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* SymmetricAlgorithm_get_Key_mE3CB723B043AE6ED61EA661BACB9E16622A7D9E8 (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, const RuntimeMethod* method);
// System.Void System.Security.Cryptography.SymmetricAlgorithm::set_Key(System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SymmetricAlgorithm_set_Key_m0FAF965C2DF241C3CDFD16F5ED2A55CD07200467 (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___value0, const RuntimeMethod* method);
// System.Int32 System.Security.Cryptography.SymmetricAlgorithm::get_KeySize()
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR int32_t SymmetricAlgorithm_get_KeySize_m416638119C768C838536FDC5FAD652478F3EC18E_inline (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, const RuntimeMethod* method);
// System.Void System.Security.Cryptography.SymmetricAlgorithm::set_KeySize(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SymmetricAlgorithm_set_KeySize_m4848DDE2DBE3BEA4F560CCF2DF868E8A16391DAD (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, int32_t ___value0, const RuntimeMethod* method);
// System.Int32 System.Security.Cryptography.SymmetricAlgorithm::get_FeedbackSize()
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR int32_t SymmetricAlgorithm_get_FeedbackSize_mD2DEAC30A2684A4CC725A592D7301265EE979FE0_inline (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, const RuntimeMethod* method);
// System.Void System.Security.Cryptography.SymmetricAlgorithm::set_FeedbackSize(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SymmetricAlgorithm_set_FeedbackSize_mD26C5C8E130A6A250BEC49F7AAC1AF3CC362B1A0 (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, int32_t ___value0, const RuntimeMethod* method);
// System.Security.Cryptography.CipherMode System.Security.Cryptography.SymmetricAlgorithm::get_Mode()
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR int32_t SymmetricAlgorithm_get_Mode_m782D8A5FAC8271F3FAF6689DDDD4E9B1D15A685D_inline (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, const RuntimeMethod* method);
// System.Void System.Security.Cryptography.SymmetricAlgorithm::set_Mode(System.Security.Cryptography.CipherMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SymmetricAlgorithm_set_Mode_m49F5F2C5AA8B003D435E46E0ADDA30D9D358D68E (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, int32_t ___value0, const RuntimeMethod* method);
// System.Security.Cryptography.PaddingMode System.Security.Cryptography.SymmetricAlgorithm::get_Padding()
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR int32_t SymmetricAlgorithm_get_Padding_mD308D61BEA3783A6BC49FBF5E4A8A3C6F9BB61F8_inline (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, const RuntimeMethod* method);
// System.Void System.Security.Cryptography.SymmetricAlgorithm::set_Padding(System.Security.Cryptography.PaddingMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SymmetricAlgorithm_set_Padding_m1EDE1DE4815A7ACC496D95D57407FB5A6E3755A9 (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, int32_t ___value0, const RuntimeMethod* method);
// System.Void System.Security.Cryptography.SymmetricAlgorithm::Dispose(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SymmetricAlgorithm_Dispose_m7528DAAC38724C0571A2DF385D2FA6179140A258 (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, bool ___disposing0, const RuntimeMethod* method);
// System.Boolean System.Security.Cryptography.CryptoConfig::get_AllowOnlyFipsAlgorithms()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool CryptoConfig_get_AllowOnlyFipsAlgorithms_mAB638CADB33E72823271E1FA51421DEBDB41AD5E (const RuntimeMethod* method);
// System.String SR::GetString(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B (String_t* ___name0, const RuntimeMethod* method);
// System.Void System.Security.Cryptography.RijndaelManaged::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void RijndaelManaged__ctor_mA6A1CDD39CD6CFCD208B3F102A01C90B5C4D4134 (RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * __this, const RuntimeMethod* method);
// System.Boolean System.Security.Cryptography.SymmetricAlgorithm::ValidKeySize(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool SymmetricAlgorithm_ValidKeySize_m08B525A5E6F08E0358DDB6FBC1E55C0DBE1703FB (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, int32_t ___bitLength0, const RuntimeMethod* method);
// System.Void System.ArgumentException::.ctor(System.String,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8 (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * __this, String_t* ___message0, String_t* ___paramName1, const RuntimeMethod* method);
// System.Void Mono.Security.Cryptography.SymmetricTransform::.ctor(System.Security.Cryptography.SymmetricAlgorithm,System.Boolean,System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SymmetricTransform__ctor_mFB4A57FD66418928944A29FEA8C212D7785C1644 (SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750 * __this, SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * ___symmAlgo0, bool ___encryption1, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___rgbIV2, const RuntimeMethod* method);
// System.String Locale::GetText(System.String,System.Object[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Locale_GetText_m315FCDCAB2E9BB0B34A5901B7552D17D741C74DF (String_t* ___fmt0, ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* ___args1, const RuntimeMethod* method);
// System.UInt32 System.Security.Cryptography.AesTransform::SubByte(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t AesTransform_SubByte_mEDB43A2A4E83017475094E5616E7DBC56F945A24 (AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208 * __this, uint32_t ___a0, const RuntimeMethod* method);
// System.Void System.Security.Cryptography.AesTransform::Encrypt128(System.Byte[],System.Byte[],System.UInt32[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesTransform_Encrypt128_m09C945A0345FD32E8DB3F4AF4B4E184CADD754DA (AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___indata0, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___outdata1, UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___ekey2, const RuntimeMethod* method);
// System.Void System.Security.Cryptography.AesTransform::Decrypt128(System.Byte[],System.Byte[],System.UInt32[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesTransform_Decrypt128_m1AE10B230A47A294B5B10EFD9C8243B02DBEA463 (AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___indata0, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___outdata1, UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___ekey2, const RuntimeMethod* method);
// System.Void System.Runtime.CompilerServices.RuntimeHelpers::InitializeArray(System.Array,System.RuntimeFieldHandle)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void RuntimeHelpers_InitializeArray_m29F50CDFEEE0AB868200291366253DD4737BC76A (RuntimeArray * ___array0, RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF ___fldHandle1, const RuntimeMethod* method);
// System.Void System.Object::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0 (RuntimeObject * __this, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::InitializeThreadCounts()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_InitializeThreadCounts_m6B26A0D91D196DBD41FD8C823CA33EE1CBACCA62 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Int64 System.Threading.Interlocked::Increment(System.Int64&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t Interlocked_Increment_mC76DFF0EEFD78295EB586C282E4B64AA6595C0DC (int64_t* ___location0, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::IsRWEntryEmpty(System.Threading.ReaderWriterCount)
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_IsRWEntryEmpty_m81FB0780C065C2D3ADF7662E8C89938FF86596B9_inline (ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * ___rwc0, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterCount::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterCount__ctor_m1BBD3EB1DFD5837AE05A5B72DB01657C1546C0EF (ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * __this, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterReadLock(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterReadLock_m9DCDCD139A9F4717EAFB1795A89F9579B256AAB3 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, int32_t ___millisecondsTimeout0, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim/TimeoutTracker::.ctor(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TimeoutTracker__ctor_m2238A5B6D938E911C2F7742E5A90E1E670F570F9 (TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 * __this, int32_t ___millisecondsTimeout0, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterReadLock(System.Threading.ReaderWriterLockSlim/TimeoutTracker)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterReadLock_mA430E93FBDC3DD271642867ACE99ADE739FD9815 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 ___timeout0, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterReadLockCore(System.Threading.ReaderWriterLockSlim/TimeoutTracker)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterReadLockCore_m946546F9F496EF40AB1C4B24FA8466A4E2D4E1DA (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 ___timeout0, const RuntimeMethod* method);
// System.Void System.ObjectDisposedException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ObjectDisposedException__ctor_m8B5D23EA08E42BDE6BC5233CC666295F19BBD2F9 (ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A * __this, String_t* ___objectName0, const RuntimeMethod* method);
// System.Threading.Thread System.Threading.Thread::get_CurrentThread()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * Thread_get_CurrentThread_mB7A83CAE2B9A74CEA053196DFD1AF1E7AB30A70E (const RuntimeMethod* method);
// System.Int32 System.Threading.Thread::get_ManagedThreadId()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Thread_get_ManagedThreadId_m7FA85162CB00713B94EF5708B19120F791D3AAD1 (Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * __this, const RuntimeMethod* method);
// System.Void System.Threading.LockRecursionException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void LockRecursionException__ctor_mC4B847F5F4421F0B7EA18E302D346C35C8A2F9E1 (LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 * __this, String_t* ___message0, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::EnterMyLock()
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Threading.ReaderWriterCount System.Threading.ReaderWriterLockSlim::GetThreadRWCount(System.Boolean)
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, bool ___dontAllocate0, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::ExitMyLock()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim/TimeoutTracker::get_IsExpired()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool TimeoutTracker_get_IsExpired_m3A2BF7A380901450677142E2863EB14A28B3EE85 (TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 * __this, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::SpinWait(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_SpinWait_m326D5ADB06292AEB146FCB7D577AA19E63C8A9EA (int32_t ___SpinCount0, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::IsRwHashEntryChanged(System.Threading.ReaderWriterCount)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_IsRwHashEntryChanged_m0224E239675EDC26497D7097C004AAC052561AF0 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * ___lrwc0, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::LazyCreateEvent(System.Threading.EventWaitHandle&,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_LazyCreateEvent_mF1FB4CDE744ADC2CADEE4F020F095896E1C64D1A (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 ** ___waitEvent0, bool ___makeAutoResetEvent1, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::WaitOnEvent(System.Threading.EventWaitHandle,System.UInt32&,System.Threading.ReaderWriterLockSlim/TimeoutTracker,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_WaitOnEvent_mE15EA3B2BB1C0145C6014F71F635FA5AECC0CD7F (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * ___waitEvent0, uint32_t* ___numWaiters1, TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 ___timeout2, bool ___isWriteWaiter3, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterWriteLock(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterWriteLock_m261EB842AE34C83257118B44645CB41B06F9750B (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, int32_t ___millisecondsTimeout0, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterWriteLock(System.Threading.ReaderWriterLockSlim/TimeoutTracker)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterWriteLock_mD6B75A7D593659DB2591012ADF1AC9AE3156FBF9 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 ___timeout0, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterWriteLockCore(System.Threading.ReaderWriterLockSlim/TimeoutTracker)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterWriteLockCore_m89767DB508CA2EDBAD19B727B0814DF5EA959F9E (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 ___timeout0, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::IsWriterAcquired()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_IsWriterAcquired_m0FC58A2B2697A2911D5C76D4D51E758ED006E3DD (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::SetWriterAcquired()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_SetWriterAcquired_mA707D12FB8981C8B7BA215DC0E912EF063CB215B (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.UInt32 System.Threading.ReaderWriterLockSlim::GetNumReaders()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t ReaderWriterLockSlim_GetNumReaders_m677B71BAF98B757FB32C4F0EB7D6E240E6D1A2B1 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterUpgradeableReadLock(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterUpgradeableReadLock_m9F8188CC19D128C34EC9DBA2C09E576A3FAD6403 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, int32_t ___millisecondsTimeout0, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterUpgradeableReadLock(System.Threading.ReaderWriterLockSlim/TimeoutTracker)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterUpgradeableReadLock_mBFDA69E20364175224C97C8963B0EDDFA7B229A7 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 ___timeout0, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterUpgradeableReadLockCore(System.Threading.ReaderWriterLockSlim/TimeoutTracker)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterUpgradeableReadLockCore_m2275C4016382DCDD9A5B2EA8B1239C710486EBFB (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 ___timeout0, const RuntimeMethod* method);
// System.Void System.Threading.SynchronizationLockException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void SynchronizationLockException__ctor_m2D56EA848D40CF87417BFD4BE6426C39C6873FE9 (SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 * __this, String_t* ___message0, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::ExitAndWakeUpAppropriateWaiters()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ExitAndWakeUpAppropriateWaiters_mBE16B41DDB40A7F5016EA873CD9F9CA0A42D9386 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::ClearWriterAcquired()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ClearWriterAcquired_m7D23840004AFD1C1C3A23C608590807D84844038 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Void System.Threading.AutoResetEvent::.ctor(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AutoResetEvent__ctor_m2A6F4D44E005E07021957D5134037747AE9890BE (AutoResetEvent_t2A1182CEEE4E184587D4DEAA4F382B810B21D3B7 * __this, bool ___initialState0, const RuntimeMethod* method);
// System.Void System.Threading.ManualResetEvent::.ctor(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ManualResetEvent__ctor_m8973D9E3C622B9602641C017A33870F51D0311E1 (ManualResetEvent_tDFAF117B200ECA4CCF4FD09593F949A016D55408 * __this, bool ___initialState0, const RuntimeMethod* method);
// System.Boolean System.Threading.EventWaitHandle::Reset()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EventWaitHandle_Reset_m59EBCEA32BC9C67B4E432BEA5FF0A42ED0CC8A6F (EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * __this, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::SetWritersWaiting()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_SetWritersWaiting_m0DBD0499833C2CEFF3E1EC14503FB3B729D15DCD (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::SetUpgraderWaiting()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_SetUpgraderWaiting_m90CBDB7726E59B974200EADFC3B9ADB2504E8B90 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Int32 System.Threading.ReaderWriterLockSlim/TimeoutTracker::get_RemainingMilliseconds()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t TimeoutTracker_get_RemainingMilliseconds_mAF2F88DCCD1A056E00EF12AA334C9561D962A17C (TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 * __this, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::ClearWritersWaiting()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ClearWritersWaiting_m2BE83552E3E49933AB3CB472B166655D456B8184 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::ClearUpgraderWaiting()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ClearUpgraderWaiting_m1AC4F6CCAA86849911DFCC0A8907FDA9FBA2EFBD (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::ExitAndWakeUpAppropriateReadWaiters()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ExitAndWakeUpAppropriateReadWaiters_m3010FADED458384F9E926BF6CF27AF16ACD7987A (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::ExitAndWakeUpAppropriateWaitersPreferringWriters()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ExitAndWakeUpAppropriateWaitersPreferringWriters_mB76632D7385923BA08EDEE6854A65311FC323DFC (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Boolean System.Threading.EventWaitHandle::Set()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool EventWaitHandle_Set_m7959A86A39735296FC949EC86FDA42A6CFAAB94C (EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * __this, const RuntimeMethod* method);
// System.Int32 System.Threading.Interlocked::CompareExchange(System.Int32&,System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Interlocked_CompareExchange_mD830160E95D6C589AD31EE9DC8D19BD4A8DCDC03 (int32_t* ___location10, int32_t ___value1, int32_t ___comparand2, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::EnterMyLockSpin()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_EnterMyLockSpin_m6799FA31434367D4A953F8E65ACE11E6FBD2994D (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Int32 System.Environment::get_ProcessorCount()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Environment_get_ProcessorCount_m086119F1D40B7319BFC37F4501C6A73517E9B8CD (const RuntimeMethod* method);
// System.Void System.Threading.Thread::SpinWait(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Thread_SpinWait_m78B41D34DB11B07C0E7776FD3150DFB10AC63BB4 (int32_t ___iterations0, const RuntimeMethod* method);
// System.Void System.Threading.Thread::Sleep(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Thread_Sleep_m2CD320EAB7BE02CC1F395EAFE9970D53A5F9EAEF (int32_t ___millisecondsTimeout0, const RuntimeMethod* method);
// System.Void System.Threading.ReaderWriterLockSlim::Dispose(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_Dispose_m227307FAFA9FC458348241A75B6FCEF94CC63A29 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, bool ___disposing0, const RuntimeMethod* method);
// System.Int32 System.Threading.ReaderWriterLockSlim::get_WaitingReadCount()
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_WaitingReadCount_mA544945C581A791EAC1AC80C3BA1CCEFC2CF7113_inline (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Int32 System.Threading.ReaderWriterLockSlim::get_WaitingUpgradeCount()
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_WaitingUpgradeCount_mDA59AE0658A70FCC5A3F0A7CC2BFC065C2A6BAD2_inline (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Int32 System.Threading.ReaderWriterLockSlim::get_WaitingWriteCount()
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_WaitingWriteCount_m7233838329221BC82DB7E52D6F510BE82B6DC0AD_inline (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::get_IsReadLockHeld()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_get_IsReadLockHeld_m1831FFFB370170F6C65F2294A7F134DADB9C5296 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::get_IsUpgradeableReadLockHeld()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_get_IsUpgradeableReadLockHeld_m9AFAD1A28F90A22D9DD55D1F7C0AE4D7901F01DD (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Boolean System.Threading.ReaderWriterLockSlim::get_IsWriteLockHeld()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_get_IsWriteLockHeld_m799A737B0616EE50CB3EF51D02F64945E1EE8E6A (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Int32 System.Threading.ReaderWriterLockSlim::get_RecursiveReadCount()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_RecursiveReadCount_mE6BA1143A18149878ED16D6BB21118F741A73AE9 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Int32 System.Threading.ReaderWriterLockSlim::get_RecursiveUpgradeCount()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_RecursiveUpgradeCount_m65397E248826F5D1D67C056F7DC428FF13BB0801 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Int32 System.Threading.ReaderWriterLockSlim::get_RecursiveWriteCount()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_RecursiveWriteCount_m3EB437BB407DA44B1B5932E5AD958101F4FBC1E3 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method);
// System.Int32 System.Environment::get_TickCount()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Environment_get_TickCount_m0A119BE4354EA90C82CC48E559588C987A79FE0C (const RuntimeMethod* method);
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.String SR::GetString(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B (String_t* ___name0, const RuntimeMethod* method)
{
{
String_t* L_0 = ___name0;
return L_0;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Exception System.Linq.Error::ArgumentNull(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Exception_t * Error_ArgumentNull_mCA126ED8F4F3B343A70E201C44B3A509690F1EA7 (String_t* ___s0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Error_ArgumentNull_mCA126ED8F4F3B343A70E201C44B3A509690F1EA7_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
String_t* L_0 = ___s0;
ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * L_1 = (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD *)il2cpp_codegen_object_new(ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED(L_1, L_0, /*hidden argument*/NULL);
return L_1;
}
}
// System.Exception System.Linq.Error::ArgumentOutOfRange(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Exception_t * Error_ArgumentOutOfRange_mACFCB068F4E0C4EEF9E6EDDD59E798901C32C6C9 (String_t* ___s0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Error_ArgumentOutOfRange_mACFCB068F4E0C4EEF9E6EDDD59E798901C32C6C9_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
String_t* L_0 = ___s0;
ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA * L_1 = (ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA *)il2cpp_codegen_object_new(ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m6B36E60C989DC798A8B44556DB35960282B133A6(L_1, L_0, /*hidden argument*/NULL);
return L_1;
}
}
// System.Exception System.Linq.Error::MoreThanOneMatch()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Exception_t * Error_MoreThanOneMatch_m85C3617F782E9F2333FC1FDF42821BE069F24623 (const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (Error_MoreThanOneMatch_m85C3617F782E9F2333FC1FDF42821BE069F24623_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_0 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_0, _stringLiteral482B665E48FCB8584375B0A83CB92F4C37CED919, /*hidden argument*/NULL);
return L_0;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Security.Cryptography.AesCryptoServiceProvider::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesCryptoServiceProvider__ctor_m8AA4C1503DBE1849070CFE727ED227BE5043373E (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (AesCryptoServiceProvider__ctor_m8AA4C1503DBE1849070CFE727ED227BE5043373E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653_il2cpp_TypeInfo_var);
Aes__ctor_m16C1BE841CDC7AD3484B027FADD635F4CC2F46C5(__this, /*hidden argument*/NULL);
((SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 *)__this)->set_FeedbackSizeValue_1(8);
return;
}
}
// System.Void System.Security.Cryptography.AesCryptoServiceProvider::GenerateIV()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesCryptoServiceProvider_GenerateIV_mAE25C1774AEB75702E4737808E56FD2EC8BF54CC (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = ((SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 *)__this)->get_BlockSizeValue_0();
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1 = KeyBuilder_IV_m45A7513A2E5E3F6535B20B1861DFA209FD52232E(((int32_t)((int32_t)L_0>>(int32_t)3)), /*hidden argument*/NULL);
((SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 *)__this)->set_IVValue_2(L_1);
return;
}
}
// System.Void System.Security.Cryptography.AesCryptoServiceProvider::GenerateKey()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesCryptoServiceProvider_GenerateKey_mC65CD8C14E8FD07E9469E74C641A746E52977586 (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = ((SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 *)__this)->get_KeySizeValue_6();
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1 = KeyBuilder_Key_mE2BA9CC6CF77F5A93BC03E878DCB6EFB6E1A0332(((int32_t)((int32_t)L_0>>(int32_t)3)), /*hidden argument*/NULL);
((SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 *)__this)->set_KeyValue_3(L_1);
return;
}
}
// System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.AesCryptoServiceProvider::CreateDecryptor(System.Byte[],System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* AesCryptoServiceProvider_CreateDecryptor_m3842B2AC283063BE4D9902818C8F68CFB4100139 (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___key0, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___iv1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (AesCryptoServiceProvider_CreateDecryptor_m3842B2AC283063BE4D9902818C8F68CFB4100139_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = VirtFuncInvoker0< int32_t >::Invoke(18 /* System.Security.Cryptography.CipherMode System.Security.Cryptography.SymmetricAlgorithm::get_Mode() */, __this);
if ((!(((uint32_t)L_0) == ((uint32_t)4))))
{
goto IL_001e;
}
}
{
int32_t L_1 = VirtFuncInvoker0< int32_t >::Invoke(8 /* System.Int32 System.Security.Cryptography.SymmetricAlgorithm::get_FeedbackSize() */, __this);
if ((((int32_t)L_1) <= ((int32_t)((int32_t)64))))
{
goto IL_001e;
}
}
{
CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A * L_2 = (CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A *)il2cpp_codegen_object_new(CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A_il2cpp_TypeInfo_var);
CryptographicException__ctor_m0A5D357C12F9A830A9EBC51723094EBA5B854B98(L_2, _stringLiteral9BA1F37E186819E10410F7100555F559D85A26C8, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, NULL, AesCryptoServiceProvider_CreateDecryptor_m3842B2AC283063BE4D9902818C8F68CFB4100139_RuntimeMethod_var);
}
IL_001e:
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_3 = ___key0;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_4 = ___iv1;
AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208 * L_5 = (AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208 *)il2cpp_codegen_object_new(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var);
AesTransform__ctor_m1BC6B0F208747D4E35A58075D74DEBD5F72DB7DD(L_5, __this, (bool)0, L_3, L_4, /*hidden argument*/NULL);
return L_5;
}
}
// System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.AesCryptoServiceProvider::CreateEncryptor(System.Byte[],System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* AesCryptoServiceProvider_CreateEncryptor_mACCCC00AED5CBBF5E9437BCA907DD67C6D123672 (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___key0, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___iv1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (AesCryptoServiceProvider_CreateEncryptor_mACCCC00AED5CBBF5E9437BCA907DD67C6D123672_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = VirtFuncInvoker0< int32_t >::Invoke(18 /* System.Security.Cryptography.CipherMode System.Security.Cryptography.SymmetricAlgorithm::get_Mode() */, __this);
if ((!(((uint32_t)L_0) == ((uint32_t)4))))
{
goto IL_001e;
}
}
{
int32_t L_1 = VirtFuncInvoker0< int32_t >::Invoke(8 /* System.Int32 System.Security.Cryptography.SymmetricAlgorithm::get_FeedbackSize() */, __this);
if ((((int32_t)L_1) <= ((int32_t)((int32_t)64))))
{
goto IL_001e;
}
}
{
CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A * L_2 = (CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A *)il2cpp_codegen_object_new(CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A_il2cpp_TypeInfo_var);
CryptographicException__ctor_m0A5D357C12F9A830A9EBC51723094EBA5B854B98(L_2, _stringLiteral9BA1F37E186819E10410F7100555F559D85A26C8, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, NULL, AesCryptoServiceProvider_CreateEncryptor_mACCCC00AED5CBBF5E9437BCA907DD67C6D123672_RuntimeMethod_var);
}
IL_001e:
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_3 = ___key0;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_4 = ___iv1;
AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208 * L_5 = (AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208 *)il2cpp_codegen_object_new(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var);
AesTransform__ctor_m1BC6B0F208747D4E35A58075D74DEBD5F72DB7DD(L_5, __this, (bool)1, L_3, L_4, /*hidden argument*/NULL);
return L_5;
}
}
// System.Byte[] System.Security.Cryptography.AesCryptoServiceProvider::get_IV()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* AesCryptoServiceProvider_get_IV_m30FBD13B702C384941FB85AD975BB3C0668F426F (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, const RuntimeMethod* method)
{
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_0 = SymmetricAlgorithm_get_IV_m2F5791D5F7FD950502907C577DBAEA2C62DFA1A2(__this, /*hidden argument*/NULL);
return L_0;
}
}
// System.Void System.Security.Cryptography.AesCryptoServiceProvider::set_IV(System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesCryptoServiceProvider_set_IV_m195F582AD29E4B449AFC54036AAECE0E05385C9C (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___value0, const RuntimeMethod* method)
{
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_0 = ___value0;
SymmetricAlgorithm_set_IV_m3EA9F1066011BC02DC5E4460883AEC0CC5AC2F33(__this, L_0, /*hidden argument*/NULL);
return;
}
}
// System.Byte[] System.Security.Cryptography.AesCryptoServiceProvider::get_Key()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* AesCryptoServiceProvider_get_Key_m9ABC98DF0CDE8952B677538C387C66A88196786A (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, const RuntimeMethod* method)
{
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_0 = SymmetricAlgorithm_get_Key_mE3CB723B043AE6ED61EA661BACB9E16622A7D9E8(__this, /*hidden argument*/NULL);
return L_0;
}
}
// System.Void System.Security.Cryptography.AesCryptoServiceProvider::set_Key(System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesCryptoServiceProvider_set_Key_m4B9CE2F92E3B1BC209BFAECEACB7A976BBCDC700 (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___value0, const RuntimeMethod* method)
{
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_0 = ___value0;
SymmetricAlgorithm_set_Key_m0FAF965C2DF241C3CDFD16F5ED2A55CD07200467(__this, L_0, /*hidden argument*/NULL);
return;
}
}
// System.Int32 System.Security.Cryptography.AesCryptoServiceProvider::get_KeySize()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t AesCryptoServiceProvider_get_KeySize_m10BDECEC12722803F3DE5F15CD76C5BDF588D1FA (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = SymmetricAlgorithm_get_KeySize_m416638119C768C838536FDC5FAD652478F3EC18E_inline(__this, /*hidden argument*/NULL);
return L_0;
}
}
// System.Void System.Security.Cryptography.AesCryptoServiceProvider::set_KeySize(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesCryptoServiceProvider_set_KeySize_mA26268F7CEDA7D0A2447FC2022327E0C49C89B9B (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, int32_t ___value0, const RuntimeMethod* method)
{
{
int32_t L_0 = ___value0;
SymmetricAlgorithm_set_KeySize_m4848DDE2DBE3BEA4F560CCF2DF868E8A16391DAD(__this, L_0, /*hidden argument*/NULL);
return;
}
}
// System.Int32 System.Security.Cryptography.AesCryptoServiceProvider::get_FeedbackSize()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t AesCryptoServiceProvider_get_FeedbackSize_mB93FFC9FCB2C09EABFB13913E245A2D75491659F (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = SymmetricAlgorithm_get_FeedbackSize_mD2DEAC30A2684A4CC725A592D7301265EE979FE0_inline(__this, /*hidden argument*/NULL);
return L_0;
}
}
// System.Void System.Security.Cryptography.AesCryptoServiceProvider::set_FeedbackSize(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesCryptoServiceProvider_set_FeedbackSize_m409990EF50B03E207F0BAAE9BE19C23A77EA9C27 (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, int32_t ___value0, const RuntimeMethod* method)
{
{
int32_t L_0 = ___value0;
SymmetricAlgorithm_set_FeedbackSize_mD26C5C8E130A6A250BEC49F7AAC1AF3CC362B1A0(__this, L_0, /*hidden argument*/NULL);
return;
}
}
// System.Security.Cryptography.CipherMode System.Security.Cryptography.AesCryptoServiceProvider::get_Mode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t AesCryptoServiceProvider_get_Mode_m5C09588E49787D597CF8C0CD0C74DB63BE0ACE5F (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = SymmetricAlgorithm_get_Mode_m782D8A5FAC8271F3FAF6689DDDD4E9B1D15A685D_inline(__this, /*hidden argument*/NULL);
return L_0;
}
}
// System.Void System.Security.Cryptography.AesCryptoServiceProvider::set_Mode(System.Security.Cryptography.CipherMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesCryptoServiceProvider_set_Mode_mC7EE07E709C918D0745E5A207A66D89F08EA57EA (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, int32_t ___value0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (AesCryptoServiceProvider_set_Mode_mC7EE07E709C918D0745E5A207A66D89F08EA57EA_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = ___value0;
if ((!(((uint32_t)L_0) == ((uint32_t)5))))
{
goto IL_000f;
}
}
{
CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A * L_1 = (CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A *)il2cpp_codegen_object_new(CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A_il2cpp_TypeInfo_var);
CryptographicException__ctor_m0A5D357C12F9A830A9EBC51723094EBA5B854B98(L_1, _stringLiteral55A76F0C6A7878D7B9E3BBE71A039630E24CDF5E, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, AesCryptoServiceProvider_set_Mode_mC7EE07E709C918D0745E5A207A66D89F08EA57EA_RuntimeMethod_var);
}
IL_000f:
{
int32_t L_2 = ___value0;
SymmetricAlgorithm_set_Mode_m49F5F2C5AA8B003D435E46E0ADDA30D9D358D68E(__this, L_2, /*hidden argument*/NULL);
return;
}
}
// System.Security.Cryptography.PaddingMode System.Security.Cryptography.AesCryptoServiceProvider::get_Padding()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t AesCryptoServiceProvider_get_Padding_mA56E045AE5CCF569C4A21C949DD4A4332E63F438 (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = SymmetricAlgorithm_get_Padding_mD308D61BEA3783A6BC49FBF5E4A8A3C6F9BB61F8_inline(__this, /*hidden argument*/NULL);
return L_0;
}
}
// System.Void System.Security.Cryptography.AesCryptoServiceProvider::set_Padding(System.Security.Cryptography.PaddingMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesCryptoServiceProvider_set_Padding_m94A4D3BE55325036611C5015E02CB622CFCDAF22 (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, int32_t ___value0, const RuntimeMethod* method)
{
{
int32_t L_0 = ___value0;
SymmetricAlgorithm_set_Padding_m1EDE1DE4815A7ACC496D95D57407FB5A6E3755A9(__this, L_0, /*hidden argument*/NULL);
return;
}
}
// System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.AesCryptoServiceProvider::CreateDecryptor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* AesCryptoServiceProvider_CreateDecryptor_mD858924207EA664C6E32D42408FB5C8040DD4D44 (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, const RuntimeMethod* method)
{
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_0 = VirtFuncInvoker0< ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* >::Invoke(12 /* System.Byte[] System.Security.Cryptography.SymmetricAlgorithm::get_Key() */, __this);
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1 = VirtFuncInvoker0< ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* >::Invoke(10 /* System.Byte[] System.Security.Cryptography.SymmetricAlgorithm::get_IV() */, __this);
RuntimeObject* L_2 = VirtFuncInvoker2< RuntimeObject*, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821*, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* >::Invoke(25 /* System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.SymmetricAlgorithm::CreateDecryptor(System.Byte[],System.Byte[]) */, __this, L_0, L_1);
return L_2;
}
}
// System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.AesCryptoServiceProvider::CreateEncryptor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* AesCryptoServiceProvider_CreateEncryptor_m964DD0E94A26806AB34A7A79D4E4D1539425A2EA (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, const RuntimeMethod* method)
{
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_0 = VirtFuncInvoker0< ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* >::Invoke(12 /* System.Byte[] System.Security.Cryptography.SymmetricAlgorithm::get_Key() */, __this);
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1 = VirtFuncInvoker0< ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* >::Invoke(10 /* System.Byte[] System.Security.Cryptography.SymmetricAlgorithm::get_IV() */, __this);
RuntimeObject* L_2 = VirtFuncInvoker2< RuntimeObject*, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821*, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* >::Invoke(23 /* System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.SymmetricAlgorithm::CreateEncryptor(System.Byte[],System.Byte[]) */, __this, L_0, L_1);
return L_2;
}
}
// System.Void System.Security.Cryptography.AesCryptoServiceProvider::Dispose(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesCryptoServiceProvider_Dispose_mCFA420F8643911F86A112F50905FCB34C4A3045F (AesCryptoServiceProvider_t01E8BF6BEA9BB2C16BEEC3291EC0060086E2EBB3 * __this, bool ___disposing0, const RuntimeMethod* method)
{
{
bool L_0 = ___disposing0;
SymmetricAlgorithm_Dispose_m7528DAAC38724C0571A2DF385D2FA6179140A258(__this, L_0, /*hidden argument*/NULL);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Security.Cryptography.AesManaged::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesManaged__ctor_mB2BB25E2F795428300A966DF7C4706BDDB65FB64 (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (AesManaged__ctor_mB2BB25E2F795428300A966DF7C4706BDDB65FB64_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
IL2CPP_RUNTIME_CLASS_INIT(Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653_il2cpp_TypeInfo_var);
Aes__ctor_m16C1BE841CDC7AD3484B027FADD635F4CC2F46C5(__this, /*hidden argument*/NULL);
bool L_0 = CryptoConfig_get_AllowOnlyFipsAlgorithms_mAB638CADB33E72823271E1FA51421DEBDB41AD5E(/*hidden argument*/NULL);
if (!L_0)
{
goto IL_001d;
}
}
{
String_t* L_1 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteral6F3695F7633E8B0DBDDF0AA3265EA7BEB1344779, /*hidden argument*/NULL);
InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 * L_2 = (InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1 *)il2cpp_codegen_object_new(InvalidOperationException_t0530E734D823F78310CAFAFA424CA5164D93A1F1_il2cpp_TypeInfo_var);
InvalidOperationException__ctor_m72027D5F1D513C25C05137E203EEED8FD8297706(L_2, L_1, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, NULL, AesManaged__ctor_mB2BB25E2F795428300A966DF7C4706BDDB65FB64_RuntimeMethod_var);
}
IL_001d:
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_3 = (RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 *)il2cpp_codegen_object_new(RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182_il2cpp_TypeInfo_var);
RijndaelManaged__ctor_mA6A1CDD39CD6CFCD208B3F102A01C90B5C4D4134(L_3, /*hidden argument*/NULL);
__this->set_m_rijndael_11(L_3);
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_4 = __this->get_m_rijndael_11();
int32_t L_5 = VirtFuncInvoker0< int32_t >::Invoke(6 /* System.Int32 System.Security.Cryptography.SymmetricAlgorithm::get_BlockSize() */, __this);
NullCheck(L_4);
VirtActionInvoker1< int32_t >::Invoke(7 /* System.Void System.Security.Cryptography.SymmetricAlgorithm::set_BlockSize(System.Int32) */, L_4, L_5);
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_6 = __this->get_m_rijndael_11();
int32_t L_7 = VirtFuncInvoker0< int32_t >::Invoke(16 /* System.Int32 System.Security.Cryptography.SymmetricAlgorithm::get_KeySize() */, __this);
NullCheck(L_6);
VirtActionInvoker1< int32_t >::Invoke(17 /* System.Void System.Security.Cryptography.SymmetricAlgorithm::set_KeySize(System.Int32) */, L_6, L_7);
return;
}
}
// System.Int32 System.Security.Cryptography.AesManaged::get_FeedbackSize()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t AesManaged_get_FeedbackSize_mA079406B80A8CDFB6811251C8BCE9EFE3C83A712 (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
NullCheck(L_0);
int32_t L_1 = VirtFuncInvoker0< int32_t >::Invoke(8 /* System.Int32 System.Security.Cryptography.SymmetricAlgorithm::get_FeedbackSize() */, L_0);
return L_1;
}
}
// System.Void System.Security.Cryptography.AesManaged::set_FeedbackSize(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesManaged_set_FeedbackSize_m881146DEC23D6F9FA3480D2ABDA7CBAFBD71C7C9 (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, int32_t ___value0, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
int32_t L_1 = ___value0;
NullCheck(L_0);
VirtActionInvoker1< int32_t >::Invoke(9 /* System.Void System.Security.Cryptography.SymmetricAlgorithm::set_FeedbackSize(System.Int32) */, L_0, L_1);
return;
}
}
// System.Byte[] System.Security.Cryptography.AesManaged::get_IV()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* AesManaged_get_IV_mAAC08AB6D76CE29D3AEFCEF7B46F17B788B00B6E (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
NullCheck(L_0);
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1 = VirtFuncInvoker0< ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* >::Invoke(10 /* System.Byte[] System.Security.Cryptography.SymmetricAlgorithm::get_IV() */, L_0);
return L_1;
}
}
// System.Void System.Security.Cryptography.AesManaged::set_IV(System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesManaged_set_IV_m6AF8905A7F0DBD20D7E059360423DB57C7DFA722 (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___value0, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1 = ___value0;
NullCheck(L_0);
VirtActionInvoker1< ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* >::Invoke(11 /* System.Void System.Security.Cryptography.SymmetricAlgorithm::set_IV(System.Byte[]) */, L_0, L_1);
return;
}
}
// System.Byte[] System.Security.Cryptography.AesManaged::get_Key()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* AesManaged_get_Key_mC3790099349E411DFBC3EB6916E31CCC1F2AC088 (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
NullCheck(L_0);
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1 = VirtFuncInvoker0< ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* >::Invoke(12 /* System.Byte[] System.Security.Cryptography.SymmetricAlgorithm::get_Key() */, L_0);
return L_1;
}
}
// System.Void System.Security.Cryptography.AesManaged::set_Key(System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesManaged_set_Key_m654922A858A73BC91747B52F5D8B194B1EA88ADC (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___value0, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1 = ___value0;
NullCheck(L_0);
VirtActionInvoker1< ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* >::Invoke(13 /* System.Void System.Security.Cryptography.SymmetricAlgorithm::set_Key(System.Byte[]) */, L_0, L_1);
return;
}
}
// System.Int32 System.Security.Cryptography.AesManaged::get_KeySize()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t AesManaged_get_KeySize_m5218EB6C55678DC91BDE12E4F0697B719A2C7DD6 (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
NullCheck(L_0);
int32_t L_1 = VirtFuncInvoker0< int32_t >::Invoke(16 /* System.Int32 System.Security.Cryptography.SymmetricAlgorithm::get_KeySize() */, L_0);
return L_1;
}
}
// System.Void System.Security.Cryptography.AesManaged::set_KeySize(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesManaged_set_KeySize_m0AF9E2BB96295D70FBADB46F8E32FB54A695C349 (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, int32_t ___value0, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
int32_t L_1 = ___value0;
NullCheck(L_0);
VirtActionInvoker1< int32_t >::Invoke(17 /* System.Void System.Security.Cryptography.SymmetricAlgorithm::set_KeySize(System.Int32) */, L_0, L_1);
return;
}
}
// System.Security.Cryptography.CipherMode System.Security.Cryptography.AesManaged::get_Mode()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t AesManaged_get_Mode_m85C722AAA2A9CF3BC012EC908CF5B3B57BAF4BDA (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
NullCheck(L_0);
int32_t L_1 = VirtFuncInvoker0< int32_t >::Invoke(18 /* System.Security.Cryptography.CipherMode System.Security.Cryptography.SymmetricAlgorithm::get_Mode() */, L_0);
return L_1;
}
}
// System.Void System.Security.Cryptography.AesManaged::set_Mode(System.Security.Cryptography.CipherMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesManaged_set_Mode_mE06717F04195261B88A558FBD08AEB847D9320D8 (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, int32_t ___value0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (AesManaged_set_Mode_mE06717F04195261B88A558FBD08AEB847D9320D8_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = ___value0;
if ((((int32_t)L_0) == ((int32_t)4)))
{
goto IL_0008;
}
}
{
int32_t L_1 = ___value0;
if ((!(((uint32_t)L_1) == ((uint32_t)3))))
{
goto IL_0018;
}
}
IL_0008:
{
String_t* L_2 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteral109DA2C2B37EAF7931CB49917D2F04C935D39886, /*hidden argument*/NULL);
CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A * L_3 = (CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A *)il2cpp_codegen_object_new(CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A_il2cpp_TypeInfo_var);
CryptographicException__ctor_m0A5D357C12F9A830A9EBC51723094EBA5B854B98(L_3, L_2, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_3, NULL, AesManaged_set_Mode_mE06717F04195261B88A558FBD08AEB847D9320D8_RuntimeMethod_var);
}
IL_0018:
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_4 = __this->get_m_rijndael_11();
int32_t L_5 = ___value0;
NullCheck(L_4);
VirtActionInvoker1< int32_t >::Invoke(19 /* System.Void System.Security.Cryptography.SymmetricAlgorithm::set_Mode(System.Security.Cryptography.CipherMode) */, L_4, L_5);
return;
}
}
// System.Security.Cryptography.PaddingMode System.Security.Cryptography.AesManaged::get_Padding()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t AesManaged_get_Padding_mBD0B0AA07CF0FBFDFC14458D14F058DE6DA656F0 (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
NullCheck(L_0);
int32_t L_1 = VirtFuncInvoker0< int32_t >::Invoke(20 /* System.Security.Cryptography.PaddingMode System.Security.Cryptography.SymmetricAlgorithm::get_Padding() */, L_0);
return L_1;
}
}
// System.Void System.Security.Cryptography.AesManaged::set_Padding(System.Security.Cryptography.PaddingMode)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesManaged_set_Padding_m1BAC3EECEF3E2F49E4641E29169F149EDA8C5B23 (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, int32_t ___value0, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
int32_t L_1 = ___value0;
NullCheck(L_0);
VirtActionInvoker1< int32_t >::Invoke(21 /* System.Void System.Security.Cryptography.SymmetricAlgorithm::set_Padding(System.Security.Cryptography.PaddingMode) */, L_0, L_1);
return;
}
}
// System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.AesManaged::CreateDecryptor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* AesManaged_CreateDecryptor_m9E9E7861138397C7A6AAF8C43C81BD4CFCB8E0BD (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
NullCheck(L_0);
RuntimeObject* L_1 = VirtFuncInvoker0< RuntimeObject* >::Invoke(24 /* System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.SymmetricAlgorithm::CreateDecryptor() */, L_0);
return L_1;
}
}
// System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.AesManaged::CreateDecryptor(System.Byte[],System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* AesManaged_CreateDecryptor_mEBE041A905F0848F846901916BA23485F85C65F1 (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___key0, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___iv1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (AesManaged_CreateDecryptor_mEBE041A905F0848F846901916BA23485F85C65F1_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_0 = ___key0;
if (L_0)
{
goto IL_000e;
}
}
{
ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * L_1 = (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD *)il2cpp_codegen_object_new(ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED(L_1, _stringLiteralA62F2225BF70BFACCBC7F1EF2A397836717377DE, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, AesManaged_CreateDecryptor_mEBE041A905F0848F846901916BA23485F85C65F1_RuntimeMethod_var);
}
IL_000e:
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_2 = ___key0;
NullCheck(L_2);
bool L_3 = SymmetricAlgorithm_ValidKeySize_m08B525A5E6F08E0358DDB6FBC1E55C0DBE1703FB(__this, ((int32_t)il2cpp_codegen_multiply((int32_t)(((int32_t)((int32_t)(((RuntimeArray*)L_2)->max_length)))), (int32_t)8)), /*hidden argument*/NULL);
if (L_3)
{
goto IL_0030;
}
}
{
String_t* L_4 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteralC24C570C80332D3F38155C328F3AF1A671970FE7, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_5 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_5, L_4, _stringLiteralA62F2225BF70BFACCBC7F1EF2A397836717377DE, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_5, NULL, AesManaged_CreateDecryptor_mEBE041A905F0848F846901916BA23485F85C65F1_RuntimeMethod_var);
}
IL_0030:
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_6 = ___iv1;
if (!L_6)
{
goto IL_0055;
}
}
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_7 = ___iv1;
NullCheck(L_7);
int32_t L_8 = ((SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 *)__this)->get_BlockSizeValue_0();
if ((((int32_t)((int32_t)il2cpp_codegen_multiply((int32_t)(((int32_t)((int32_t)(((RuntimeArray*)L_7)->max_length)))), (int32_t)8))) == ((int32_t)L_8)))
{
goto IL_0055;
}
}
{
String_t* L_9 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteral234A8A5D65EA3192A7CCFA46C3B46E9647D3D6F4, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_10 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_10, L_9, _stringLiteral2B946DDAE90DF50F553375CBADEDE63EF5DCC8B0, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_10, NULL, AesManaged_CreateDecryptor_mEBE041A905F0848F846901916BA23485F85C65F1_RuntimeMethod_var);
}
IL_0055:
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_11 = __this->get_m_rijndael_11();
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_12 = ___key0;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_13 = ___iv1;
NullCheck(L_11);
RuntimeObject* L_14 = VirtFuncInvoker2< RuntimeObject*, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821*, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* >::Invoke(25 /* System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.SymmetricAlgorithm::CreateDecryptor(System.Byte[],System.Byte[]) */, L_11, L_12, L_13);
return L_14;
}
}
// System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.AesManaged::CreateEncryptor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* AesManaged_CreateEncryptor_m82CC97D7C3C330EB8F5F61B3192D65859CAA94F4 (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
NullCheck(L_0);
RuntimeObject* L_1 = VirtFuncInvoker0< RuntimeObject* >::Invoke(22 /* System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.SymmetricAlgorithm::CreateEncryptor() */, L_0);
return L_1;
}
}
// System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.AesManaged::CreateEncryptor(System.Byte[],System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* AesManaged_CreateEncryptor_mA914CA875EF777EDB202343570182CC0D9D89A91 (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___key0, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___iv1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (AesManaged_CreateEncryptor_mA914CA875EF777EDB202343570182CC0D9D89A91_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_0 = ___key0;
if (L_0)
{
goto IL_000e;
}
}
{
ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD * L_1 = (ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD *)il2cpp_codegen_object_new(ArgumentNullException_t581DF992B1F3E0EC6EFB30CC5DC43519A79B27AD_il2cpp_TypeInfo_var);
ArgumentNullException__ctor_mEE0C0D6FCB2D08CD7967DBB1329A0854BBED49ED(L_1, _stringLiteralA62F2225BF70BFACCBC7F1EF2A397836717377DE, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, AesManaged_CreateEncryptor_mA914CA875EF777EDB202343570182CC0D9D89A91_RuntimeMethod_var);
}
IL_000e:
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_2 = ___key0;
NullCheck(L_2);
bool L_3 = SymmetricAlgorithm_ValidKeySize_m08B525A5E6F08E0358DDB6FBC1E55C0DBE1703FB(__this, ((int32_t)il2cpp_codegen_multiply((int32_t)(((int32_t)((int32_t)(((RuntimeArray*)L_2)->max_length)))), (int32_t)8)), /*hidden argument*/NULL);
if (L_3)
{
goto IL_0030;
}
}
{
String_t* L_4 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteralC24C570C80332D3F38155C328F3AF1A671970FE7, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_5 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_5, L_4, _stringLiteralA62F2225BF70BFACCBC7F1EF2A397836717377DE, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_5, NULL, AesManaged_CreateEncryptor_mA914CA875EF777EDB202343570182CC0D9D89A91_RuntimeMethod_var);
}
IL_0030:
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_6 = ___iv1;
if (!L_6)
{
goto IL_0055;
}
}
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_7 = ___iv1;
NullCheck(L_7);
int32_t L_8 = ((SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 *)__this)->get_BlockSizeValue_0();
if ((((int32_t)((int32_t)il2cpp_codegen_multiply((int32_t)(((int32_t)((int32_t)(((RuntimeArray*)L_7)->max_length)))), (int32_t)8))) == ((int32_t)L_8)))
{
goto IL_0055;
}
}
{
String_t* L_9 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteral234A8A5D65EA3192A7CCFA46C3B46E9647D3D6F4, /*hidden argument*/NULL);
ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 * L_10 = (ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1 *)il2cpp_codegen_object_new(ArgumentException_tEDCD16F20A09ECE461C3DA766C16EDA8864057D1_il2cpp_TypeInfo_var);
ArgumentException__ctor_m26DC3463C6F3C98BF33EA39598DD2B32F0249CA8(L_10, L_9, _stringLiteral2B946DDAE90DF50F553375CBADEDE63EF5DCC8B0, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_10, NULL, AesManaged_CreateEncryptor_mA914CA875EF777EDB202343570182CC0D9D89A91_RuntimeMethod_var);
}
IL_0055:
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_11 = __this->get_m_rijndael_11();
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_12 = ___key0;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_13 = ___iv1;
NullCheck(L_11);
RuntimeObject* L_14 = VirtFuncInvoker2< RuntimeObject*, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821*, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* >::Invoke(23 /* System.Security.Cryptography.ICryptoTransform System.Security.Cryptography.SymmetricAlgorithm::CreateEncryptor(System.Byte[],System.Byte[]) */, L_11, L_12, L_13);
return L_14;
}
}
// System.Void System.Security.Cryptography.AesManaged::Dispose(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesManaged_Dispose_m57258CB76A9CCEF03FF4D4C5DE02E9A31056F8ED (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, bool ___disposing0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (AesManaged_Dispose_m57258CB76A9CCEF03FF4D4C5DE02E9A31056F8ED_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
Exception_t * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
void* __leave_targets_storage = alloca(sizeof(int32_t) * 1);
il2cpp::utils::LeaveTargetStack __leave_targets(__leave_targets_storage);
NO_UNUSED_WARNING (__leave_targets);
IL_0000:
try
{ // begin try (depth: 1)
{
bool L_0 = ___disposing0;
if (!L_0)
{
goto IL_000e;
}
}
IL_0003:
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_1 = __this->get_m_rijndael_11();
NullCheck(L_1);
InterfaceActionInvoker0::Invoke(0 /* System.Void System.IDisposable::Dispose() */, IDisposable_t7218B22548186B208D65EA5B7870503810A2D15A_il2cpp_TypeInfo_var, L_1);
}
IL_000e:
{
IL2CPP_LEAVE(0x18, FINALLY_0010);
}
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t *)e.ex;
goto FINALLY_0010;
}
FINALLY_0010:
{ // begin finally (depth: 1)
bool L_2 = ___disposing0;
SymmetricAlgorithm_Dispose_m7528DAAC38724C0571A2DF385D2FA6179140A258(__this, L_2, /*hidden argument*/NULL);
IL2CPP_END_FINALLY(16)
} // end finally (depth: 1)
IL2CPP_CLEANUP(16)
{
IL2CPP_JUMP_TBL(0x18, IL_0018)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t *)
}
IL_0018:
{
return;
}
}
// System.Void System.Security.Cryptography.AesManaged::GenerateIV()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesManaged_GenerateIV_m92735378E3FB47DE1D0241A923CB4E426C702ABC (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
NullCheck(L_0);
VirtActionInvoker0::Invoke(27 /* System.Void System.Security.Cryptography.SymmetricAlgorithm::GenerateIV() */, L_0);
return;
}
}
// System.Void System.Security.Cryptography.AesManaged::GenerateKey()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesManaged_GenerateKey_m5C790BC376A3FAFF13617855FF6BFA8A57925146 (AesManaged_tECE77EB2106D6F15928DA89DF573A924936907B3 * __this, const RuntimeMethod* method)
{
{
RijndaelManaged_t4E3376C5DAE4AB0D658F4A00A1FE7496DB258182 * L_0 = __this->get_m_rijndael_11();
NullCheck(L_0);
VirtActionInvoker0::Invoke(26 /* System.Void System.Security.Cryptography.SymmetricAlgorithm::GenerateKey() */, L_0);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Security.Cryptography.AesTransform::.ctor(System.Security.Cryptography.Aes,System.Boolean,System.Byte[],System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesTransform__ctor_m1BC6B0F208747D4E35A58075D74DEBD5F72DB7DD (AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208 * __this, Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653 * ___algo0, bool ___encryption1, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___key2, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___iv3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (AesTransform__ctor_m1BC6B0F208747D4E35A58075D74DEBD5F72DB7DD_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
int32_t V_1 = 0;
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* V_2 = NULL;
int32_t V_3 = 0;
int32_t V_4 = 0;
uint32_t V_5 = 0;
int32_t V_6 = 0;
uint32_t V_7 = 0;
uint32_t V_8 = 0;
int32_t V_9 = 0;
int32_t V_10 = 0;
int32_t V_11 = 0;
uint32_t V_12 = 0;
int32_t V_13 = 0;
{
Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653 * L_0 = ___algo0;
bool L_1 = ___encryption1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_2 = ___iv3;
SymmetricTransform__ctor_mFB4A57FD66418928944A29FEA8C212D7785C1644(__this, L_0, L_1, L_2, /*hidden argument*/NULL);
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_3 = ___key2;
if (L_3)
{
goto IL_0018;
}
}
{
CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A * L_4 = (CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A *)il2cpp_codegen_object_new(CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A_il2cpp_TypeInfo_var);
CryptographicException__ctor_m0A5D357C12F9A830A9EBC51723094EBA5B854B98(L_4, _stringLiteralCD72BFB00B20A1600AF561C7F666CA5EA98BBB38, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_4, NULL, AesTransform__ctor_m1BC6B0F208747D4E35A58075D74DEBD5F72DB7DD_RuntimeMethod_var);
}
IL_0018:
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_5 = ___iv3;
if (!L_5)
{
goto IL_005c;
}
}
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_6 = ___iv3;
NullCheck(L_6);
Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653 * L_7 = ___algo0;
NullCheck(L_7);
int32_t L_8 = VirtFuncInvoker0< int32_t >::Invoke(6 /* System.Int32 System.Security.Cryptography.SymmetricAlgorithm::get_BlockSize() */, L_7);
if ((((int32_t)(((int32_t)((int32_t)(((RuntimeArray*)L_6)->max_length))))) == ((int32_t)((int32_t)((int32_t)L_8>>(int32_t)3)))))
{
goto IL_005c;
}
}
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_9 = (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)SZArrayNew(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_10 = L_9;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_11 = ___iv3;
NullCheck(L_11);
int32_t L_12 = (((int32_t)((int32_t)(((RuntimeArray*)L_11)->max_length))));
RuntimeObject * L_13 = Box(Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var, &L_12);
NullCheck(L_10);
ArrayElementTypeCheck (L_10, L_13);
(L_10)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)L_13);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_14 = L_10;
Aes_t45D82D059B1811A60AF2DA6FD0355CAFB591A653 * L_15 = ___algo0;
NullCheck(L_15);
int32_t L_16 = VirtFuncInvoker0< int32_t >::Invoke(6 /* System.Int32 System.Security.Cryptography.SymmetricAlgorithm::get_BlockSize() */, L_15);
int32_t L_17 = ((int32_t)((int32_t)L_16>>(int32_t)3));
RuntimeObject * L_18 = Box(Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var, &L_17);
NullCheck(L_14);
ArrayElementTypeCheck (L_14, L_18);
(L_14)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)L_18);
String_t* L_19 = Locale_GetText_m315FCDCAB2E9BB0B34A5901B7552D17D741C74DF(_stringLiteral0F26F65FFEB0A0C184512B25B278A5DF73E93D09, L_14, /*hidden argument*/NULL);
CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A * L_20 = (CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A *)il2cpp_codegen_object_new(CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A_il2cpp_TypeInfo_var);
CryptographicException__ctor_m0A5D357C12F9A830A9EBC51723094EBA5B854B98(L_20, L_19, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_20, NULL, AesTransform__ctor_m1BC6B0F208747D4E35A58075D74DEBD5F72DB7DD_RuntimeMethod_var);
}
IL_005c:
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_21 = ___key2;
NullCheck(L_21);
V_0 = (((int32_t)((int32_t)(((RuntimeArray*)L_21)->max_length))));
int32_t L_22 = V_0;
if ((((int32_t)L_22) == ((int32_t)((int32_t)16))))
{
goto IL_00ac;
}
}
{
int32_t L_23 = V_0;
if ((((int32_t)L_23) == ((int32_t)((int32_t)24))))
{
goto IL_00ac;
}
}
{
int32_t L_24 = V_0;
if ((((int32_t)L_24) == ((int32_t)((int32_t)32))))
{
goto IL_00ac;
}
}
{
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_25 = (ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A*)SZArrayNew(ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A_il2cpp_TypeInfo_var, (uint32_t)4);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_26 = L_25;
int32_t L_27 = V_0;
int32_t L_28 = L_27;
RuntimeObject * L_29 = Box(Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var, &L_28);
NullCheck(L_26);
ArrayElementTypeCheck (L_26, L_29);
(L_26)->SetAt(static_cast<il2cpp_array_size_t>(0), (RuntimeObject *)L_29);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_30 = L_26;
int32_t L_31 = ((int32_t)16);
RuntimeObject * L_32 = Box(Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var, &L_31);
NullCheck(L_30);
ArrayElementTypeCheck (L_30, L_32);
(L_30)->SetAt(static_cast<il2cpp_array_size_t>(1), (RuntimeObject *)L_32);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_33 = L_30;
int32_t L_34 = ((int32_t)24);
RuntimeObject * L_35 = Box(Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var, &L_34);
NullCheck(L_33);
ArrayElementTypeCheck (L_33, L_35);
(L_33)->SetAt(static_cast<il2cpp_array_size_t>(2), (RuntimeObject *)L_35);
ObjectU5BU5D_t3C9242B5C88A48B2A5BD9FDA6CD0024E792AF08A* L_36 = L_33;
int32_t L_37 = ((int32_t)32);
RuntimeObject * L_38 = Box(Int32_t585191389E07734F19F3156FF88FB3EF4800D102_il2cpp_TypeInfo_var, &L_37);
NullCheck(L_36);
ArrayElementTypeCheck (L_36, L_38);
(L_36)->SetAt(static_cast<il2cpp_array_size_t>(3), (RuntimeObject *)L_38);
String_t* L_39 = Locale_GetText_m315FCDCAB2E9BB0B34A5901B7552D17D741C74DF(_stringLiteralC7C98D2F3A743BCA3032E11738A7C2CD9E0DAF5A, L_36, /*hidden argument*/NULL);
CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A * L_40 = (CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A *)il2cpp_codegen_object_new(CryptographicException_t67ABE4FAB48298C9DF4C5E37E4C8F20AA601F15A_il2cpp_TypeInfo_var);
CryptographicException__ctor_m0A5D357C12F9A830A9EBC51723094EBA5B854B98(L_40, L_39, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_40, NULL, AesTransform__ctor_m1BC6B0F208747D4E35A58075D74DEBD5F72DB7DD_RuntimeMethod_var);
}
IL_00ac:
{
int32_t L_41 = V_0;
V_0 = ((int32_t)((int32_t)L_41<<(int32_t)3));
int32_t L_42 = V_0;
__this->set_Nk_13(((int32_t)((int32_t)L_42>>(int32_t)5)));
int32_t L_43 = __this->get_Nk_13();
if ((!(((uint32_t)L_43) == ((uint32_t)8))))
{
goto IL_00cc;
}
}
{
__this->set_Nr_14(((int32_t)14));
goto IL_00e7;
}
IL_00cc:
{
int32_t L_44 = __this->get_Nk_13();
if ((!(((uint32_t)L_44) == ((uint32_t)6))))
{
goto IL_00df;
}
}
{
__this->set_Nr_14(((int32_t)12));
goto IL_00e7;
}
IL_00df:
{
__this->set_Nr_14(((int32_t)10));
}
IL_00e7:
{
int32_t L_45 = __this->get_Nr_14();
V_1 = ((int32_t)il2cpp_codegen_multiply((int32_t)4, (int32_t)((int32_t)il2cpp_codegen_add((int32_t)L_45, (int32_t)1))));
int32_t L_46 = V_1;
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_47 = (UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)SZArrayNew(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB_il2cpp_TypeInfo_var, (uint32_t)L_46);
V_2 = L_47;
V_3 = 0;
V_4 = 0;
goto IL_0141;
}
IL_0100:
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_48 = ___key2;
int32_t L_49 = V_3;
int32_t L_50 = L_49;
V_3 = ((int32_t)il2cpp_codegen_add((int32_t)L_50, (int32_t)1));
NullCheck(L_48);
int32_t L_51 = L_50;
uint8_t L_52 = (L_48)->GetAt(static_cast<il2cpp_array_size_t>(L_51));
V_5 = ((int32_t)((int32_t)L_52<<(int32_t)((int32_t)24)));
uint32_t L_53 = V_5;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_54 = ___key2;
int32_t L_55 = V_3;
int32_t L_56 = L_55;
V_3 = ((int32_t)il2cpp_codegen_add((int32_t)L_56, (int32_t)1));
NullCheck(L_54);
int32_t L_57 = L_56;
uint8_t L_58 = (L_54)->GetAt(static_cast<il2cpp_array_size_t>(L_57));
V_5 = ((int32_t)((int32_t)L_53|(int32_t)((int32_t)((int32_t)L_58<<(int32_t)((int32_t)16)))));
uint32_t L_59 = V_5;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_60 = ___key2;
int32_t L_61 = V_3;
int32_t L_62 = L_61;
V_3 = ((int32_t)il2cpp_codegen_add((int32_t)L_62, (int32_t)1));
NullCheck(L_60);
int32_t L_63 = L_62;
uint8_t L_64 = (L_60)->GetAt(static_cast<il2cpp_array_size_t>(L_63));
V_5 = ((int32_t)((int32_t)L_59|(int32_t)((int32_t)((int32_t)L_64<<(int32_t)8))));
uint32_t L_65 = V_5;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_66 = ___key2;
int32_t L_67 = V_3;
int32_t L_68 = L_67;
V_3 = ((int32_t)il2cpp_codegen_add((int32_t)L_68, (int32_t)1));
NullCheck(L_66);
int32_t L_69 = L_68;
uint8_t L_70 = (L_66)->GetAt(static_cast<il2cpp_array_size_t>(L_69));
V_5 = ((int32_t)((int32_t)L_65|(int32_t)L_70));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_71 = V_2;
int32_t L_72 = V_4;
uint32_t L_73 = V_5;
NullCheck(L_71);
(L_71)->SetAt(static_cast<il2cpp_array_size_t>(L_72), (uint32_t)L_73);
int32_t L_74 = V_4;
V_4 = ((int32_t)il2cpp_codegen_add((int32_t)L_74, (int32_t)1));
}
IL_0141:
{
int32_t L_75 = V_4;
int32_t L_76 = __this->get_Nk_13();
if ((((int32_t)L_75) < ((int32_t)L_76)))
{
goto IL_0100;
}
}
{
int32_t L_77 = __this->get_Nk_13();
V_6 = L_77;
goto IL_01cd;
}
IL_0155:
{
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_78 = V_2;
int32_t L_79 = V_6;
NullCheck(L_78);
int32_t L_80 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_79, (int32_t)1));
uint32_t L_81 = (L_78)->GetAt(static_cast<il2cpp_array_size_t>(L_80));
V_7 = L_81;
int32_t L_82 = V_6;
int32_t L_83 = __this->get_Nk_13();
if (((int32_t)((int32_t)L_82%(int32_t)L_83)))
{
goto IL_0196;
}
}
{
uint32_t L_84 = V_7;
uint32_t L_85 = V_7;
V_8 = ((int32_t)((int32_t)((int32_t)((int32_t)L_84<<(int32_t)8))|(int32_t)((int32_t)((int32_t)((int32_t)((uint32_t)L_85>>((int32_t)24)))&(int32_t)((int32_t)255)))));
uint32_t L_86 = V_8;
uint32_t L_87 = AesTransform_SubByte_mEDB43A2A4E83017475094E5616E7DBC56F945A24(__this, L_86, /*hidden argument*/NULL);
IL2CPP_RUNTIME_CLASS_INIT(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_88 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_Rcon_15();
int32_t L_89 = V_6;
int32_t L_90 = __this->get_Nk_13();
NullCheck(L_88);
int32_t L_91 = ((int32_t)((int32_t)L_89/(int32_t)L_90));
uint32_t L_92 = (L_88)->GetAt(static_cast<il2cpp_array_size_t>(L_91));
V_7 = ((int32_t)((int32_t)L_87^(int32_t)L_92));
goto IL_01b5;
}
IL_0196:
{
int32_t L_93 = __this->get_Nk_13();
if ((((int32_t)L_93) <= ((int32_t)6)))
{
goto IL_01b5;
}
}
{
int32_t L_94 = V_6;
int32_t L_95 = __this->get_Nk_13();
if ((!(((uint32_t)((int32_t)((int32_t)L_94%(int32_t)L_95))) == ((uint32_t)4))))
{
goto IL_01b5;
}
}
{
uint32_t L_96 = V_7;
uint32_t L_97 = AesTransform_SubByte_mEDB43A2A4E83017475094E5616E7DBC56F945A24(__this, L_96, /*hidden argument*/NULL);
V_7 = L_97;
}
IL_01b5:
{
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_98 = V_2;
int32_t L_99 = V_6;
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_100 = V_2;
int32_t L_101 = V_6;
int32_t L_102 = __this->get_Nk_13();
NullCheck(L_100);
int32_t L_103 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_101, (int32_t)L_102));
uint32_t L_104 = (L_100)->GetAt(static_cast<il2cpp_array_size_t>(L_103));
uint32_t L_105 = V_7;
NullCheck(L_98);
(L_98)->SetAt(static_cast<il2cpp_array_size_t>(L_99), (uint32_t)((int32_t)((int32_t)L_104^(int32_t)L_105)));
int32_t L_106 = V_6;
V_6 = ((int32_t)il2cpp_codegen_add((int32_t)L_106, (int32_t)1));
}
IL_01cd:
{
int32_t L_107 = V_6;
int32_t L_108 = V_1;
if ((((int32_t)L_107) < ((int32_t)L_108)))
{
goto IL_0155;
}
}
{
bool L_109 = ___encryption1;
if (L_109)
{
goto IL_028a;
}
}
{
V_9 = 0;
int32_t L_110 = V_1;
V_10 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_110, (int32_t)4));
goto IL_021e;
}
IL_01e2:
{
V_11 = 0;
goto IL_020d;
}
IL_01e7:
{
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_111 = V_2;
int32_t L_112 = V_9;
int32_t L_113 = V_11;
NullCheck(L_111);
int32_t L_114 = ((int32_t)il2cpp_codegen_add((int32_t)L_112, (int32_t)L_113));
uint32_t L_115 = (L_111)->GetAt(static_cast<il2cpp_array_size_t>(L_114));
V_12 = L_115;
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_116 = V_2;
int32_t L_117 = V_9;
int32_t L_118 = V_11;
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_119 = V_2;
int32_t L_120 = V_10;
int32_t L_121 = V_11;
NullCheck(L_119);
int32_t L_122 = ((int32_t)il2cpp_codegen_add((int32_t)L_120, (int32_t)L_121));
uint32_t L_123 = (L_119)->GetAt(static_cast<il2cpp_array_size_t>(L_122));
NullCheck(L_116);
(L_116)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)il2cpp_codegen_add((int32_t)L_117, (int32_t)L_118))), (uint32_t)L_123);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_124 = V_2;
int32_t L_125 = V_10;
int32_t L_126 = V_11;
uint32_t L_127 = V_12;
NullCheck(L_124);
(L_124)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)il2cpp_codegen_add((int32_t)L_125, (int32_t)L_126))), (uint32_t)L_127);
int32_t L_128 = V_11;
V_11 = ((int32_t)il2cpp_codegen_add((int32_t)L_128, (int32_t)1));
}
IL_020d:
{
int32_t L_129 = V_11;
if ((((int32_t)L_129) < ((int32_t)4)))
{
goto IL_01e7;
}
}
{
int32_t L_130 = V_9;
V_9 = ((int32_t)il2cpp_codegen_add((int32_t)L_130, (int32_t)4));
int32_t L_131 = V_10;
V_10 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_131, (int32_t)4));
}
IL_021e:
{
int32_t L_132 = V_9;
int32_t L_133 = V_10;
if ((((int32_t)L_132) < ((int32_t)L_133)))
{
goto IL_01e2;
}
}
{
V_13 = 4;
goto IL_0281;
}
IL_0229:
{
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_134 = V_2;
int32_t L_135 = V_13;
IL2CPP_RUNTIME_CLASS_INIT(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_136 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_137 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_138 = V_2;
int32_t L_139 = V_13;
NullCheck(L_138);
int32_t L_140 = L_139;
uint32_t L_141 = (L_138)->GetAt(static_cast<il2cpp_array_size_t>(L_140));
NullCheck(L_137);
int32_t L_142 = ((int32_t)((uint32_t)L_141>>((int32_t)24)));
uint8_t L_143 = (L_137)->GetAt(static_cast<il2cpp_array_size_t>(L_142));
NullCheck(L_136);
uint8_t L_144 = L_143;
uint32_t L_145 = (L_136)->GetAt(static_cast<il2cpp_array_size_t>(L_144));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_146 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_147 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_148 = V_2;
int32_t L_149 = V_13;
NullCheck(L_148);
int32_t L_150 = L_149;
uint32_t L_151 = (L_148)->GetAt(static_cast<il2cpp_array_size_t>(L_150));
NullCheck(L_147);
int32_t L_152 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_151>>((int32_t)16))))));
uint8_t L_153 = (L_147)->GetAt(static_cast<il2cpp_array_size_t>(L_152));
NullCheck(L_146);
uint8_t L_154 = L_153;
uint32_t L_155 = (L_146)->GetAt(static_cast<il2cpp_array_size_t>(L_154));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_156 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_157 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_158 = V_2;
int32_t L_159 = V_13;
NullCheck(L_158);
int32_t L_160 = L_159;
uint32_t L_161 = (L_158)->GetAt(static_cast<il2cpp_array_size_t>(L_160));
NullCheck(L_157);
int32_t L_162 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_161>>8)))));
uint8_t L_163 = (L_157)->GetAt(static_cast<il2cpp_array_size_t>(L_162));
NullCheck(L_156);
uint8_t L_164 = L_163;
uint32_t L_165 = (L_156)->GetAt(static_cast<il2cpp_array_size_t>(L_164));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_166 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_167 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_168 = V_2;
int32_t L_169 = V_13;
NullCheck(L_168);
int32_t L_170 = L_169;
uint32_t L_171 = (L_168)->GetAt(static_cast<il2cpp_array_size_t>(L_170));
NullCheck(L_167);
int32_t L_172 = (((int32_t)((uint8_t)L_171)));
uint8_t L_173 = (L_167)->GetAt(static_cast<il2cpp_array_size_t>(L_172));
NullCheck(L_166);
uint8_t L_174 = L_173;
uint32_t L_175 = (L_166)->GetAt(static_cast<il2cpp_array_size_t>(L_174));
NullCheck(L_134);
(L_134)->SetAt(static_cast<il2cpp_array_size_t>(L_135), (uint32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_145^(int32_t)L_155))^(int32_t)L_165))^(int32_t)L_175)));
int32_t L_176 = V_13;
V_13 = ((int32_t)il2cpp_codegen_add((int32_t)L_176, (int32_t)1));
}
IL_0281:
{
int32_t L_177 = V_13;
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_178 = V_2;
NullCheck(L_178);
if ((((int32_t)L_177) < ((int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)(((int32_t)((int32_t)(((RuntimeArray*)L_178)->max_length)))), (int32_t)4)))))
{
goto IL_0229;
}
}
IL_028a:
{
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_179 = V_2;
__this->set_expandedKey_12(L_179);
return;
}
}
// System.Void System.Security.Cryptography.AesTransform::ECB(System.Byte[],System.Byte[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesTransform_ECB_mAFE52E4D1958026C3343F85CC950A8E24FDFBBDA (AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___input0, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___output1, const RuntimeMethod* method)
{
{
bool L_0 = ((SymmetricTransform_t413AE9CB2D31AA411A8F189123C15258929AC750 *)__this)->get_encrypt_1();
if (!L_0)
{
goto IL_0017;
}
}
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1 = ___input0;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_2 = ___output1;
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_3 = __this->get_expandedKey_12();
AesTransform_Encrypt128_m09C945A0345FD32E8DB3F4AF4B4E184CADD754DA(__this, L_1, L_2, L_3, /*hidden argument*/NULL);
return;
}
IL_0017:
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_4 = ___input0;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_5 = ___output1;
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_6 = __this->get_expandedKey_12();
AesTransform_Decrypt128_m1AE10B230A47A294B5B10EFD9C8243B02DBEA463(__this, L_4, L_5, L_6, /*hidden argument*/NULL);
return;
}
}
// System.UInt32 System.Security.Cryptography.AesTransform::SubByte(System.UInt32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t AesTransform_SubByte_mEDB43A2A4E83017475094E5616E7DBC56F945A24 (AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208 * __this, uint32_t ___a0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (AesTransform_SubByte_mEDB43A2A4E83017475094E5616E7DBC56F945A24_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
uint32_t V_0 = 0;
{
uint32_t L_0 = ___a0;
V_0 = ((int32_t)((int32_t)((int32_t)255)&(int32_t)L_0));
IL2CPP_RUNTIME_CLASS_INIT(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var);
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_2 = V_0;
NullCheck(L_1);
uint32_t L_3 = L_2;
uint8_t L_4 = (L_1)->GetAt(static_cast<il2cpp_array_size_t>(L_3));
uint32_t L_5 = ___a0;
V_0 = ((int32_t)((int32_t)((int32_t)255)&(int32_t)((int32_t)((uint32_t)L_5>>8))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_6 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_7 = V_0;
NullCheck(L_6);
uint32_t L_8 = L_7;
uint8_t L_9 = (L_6)->GetAt(static_cast<il2cpp_array_size_t>(L_8));
uint32_t L_10 = ___a0;
V_0 = ((int32_t)((int32_t)((int32_t)255)&(int32_t)((int32_t)((uint32_t)L_10>>((int32_t)16)))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_11 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_12 = V_0;
NullCheck(L_11);
uint32_t L_13 = L_12;
uint8_t L_14 = (L_11)->GetAt(static_cast<il2cpp_array_size_t>(L_13));
uint32_t L_15 = ___a0;
V_0 = ((int32_t)((int32_t)((int32_t)255)&(int32_t)((int32_t)((uint32_t)L_15>>((int32_t)24)))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_16 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_17 = V_0;
NullCheck(L_16);
uint32_t L_18 = L_17;
uint8_t L_19 = (L_16)->GetAt(static_cast<il2cpp_array_size_t>(L_18));
return ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_4|(int32_t)((int32_t)((int32_t)L_9<<(int32_t)8))))|(int32_t)((int32_t)((int32_t)L_14<<(int32_t)((int32_t)16)))))|(int32_t)((int32_t)((int32_t)L_19<<(int32_t)((int32_t)24)))));
}
}
// System.Void System.Security.Cryptography.AesTransform::Encrypt128(System.Byte[],System.Byte[],System.UInt32[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesTransform_Encrypt128_m09C945A0345FD32E8DB3F4AF4B4E184CADD754DA (AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___indata0, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___outdata1, UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___ekey2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (AesTransform_Encrypt128_m09C945A0345FD32E8DB3F4AF4B4E184CADD754DA_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
uint32_t V_0 = 0;
uint32_t V_1 = 0;
uint32_t V_2 = 0;
uint32_t V_3 = 0;
uint32_t V_4 = 0;
uint32_t V_5 = 0;
uint32_t V_6 = 0;
uint32_t V_7 = 0;
int32_t V_8 = 0;
{
V_8 = ((int32_t)40);
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_0 = ___indata0;
NullCheck(L_0);
int32_t L_1 = 0;
uint8_t L_2 = (L_0)->GetAt(static_cast<il2cpp_array_size_t>(L_1));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_3 = ___indata0;
NullCheck(L_3);
int32_t L_4 = 1;
uint8_t L_5 = (L_3)->GetAt(static_cast<il2cpp_array_size_t>(L_4));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_6 = ___indata0;
NullCheck(L_6);
int32_t L_7 = 2;
uint8_t L_8 = (L_6)->GetAt(static_cast<il2cpp_array_size_t>(L_7));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_9 = ___indata0;
NullCheck(L_9);
int32_t L_10 = 3;
uint8_t L_11 = (L_9)->GetAt(static_cast<il2cpp_array_size_t>(L_10));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_12 = ___ekey2;
NullCheck(L_12);
int32_t L_13 = 0;
uint32_t L_14 = (L_12)->GetAt(static_cast<il2cpp_array_size_t>(L_13));
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_2<<(int32_t)((int32_t)24)))|(int32_t)((int32_t)((int32_t)L_5<<(int32_t)((int32_t)16)))))|(int32_t)((int32_t)((int32_t)L_8<<(int32_t)8))))|(int32_t)L_11))^(int32_t)L_14));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_15 = ___indata0;
NullCheck(L_15);
int32_t L_16 = 4;
uint8_t L_17 = (L_15)->GetAt(static_cast<il2cpp_array_size_t>(L_16));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_18 = ___indata0;
NullCheck(L_18);
int32_t L_19 = 5;
uint8_t L_20 = (L_18)->GetAt(static_cast<il2cpp_array_size_t>(L_19));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_21 = ___indata0;
NullCheck(L_21);
int32_t L_22 = 6;
uint8_t L_23 = (L_21)->GetAt(static_cast<il2cpp_array_size_t>(L_22));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_24 = ___indata0;
NullCheck(L_24);
int32_t L_25 = 7;
uint8_t L_26 = (L_24)->GetAt(static_cast<il2cpp_array_size_t>(L_25));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_27 = ___ekey2;
NullCheck(L_27);
int32_t L_28 = 1;
uint32_t L_29 = (L_27)->GetAt(static_cast<il2cpp_array_size_t>(L_28));
V_1 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_17<<(int32_t)((int32_t)24)))|(int32_t)((int32_t)((int32_t)L_20<<(int32_t)((int32_t)16)))))|(int32_t)((int32_t)((int32_t)L_23<<(int32_t)8))))|(int32_t)L_26))^(int32_t)L_29));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_30 = ___indata0;
NullCheck(L_30);
int32_t L_31 = 8;
uint8_t L_32 = (L_30)->GetAt(static_cast<il2cpp_array_size_t>(L_31));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_33 = ___indata0;
NullCheck(L_33);
int32_t L_34 = ((int32_t)9);
uint8_t L_35 = (L_33)->GetAt(static_cast<il2cpp_array_size_t>(L_34));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_36 = ___indata0;
NullCheck(L_36);
int32_t L_37 = ((int32_t)10);
uint8_t L_38 = (L_36)->GetAt(static_cast<il2cpp_array_size_t>(L_37));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_39 = ___indata0;
NullCheck(L_39);
int32_t L_40 = ((int32_t)11);
uint8_t L_41 = (L_39)->GetAt(static_cast<il2cpp_array_size_t>(L_40));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_42 = ___ekey2;
NullCheck(L_42);
int32_t L_43 = 2;
uint32_t L_44 = (L_42)->GetAt(static_cast<il2cpp_array_size_t>(L_43));
V_2 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_32<<(int32_t)((int32_t)24)))|(int32_t)((int32_t)((int32_t)L_35<<(int32_t)((int32_t)16)))))|(int32_t)((int32_t)((int32_t)L_38<<(int32_t)8))))|(int32_t)L_41))^(int32_t)L_44));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_45 = ___indata0;
NullCheck(L_45);
int32_t L_46 = ((int32_t)12);
uint8_t L_47 = (L_45)->GetAt(static_cast<il2cpp_array_size_t>(L_46));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_48 = ___indata0;
NullCheck(L_48);
int32_t L_49 = ((int32_t)13);
uint8_t L_50 = (L_48)->GetAt(static_cast<il2cpp_array_size_t>(L_49));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_51 = ___indata0;
NullCheck(L_51);
int32_t L_52 = ((int32_t)14);
uint8_t L_53 = (L_51)->GetAt(static_cast<il2cpp_array_size_t>(L_52));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_54 = ___indata0;
NullCheck(L_54);
int32_t L_55 = ((int32_t)15);
uint8_t L_56 = (L_54)->GetAt(static_cast<il2cpp_array_size_t>(L_55));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_57 = ___ekey2;
NullCheck(L_57);
int32_t L_58 = 3;
uint32_t L_59 = (L_57)->GetAt(static_cast<il2cpp_array_size_t>(L_58));
V_3 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_47<<(int32_t)((int32_t)24)))|(int32_t)((int32_t)((int32_t)L_50<<(int32_t)((int32_t)16)))))|(int32_t)((int32_t)((int32_t)L_53<<(int32_t)8))))|(int32_t)L_56))^(int32_t)L_59));
IL2CPP_RUNTIME_CLASS_INIT(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_60 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_61 = V_0;
NullCheck(L_60);
int32_t L_62 = ((int32_t)((uint32_t)L_61>>((int32_t)24)));
uint32_t L_63 = (L_60)->GetAt(static_cast<il2cpp_array_size_t>(L_62));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_64 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_65 = V_1;
NullCheck(L_64);
int32_t L_66 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_65>>((int32_t)16))))));
uint32_t L_67 = (L_64)->GetAt(static_cast<il2cpp_array_size_t>(L_66));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_68 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_69 = V_2;
NullCheck(L_68);
int32_t L_70 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_69>>8)))));
uint32_t L_71 = (L_68)->GetAt(static_cast<il2cpp_array_size_t>(L_70));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_72 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_73 = V_3;
NullCheck(L_72);
int32_t L_74 = (((int32_t)((uint8_t)L_73)));
uint32_t L_75 = (L_72)->GetAt(static_cast<il2cpp_array_size_t>(L_74));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_76 = ___ekey2;
NullCheck(L_76);
int32_t L_77 = 4;
uint32_t L_78 = (L_76)->GetAt(static_cast<il2cpp_array_size_t>(L_77));
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_63^(int32_t)L_67))^(int32_t)L_71))^(int32_t)L_75))^(int32_t)L_78));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_79 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_80 = V_1;
NullCheck(L_79);
int32_t L_81 = ((int32_t)((uint32_t)L_80>>((int32_t)24)));
uint32_t L_82 = (L_79)->GetAt(static_cast<il2cpp_array_size_t>(L_81));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_83 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_84 = V_2;
NullCheck(L_83);
int32_t L_85 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_84>>((int32_t)16))))));
uint32_t L_86 = (L_83)->GetAt(static_cast<il2cpp_array_size_t>(L_85));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_87 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_88 = V_3;
NullCheck(L_87);
int32_t L_89 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_88>>8)))));
uint32_t L_90 = (L_87)->GetAt(static_cast<il2cpp_array_size_t>(L_89));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_91 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_92 = V_0;
NullCheck(L_91);
int32_t L_93 = (((int32_t)((uint8_t)L_92)));
uint32_t L_94 = (L_91)->GetAt(static_cast<il2cpp_array_size_t>(L_93));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_95 = ___ekey2;
NullCheck(L_95);
int32_t L_96 = 5;
uint32_t L_97 = (L_95)->GetAt(static_cast<il2cpp_array_size_t>(L_96));
V_5 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_82^(int32_t)L_86))^(int32_t)L_90))^(int32_t)L_94))^(int32_t)L_97));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_98 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_99 = V_2;
NullCheck(L_98);
int32_t L_100 = ((int32_t)((uint32_t)L_99>>((int32_t)24)));
uint32_t L_101 = (L_98)->GetAt(static_cast<il2cpp_array_size_t>(L_100));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_102 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_103 = V_3;
NullCheck(L_102);
int32_t L_104 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_103>>((int32_t)16))))));
uint32_t L_105 = (L_102)->GetAt(static_cast<il2cpp_array_size_t>(L_104));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_106 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_107 = V_0;
NullCheck(L_106);
int32_t L_108 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_107>>8)))));
uint32_t L_109 = (L_106)->GetAt(static_cast<il2cpp_array_size_t>(L_108));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_110 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_111 = V_1;
NullCheck(L_110);
int32_t L_112 = (((int32_t)((uint8_t)L_111)));
uint32_t L_113 = (L_110)->GetAt(static_cast<il2cpp_array_size_t>(L_112));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_114 = ___ekey2;
NullCheck(L_114);
int32_t L_115 = 6;
uint32_t L_116 = (L_114)->GetAt(static_cast<il2cpp_array_size_t>(L_115));
V_6 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_101^(int32_t)L_105))^(int32_t)L_109))^(int32_t)L_113))^(int32_t)L_116));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_117 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_118 = V_3;
NullCheck(L_117);
int32_t L_119 = ((int32_t)((uint32_t)L_118>>((int32_t)24)));
uint32_t L_120 = (L_117)->GetAt(static_cast<il2cpp_array_size_t>(L_119));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_121 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_122 = V_0;
NullCheck(L_121);
int32_t L_123 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_122>>((int32_t)16))))));
uint32_t L_124 = (L_121)->GetAt(static_cast<il2cpp_array_size_t>(L_123));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_125 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_126 = V_1;
NullCheck(L_125);
int32_t L_127 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_126>>8)))));
uint32_t L_128 = (L_125)->GetAt(static_cast<il2cpp_array_size_t>(L_127));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_129 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_130 = V_2;
NullCheck(L_129);
int32_t L_131 = (((int32_t)((uint8_t)L_130)));
uint32_t L_132 = (L_129)->GetAt(static_cast<il2cpp_array_size_t>(L_131));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_133 = ___ekey2;
NullCheck(L_133);
int32_t L_134 = 7;
uint32_t L_135 = (L_133)->GetAt(static_cast<il2cpp_array_size_t>(L_134));
V_7 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_120^(int32_t)L_124))^(int32_t)L_128))^(int32_t)L_132))^(int32_t)L_135));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_136 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_137 = V_4;
NullCheck(L_136);
int32_t L_138 = ((int32_t)((uint32_t)L_137>>((int32_t)24)));
uint32_t L_139 = (L_136)->GetAt(static_cast<il2cpp_array_size_t>(L_138));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_140 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_141 = V_5;
NullCheck(L_140);
int32_t L_142 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_141>>((int32_t)16))))));
uint32_t L_143 = (L_140)->GetAt(static_cast<il2cpp_array_size_t>(L_142));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_144 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_145 = V_6;
NullCheck(L_144);
int32_t L_146 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_145>>8)))));
uint32_t L_147 = (L_144)->GetAt(static_cast<il2cpp_array_size_t>(L_146));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_148 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_149 = V_7;
NullCheck(L_148);
int32_t L_150 = (((int32_t)((uint8_t)L_149)));
uint32_t L_151 = (L_148)->GetAt(static_cast<il2cpp_array_size_t>(L_150));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_152 = ___ekey2;
NullCheck(L_152);
int32_t L_153 = 8;
uint32_t L_154 = (L_152)->GetAt(static_cast<il2cpp_array_size_t>(L_153));
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_139^(int32_t)L_143))^(int32_t)L_147))^(int32_t)L_151))^(int32_t)L_154));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_155 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_156 = V_5;
NullCheck(L_155);
int32_t L_157 = ((int32_t)((uint32_t)L_156>>((int32_t)24)));
uint32_t L_158 = (L_155)->GetAt(static_cast<il2cpp_array_size_t>(L_157));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_159 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_160 = V_6;
NullCheck(L_159);
int32_t L_161 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_160>>((int32_t)16))))));
uint32_t L_162 = (L_159)->GetAt(static_cast<il2cpp_array_size_t>(L_161));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_163 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_164 = V_7;
NullCheck(L_163);
int32_t L_165 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_164>>8)))));
uint32_t L_166 = (L_163)->GetAt(static_cast<il2cpp_array_size_t>(L_165));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_167 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_168 = V_4;
NullCheck(L_167);
int32_t L_169 = (((int32_t)((uint8_t)L_168)));
uint32_t L_170 = (L_167)->GetAt(static_cast<il2cpp_array_size_t>(L_169));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_171 = ___ekey2;
NullCheck(L_171);
int32_t L_172 = ((int32_t)9);
uint32_t L_173 = (L_171)->GetAt(static_cast<il2cpp_array_size_t>(L_172));
V_1 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_158^(int32_t)L_162))^(int32_t)L_166))^(int32_t)L_170))^(int32_t)L_173));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_174 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_175 = V_6;
NullCheck(L_174);
int32_t L_176 = ((int32_t)((uint32_t)L_175>>((int32_t)24)));
uint32_t L_177 = (L_174)->GetAt(static_cast<il2cpp_array_size_t>(L_176));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_178 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_179 = V_7;
NullCheck(L_178);
int32_t L_180 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_179>>((int32_t)16))))));
uint32_t L_181 = (L_178)->GetAt(static_cast<il2cpp_array_size_t>(L_180));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_182 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_183 = V_4;
NullCheck(L_182);
int32_t L_184 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_183>>8)))));
uint32_t L_185 = (L_182)->GetAt(static_cast<il2cpp_array_size_t>(L_184));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_186 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_187 = V_5;
NullCheck(L_186);
int32_t L_188 = (((int32_t)((uint8_t)L_187)));
uint32_t L_189 = (L_186)->GetAt(static_cast<il2cpp_array_size_t>(L_188));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_190 = ___ekey2;
NullCheck(L_190);
int32_t L_191 = ((int32_t)10);
uint32_t L_192 = (L_190)->GetAt(static_cast<il2cpp_array_size_t>(L_191));
V_2 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_177^(int32_t)L_181))^(int32_t)L_185))^(int32_t)L_189))^(int32_t)L_192));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_193 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_194 = V_7;
NullCheck(L_193);
int32_t L_195 = ((int32_t)((uint32_t)L_194>>((int32_t)24)));
uint32_t L_196 = (L_193)->GetAt(static_cast<il2cpp_array_size_t>(L_195));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_197 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_198 = V_4;
NullCheck(L_197);
int32_t L_199 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_198>>((int32_t)16))))));
uint32_t L_200 = (L_197)->GetAt(static_cast<il2cpp_array_size_t>(L_199));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_201 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_202 = V_5;
NullCheck(L_201);
int32_t L_203 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_202>>8)))));
uint32_t L_204 = (L_201)->GetAt(static_cast<il2cpp_array_size_t>(L_203));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_205 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_206 = V_6;
NullCheck(L_205);
int32_t L_207 = (((int32_t)((uint8_t)L_206)));
uint32_t L_208 = (L_205)->GetAt(static_cast<il2cpp_array_size_t>(L_207));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_209 = ___ekey2;
NullCheck(L_209);
int32_t L_210 = ((int32_t)11);
uint32_t L_211 = (L_209)->GetAt(static_cast<il2cpp_array_size_t>(L_210));
V_3 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_196^(int32_t)L_200))^(int32_t)L_204))^(int32_t)L_208))^(int32_t)L_211));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_212 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_213 = V_0;
NullCheck(L_212);
int32_t L_214 = ((int32_t)((uint32_t)L_213>>((int32_t)24)));
uint32_t L_215 = (L_212)->GetAt(static_cast<il2cpp_array_size_t>(L_214));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_216 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_217 = V_1;
NullCheck(L_216);
int32_t L_218 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_217>>((int32_t)16))))));
uint32_t L_219 = (L_216)->GetAt(static_cast<il2cpp_array_size_t>(L_218));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_220 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_221 = V_2;
NullCheck(L_220);
int32_t L_222 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_221>>8)))));
uint32_t L_223 = (L_220)->GetAt(static_cast<il2cpp_array_size_t>(L_222));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_224 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_225 = V_3;
NullCheck(L_224);
int32_t L_226 = (((int32_t)((uint8_t)L_225)));
uint32_t L_227 = (L_224)->GetAt(static_cast<il2cpp_array_size_t>(L_226));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_228 = ___ekey2;
NullCheck(L_228);
int32_t L_229 = ((int32_t)12);
uint32_t L_230 = (L_228)->GetAt(static_cast<il2cpp_array_size_t>(L_229));
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_215^(int32_t)L_219))^(int32_t)L_223))^(int32_t)L_227))^(int32_t)L_230));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_231 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_232 = V_1;
NullCheck(L_231);
int32_t L_233 = ((int32_t)((uint32_t)L_232>>((int32_t)24)));
uint32_t L_234 = (L_231)->GetAt(static_cast<il2cpp_array_size_t>(L_233));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_235 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_236 = V_2;
NullCheck(L_235);
int32_t L_237 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_236>>((int32_t)16))))));
uint32_t L_238 = (L_235)->GetAt(static_cast<il2cpp_array_size_t>(L_237));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_239 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_240 = V_3;
NullCheck(L_239);
int32_t L_241 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_240>>8)))));
uint32_t L_242 = (L_239)->GetAt(static_cast<il2cpp_array_size_t>(L_241));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_243 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_244 = V_0;
NullCheck(L_243);
int32_t L_245 = (((int32_t)((uint8_t)L_244)));
uint32_t L_246 = (L_243)->GetAt(static_cast<il2cpp_array_size_t>(L_245));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_247 = ___ekey2;
NullCheck(L_247);
int32_t L_248 = ((int32_t)13);
uint32_t L_249 = (L_247)->GetAt(static_cast<il2cpp_array_size_t>(L_248));
V_5 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_234^(int32_t)L_238))^(int32_t)L_242))^(int32_t)L_246))^(int32_t)L_249));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_250 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_251 = V_2;
NullCheck(L_250);
int32_t L_252 = ((int32_t)((uint32_t)L_251>>((int32_t)24)));
uint32_t L_253 = (L_250)->GetAt(static_cast<il2cpp_array_size_t>(L_252));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_254 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_255 = V_3;
NullCheck(L_254);
int32_t L_256 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_255>>((int32_t)16))))));
uint32_t L_257 = (L_254)->GetAt(static_cast<il2cpp_array_size_t>(L_256));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_258 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_259 = V_0;
NullCheck(L_258);
int32_t L_260 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_259>>8)))));
uint32_t L_261 = (L_258)->GetAt(static_cast<il2cpp_array_size_t>(L_260));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_262 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_263 = V_1;
NullCheck(L_262);
int32_t L_264 = (((int32_t)((uint8_t)L_263)));
uint32_t L_265 = (L_262)->GetAt(static_cast<il2cpp_array_size_t>(L_264));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_266 = ___ekey2;
NullCheck(L_266);
int32_t L_267 = ((int32_t)14);
uint32_t L_268 = (L_266)->GetAt(static_cast<il2cpp_array_size_t>(L_267));
V_6 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_253^(int32_t)L_257))^(int32_t)L_261))^(int32_t)L_265))^(int32_t)L_268));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_269 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_270 = V_3;
NullCheck(L_269);
int32_t L_271 = ((int32_t)((uint32_t)L_270>>((int32_t)24)));
uint32_t L_272 = (L_269)->GetAt(static_cast<il2cpp_array_size_t>(L_271));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_273 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_274 = V_0;
NullCheck(L_273);
int32_t L_275 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_274>>((int32_t)16))))));
uint32_t L_276 = (L_273)->GetAt(static_cast<il2cpp_array_size_t>(L_275));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_277 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_278 = V_1;
NullCheck(L_277);
int32_t L_279 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_278>>8)))));
uint32_t L_280 = (L_277)->GetAt(static_cast<il2cpp_array_size_t>(L_279));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_281 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_282 = V_2;
NullCheck(L_281);
int32_t L_283 = (((int32_t)((uint8_t)L_282)));
uint32_t L_284 = (L_281)->GetAt(static_cast<il2cpp_array_size_t>(L_283));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_285 = ___ekey2;
NullCheck(L_285);
int32_t L_286 = ((int32_t)15);
uint32_t L_287 = (L_285)->GetAt(static_cast<il2cpp_array_size_t>(L_286));
V_7 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_272^(int32_t)L_276))^(int32_t)L_280))^(int32_t)L_284))^(int32_t)L_287));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_288 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_289 = V_4;
NullCheck(L_288);
int32_t L_290 = ((int32_t)((uint32_t)L_289>>((int32_t)24)));
uint32_t L_291 = (L_288)->GetAt(static_cast<il2cpp_array_size_t>(L_290));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_292 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_293 = V_5;
NullCheck(L_292);
int32_t L_294 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_293>>((int32_t)16))))));
uint32_t L_295 = (L_292)->GetAt(static_cast<il2cpp_array_size_t>(L_294));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_296 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_297 = V_6;
NullCheck(L_296);
int32_t L_298 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_297>>8)))));
uint32_t L_299 = (L_296)->GetAt(static_cast<il2cpp_array_size_t>(L_298));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_300 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_301 = V_7;
NullCheck(L_300);
int32_t L_302 = (((int32_t)((uint8_t)L_301)));
uint32_t L_303 = (L_300)->GetAt(static_cast<il2cpp_array_size_t>(L_302));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_304 = ___ekey2;
NullCheck(L_304);
int32_t L_305 = ((int32_t)16);
uint32_t L_306 = (L_304)->GetAt(static_cast<il2cpp_array_size_t>(L_305));
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_291^(int32_t)L_295))^(int32_t)L_299))^(int32_t)L_303))^(int32_t)L_306));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_307 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_308 = V_5;
NullCheck(L_307);
int32_t L_309 = ((int32_t)((uint32_t)L_308>>((int32_t)24)));
uint32_t L_310 = (L_307)->GetAt(static_cast<il2cpp_array_size_t>(L_309));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_311 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_312 = V_6;
NullCheck(L_311);
int32_t L_313 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_312>>((int32_t)16))))));
uint32_t L_314 = (L_311)->GetAt(static_cast<il2cpp_array_size_t>(L_313));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_315 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_316 = V_7;
NullCheck(L_315);
int32_t L_317 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_316>>8)))));
uint32_t L_318 = (L_315)->GetAt(static_cast<il2cpp_array_size_t>(L_317));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_319 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_320 = V_4;
NullCheck(L_319);
int32_t L_321 = (((int32_t)((uint8_t)L_320)));
uint32_t L_322 = (L_319)->GetAt(static_cast<il2cpp_array_size_t>(L_321));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_323 = ___ekey2;
NullCheck(L_323);
int32_t L_324 = ((int32_t)17);
uint32_t L_325 = (L_323)->GetAt(static_cast<il2cpp_array_size_t>(L_324));
V_1 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_310^(int32_t)L_314))^(int32_t)L_318))^(int32_t)L_322))^(int32_t)L_325));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_326 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_327 = V_6;
NullCheck(L_326);
int32_t L_328 = ((int32_t)((uint32_t)L_327>>((int32_t)24)));
uint32_t L_329 = (L_326)->GetAt(static_cast<il2cpp_array_size_t>(L_328));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_330 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_331 = V_7;
NullCheck(L_330);
int32_t L_332 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_331>>((int32_t)16))))));
uint32_t L_333 = (L_330)->GetAt(static_cast<il2cpp_array_size_t>(L_332));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_334 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_335 = V_4;
NullCheck(L_334);
int32_t L_336 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_335>>8)))));
uint32_t L_337 = (L_334)->GetAt(static_cast<il2cpp_array_size_t>(L_336));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_338 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_339 = V_5;
NullCheck(L_338);
int32_t L_340 = (((int32_t)((uint8_t)L_339)));
uint32_t L_341 = (L_338)->GetAt(static_cast<il2cpp_array_size_t>(L_340));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_342 = ___ekey2;
NullCheck(L_342);
int32_t L_343 = ((int32_t)18);
uint32_t L_344 = (L_342)->GetAt(static_cast<il2cpp_array_size_t>(L_343));
V_2 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_329^(int32_t)L_333))^(int32_t)L_337))^(int32_t)L_341))^(int32_t)L_344));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_345 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_346 = V_7;
NullCheck(L_345);
int32_t L_347 = ((int32_t)((uint32_t)L_346>>((int32_t)24)));
uint32_t L_348 = (L_345)->GetAt(static_cast<il2cpp_array_size_t>(L_347));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_349 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_350 = V_4;
NullCheck(L_349);
int32_t L_351 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_350>>((int32_t)16))))));
uint32_t L_352 = (L_349)->GetAt(static_cast<il2cpp_array_size_t>(L_351));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_353 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_354 = V_5;
NullCheck(L_353);
int32_t L_355 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_354>>8)))));
uint32_t L_356 = (L_353)->GetAt(static_cast<il2cpp_array_size_t>(L_355));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_357 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_358 = V_6;
NullCheck(L_357);
int32_t L_359 = (((int32_t)((uint8_t)L_358)));
uint32_t L_360 = (L_357)->GetAt(static_cast<il2cpp_array_size_t>(L_359));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_361 = ___ekey2;
NullCheck(L_361);
int32_t L_362 = ((int32_t)19);
uint32_t L_363 = (L_361)->GetAt(static_cast<il2cpp_array_size_t>(L_362));
V_3 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_348^(int32_t)L_352))^(int32_t)L_356))^(int32_t)L_360))^(int32_t)L_363));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_364 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_365 = V_0;
NullCheck(L_364);
int32_t L_366 = ((int32_t)((uint32_t)L_365>>((int32_t)24)));
uint32_t L_367 = (L_364)->GetAt(static_cast<il2cpp_array_size_t>(L_366));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_368 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_369 = V_1;
NullCheck(L_368);
int32_t L_370 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_369>>((int32_t)16))))));
uint32_t L_371 = (L_368)->GetAt(static_cast<il2cpp_array_size_t>(L_370));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_372 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_373 = V_2;
NullCheck(L_372);
int32_t L_374 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_373>>8)))));
uint32_t L_375 = (L_372)->GetAt(static_cast<il2cpp_array_size_t>(L_374));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_376 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_377 = V_3;
NullCheck(L_376);
int32_t L_378 = (((int32_t)((uint8_t)L_377)));
uint32_t L_379 = (L_376)->GetAt(static_cast<il2cpp_array_size_t>(L_378));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_380 = ___ekey2;
NullCheck(L_380);
int32_t L_381 = ((int32_t)20);
uint32_t L_382 = (L_380)->GetAt(static_cast<il2cpp_array_size_t>(L_381));
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_367^(int32_t)L_371))^(int32_t)L_375))^(int32_t)L_379))^(int32_t)L_382));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_383 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_384 = V_1;
NullCheck(L_383);
int32_t L_385 = ((int32_t)((uint32_t)L_384>>((int32_t)24)));
uint32_t L_386 = (L_383)->GetAt(static_cast<il2cpp_array_size_t>(L_385));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_387 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_388 = V_2;
NullCheck(L_387);
int32_t L_389 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_388>>((int32_t)16))))));
uint32_t L_390 = (L_387)->GetAt(static_cast<il2cpp_array_size_t>(L_389));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_391 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_392 = V_3;
NullCheck(L_391);
int32_t L_393 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_392>>8)))));
uint32_t L_394 = (L_391)->GetAt(static_cast<il2cpp_array_size_t>(L_393));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_395 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_396 = V_0;
NullCheck(L_395);
int32_t L_397 = (((int32_t)((uint8_t)L_396)));
uint32_t L_398 = (L_395)->GetAt(static_cast<il2cpp_array_size_t>(L_397));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_399 = ___ekey2;
NullCheck(L_399);
int32_t L_400 = ((int32_t)21);
uint32_t L_401 = (L_399)->GetAt(static_cast<il2cpp_array_size_t>(L_400));
V_5 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_386^(int32_t)L_390))^(int32_t)L_394))^(int32_t)L_398))^(int32_t)L_401));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_402 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_403 = V_2;
NullCheck(L_402);
int32_t L_404 = ((int32_t)((uint32_t)L_403>>((int32_t)24)));
uint32_t L_405 = (L_402)->GetAt(static_cast<il2cpp_array_size_t>(L_404));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_406 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_407 = V_3;
NullCheck(L_406);
int32_t L_408 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_407>>((int32_t)16))))));
uint32_t L_409 = (L_406)->GetAt(static_cast<il2cpp_array_size_t>(L_408));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_410 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_411 = V_0;
NullCheck(L_410);
int32_t L_412 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_411>>8)))));
uint32_t L_413 = (L_410)->GetAt(static_cast<il2cpp_array_size_t>(L_412));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_414 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_415 = V_1;
NullCheck(L_414);
int32_t L_416 = (((int32_t)((uint8_t)L_415)));
uint32_t L_417 = (L_414)->GetAt(static_cast<il2cpp_array_size_t>(L_416));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_418 = ___ekey2;
NullCheck(L_418);
int32_t L_419 = ((int32_t)22);
uint32_t L_420 = (L_418)->GetAt(static_cast<il2cpp_array_size_t>(L_419));
V_6 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_405^(int32_t)L_409))^(int32_t)L_413))^(int32_t)L_417))^(int32_t)L_420));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_421 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_422 = V_3;
NullCheck(L_421);
int32_t L_423 = ((int32_t)((uint32_t)L_422>>((int32_t)24)));
uint32_t L_424 = (L_421)->GetAt(static_cast<il2cpp_array_size_t>(L_423));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_425 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_426 = V_0;
NullCheck(L_425);
int32_t L_427 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_426>>((int32_t)16))))));
uint32_t L_428 = (L_425)->GetAt(static_cast<il2cpp_array_size_t>(L_427));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_429 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_430 = V_1;
NullCheck(L_429);
int32_t L_431 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_430>>8)))));
uint32_t L_432 = (L_429)->GetAt(static_cast<il2cpp_array_size_t>(L_431));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_433 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_434 = V_2;
NullCheck(L_433);
int32_t L_435 = (((int32_t)((uint8_t)L_434)));
uint32_t L_436 = (L_433)->GetAt(static_cast<il2cpp_array_size_t>(L_435));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_437 = ___ekey2;
NullCheck(L_437);
int32_t L_438 = ((int32_t)23);
uint32_t L_439 = (L_437)->GetAt(static_cast<il2cpp_array_size_t>(L_438));
V_7 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_424^(int32_t)L_428))^(int32_t)L_432))^(int32_t)L_436))^(int32_t)L_439));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_440 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_441 = V_4;
NullCheck(L_440);
int32_t L_442 = ((int32_t)((uint32_t)L_441>>((int32_t)24)));
uint32_t L_443 = (L_440)->GetAt(static_cast<il2cpp_array_size_t>(L_442));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_444 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_445 = V_5;
NullCheck(L_444);
int32_t L_446 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_445>>((int32_t)16))))));
uint32_t L_447 = (L_444)->GetAt(static_cast<il2cpp_array_size_t>(L_446));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_448 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_449 = V_6;
NullCheck(L_448);
int32_t L_450 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_449>>8)))));
uint32_t L_451 = (L_448)->GetAt(static_cast<il2cpp_array_size_t>(L_450));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_452 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_453 = V_7;
NullCheck(L_452);
int32_t L_454 = (((int32_t)((uint8_t)L_453)));
uint32_t L_455 = (L_452)->GetAt(static_cast<il2cpp_array_size_t>(L_454));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_456 = ___ekey2;
NullCheck(L_456);
int32_t L_457 = ((int32_t)24);
uint32_t L_458 = (L_456)->GetAt(static_cast<il2cpp_array_size_t>(L_457));
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_443^(int32_t)L_447))^(int32_t)L_451))^(int32_t)L_455))^(int32_t)L_458));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_459 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_460 = V_5;
NullCheck(L_459);
int32_t L_461 = ((int32_t)((uint32_t)L_460>>((int32_t)24)));
uint32_t L_462 = (L_459)->GetAt(static_cast<il2cpp_array_size_t>(L_461));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_463 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_464 = V_6;
NullCheck(L_463);
int32_t L_465 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_464>>((int32_t)16))))));
uint32_t L_466 = (L_463)->GetAt(static_cast<il2cpp_array_size_t>(L_465));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_467 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_468 = V_7;
NullCheck(L_467);
int32_t L_469 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_468>>8)))));
uint32_t L_470 = (L_467)->GetAt(static_cast<il2cpp_array_size_t>(L_469));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_471 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_472 = V_4;
NullCheck(L_471);
int32_t L_473 = (((int32_t)((uint8_t)L_472)));
uint32_t L_474 = (L_471)->GetAt(static_cast<il2cpp_array_size_t>(L_473));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_475 = ___ekey2;
NullCheck(L_475);
int32_t L_476 = ((int32_t)25);
uint32_t L_477 = (L_475)->GetAt(static_cast<il2cpp_array_size_t>(L_476));
V_1 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_462^(int32_t)L_466))^(int32_t)L_470))^(int32_t)L_474))^(int32_t)L_477));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_478 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_479 = V_6;
NullCheck(L_478);
int32_t L_480 = ((int32_t)((uint32_t)L_479>>((int32_t)24)));
uint32_t L_481 = (L_478)->GetAt(static_cast<il2cpp_array_size_t>(L_480));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_482 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_483 = V_7;
NullCheck(L_482);
int32_t L_484 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_483>>((int32_t)16))))));
uint32_t L_485 = (L_482)->GetAt(static_cast<il2cpp_array_size_t>(L_484));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_486 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_487 = V_4;
NullCheck(L_486);
int32_t L_488 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_487>>8)))));
uint32_t L_489 = (L_486)->GetAt(static_cast<il2cpp_array_size_t>(L_488));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_490 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_491 = V_5;
NullCheck(L_490);
int32_t L_492 = (((int32_t)((uint8_t)L_491)));
uint32_t L_493 = (L_490)->GetAt(static_cast<il2cpp_array_size_t>(L_492));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_494 = ___ekey2;
NullCheck(L_494);
int32_t L_495 = ((int32_t)26);
uint32_t L_496 = (L_494)->GetAt(static_cast<il2cpp_array_size_t>(L_495));
V_2 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_481^(int32_t)L_485))^(int32_t)L_489))^(int32_t)L_493))^(int32_t)L_496));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_497 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_498 = V_7;
NullCheck(L_497);
int32_t L_499 = ((int32_t)((uint32_t)L_498>>((int32_t)24)));
uint32_t L_500 = (L_497)->GetAt(static_cast<il2cpp_array_size_t>(L_499));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_501 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_502 = V_4;
NullCheck(L_501);
int32_t L_503 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_502>>((int32_t)16))))));
uint32_t L_504 = (L_501)->GetAt(static_cast<il2cpp_array_size_t>(L_503));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_505 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_506 = V_5;
NullCheck(L_505);
int32_t L_507 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_506>>8)))));
uint32_t L_508 = (L_505)->GetAt(static_cast<il2cpp_array_size_t>(L_507));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_509 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_510 = V_6;
NullCheck(L_509);
int32_t L_511 = (((int32_t)((uint8_t)L_510)));
uint32_t L_512 = (L_509)->GetAt(static_cast<il2cpp_array_size_t>(L_511));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_513 = ___ekey2;
NullCheck(L_513);
int32_t L_514 = ((int32_t)27);
uint32_t L_515 = (L_513)->GetAt(static_cast<il2cpp_array_size_t>(L_514));
V_3 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_500^(int32_t)L_504))^(int32_t)L_508))^(int32_t)L_512))^(int32_t)L_515));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_516 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_517 = V_0;
NullCheck(L_516);
int32_t L_518 = ((int32_t)((uint32_t)L_517>>((int32_t)24)));
uint32_t L_519 = (L_516)->GetAt(static_cast<il2cpp_array_size_t>(L_518));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_520 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_521 = V_1;
NullCheck(L_520);
int32_t L_522 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_521>>((int32_t)16))))));
uint32_t L_523 = (L_520)->GetAt(static_cast<il2cpp_array_size_t>(L_522));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_524 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_525 = V_2;
NullCheck(L_524);
int32_t L_526 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_525>>8)))));
uint32_t L_527 = (L_524)->GetAt(static_cast<il2cpp_array_size_t>(L_526));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_528 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_529 = V_3;
NullCheck(L_528);
int32_t L_530 = (((int32_t)((uint8_t)L_529)));
uint32_t L_531 = (L_528)->GetAt(static_cast<il2cpp_array_size_t>(L_530));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_532 = ___ekey2;
NullCheck(L_532);
int32_t L_533 = ((int32_t)28);
uint32_t L_534 = (L_532)->GetAt(static_cast<il2cpp_array_size_t>(L_533));
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_519^(int32_t)L_523))^(int32_t)L_527))^(int32_t)L_531))^(int32_t)L_534));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_535 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_536 = V_1;
NullCheck(L_535);
int32_t L_537 = ((int32_t)((uint32_t)L_536>>((int32_t)24)));
uint32_t L_538 = (L_535)->GetAt(static_cast<il2cpp_array_size_t>(L_537));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_539 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_540 = V_2;
NullCheck(L_539);
int32_t L_541 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_540>>((int32_t)16))))));
uint32_t L_542 = (L_539)->GetAt(static_cast<il2cpp_array_size_t>(L_541));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_543 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_544 = V_3;
NullCheck(L_543);
int32_t L_545 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_544>>8)))));
uint32_t L_546 = (L_543)->GetAt(static_cast<il2cpp_array_size_t>(L_545));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_547 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_548 = V_0;
NullCheck(L_547);
int32_t L_549 = (((int32_t)((uint8_t)L_548)));
uint32_t L_550 = (L_547)->GetAt(static_cast<il2cpp_array_size_t>(L_549));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_551 = ___ekey2;
NullCheck(L_551);
int32_t L_552 = ((int32_t)29);
uint32_t L_553 = (L_551)->GetAt(static_cast<il2cpp_array_size_t>(L_552));
V_5 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_538^(int32_t)L_542))^(int32_t)L_546))^(int32_t)L_550))^(int32_t)L_553));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_554 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_555 = V_2;
NullCheck(L_554);
int32_t L_556 = ((int32_t)((uint32_t)L_555>>((int32_t)24)));
uint32_t L_557 = (L_554)->GetAt(static_cast<il2cpp_array_size_t>(L_556));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_558 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_559 = V_3;
NullCheck(L_558);
int32_t L_560 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_559>>((int32_t)16))))));
uint32_t L_561 = (L_558)->GetAt(static_cast<il2cpp_array_size_t>(L_560));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_562 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_563 = V_0;
NullCheck(L_562);
int32_t L_564 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_563>>8)))));
uint32_t L_565 = (L_562)->GetAt(static_cast<il2cpp_array_size_t>(L_564));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_566 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_567 = V_1;
NullCheck(L_566);
int32_t L_568 = (((int32_t)((uint8_t)L_567)));
uint32_t L_569 = (L_566)->GetAt(static_cast<il2cpp_array_size_t>(L_568));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_570 = ___ekey2;
NullCheck(L_570);
int32_t L_571 = ((int32_t)30);
uint32_t L_572 = (L_570)->GetAt(static_cast<il2cpp_array_size_t>(L_571));
V_6 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_557^(int32_t)L_561))^(int32_t)L_565))^(int32_t)L_569))^(int32_t)L_572));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_573 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_574 = V_3;
NullCheck(L_573);
int32_t L_575 = ((int32_t)((uint32_t)L_574>>((int32_t)24)));
uint32_t L_576 = (L_573)->GetAt(static_cast<il2cpp_array_size_t>(L_575));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_577 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_578 = V_0;
NullCheck(L_577);
int32_t L_579 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_578>>((int32_t)16))))));
uint32_t L_580 = (L_577)->GetAt(static_cast<il2cpp_array_size_t>(L_579));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_581 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_582 = V_1;
NullCheck(L_581);
int32_t L_583 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_582>>8)))));
uint32_t L_584 = (L_581)->GetAt(static_cast<il2cpp_array_size_t>(L_583));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_585 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_586 = V_2;
NullCheck(L_585);
int32_t L_587 = (((int32_t)((uint8_t)L_586)));
uint32_t L_588 = (L_585)->GetAt(static_cast<il2cpp_array_size_t>(L_587));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_589 = ___ekey2;
NullCheck(L_589);
int32_t L_590 = ((int32_t)31);
uint32_t L_591 = (L_589)->GetAt(static_cast<il2cpp_array_size_t>(L_590));
V_7 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_576^(int32_t)L_580))^(int32_t)L_584))^(int32_t)L_588))^(int32_t)L_591));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_592 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_593 = V_4;
NullCheck(L_592);
int32_t L_594 = ((int32_t)((uint32_t)L_593>>((int32_t)24)));
uint32_t L_595 = (L_592)->GetAt(static_cast<il2cpp_array_size_t>(L_594));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_596 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_597 = V_5;
NullCheck(L_596);
int32_t L_598 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_597>>((int32_t)16))))));
uint32_t L_599 = (L_596)->GetAt(static_cast<il2cpp_array_size_t>(L_598));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_600 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_601 = V_6;
NullCheck(L_600);
int32_t L_602 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_601>>8)))));
uint32_t L_603 = (L_600)->GetAt(static_cast<il2cpp_array_size_t>(L_602));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_604 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_605 = V_7;
NullCheck(L_604);
int32_t L_606 = (((int32_t)((uint8_t)L_605)));
uint32_t L_607 = (L_604)->GetAt(static_cast<il2cpp_array_size_t>(L_606));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_608 = ___ekey2;
NullCheck(L_608);
int32_t L_609 = ((int32_t)32);
uint32_t L_610 = (L_608)->GetAt(static_cast<il2cpp_array_size_t>(L_609));
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_595^(int32_t)L_599))^(int32_t)L_603))^(int32_t)L_607))^(int32_t)L_610));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_611 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_612 = V_5;
NullCheck(L_611);
int32_t L_613 = ((int32_t)((uint32_t)L_612>>((int32_t)24)));
uint32_t L_614 = (L_611)->GetAt(static_cast<il2cpp_array_size_t>(L_613));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_615 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_616 = V_6;
NullCheck(L_615);
int32_t L_617 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_616>>((int32_t)16))))));
uint32_t L_618 = (L_615)->GetAt(static_cast<il2cpp_array_size_t>(L_617));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_619 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_620 = V_7;
NullCheck(L_619);
int32_t L_621 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_620>>8)))));
uint32_t L_622 = (L_619)->GetAt(static_cast<il2cpp_array_size_t>(L_621));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_623 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_624 = V_4;
NullCheck(L_623);
int32_t L_625 = (((int32_t)((uint8_t)L_624)));
uint32_t L_626 = (L_623)->GetAt(static_cast<il2cpp_array_size_t>(L_625));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_627 = ___ekey2;
NullCheck(L_627);
int32_t L_628 = ((int32_t)33);
uint32_t L_629 = (L_627)->GetAt(static_cast<il2cpp_array_size_t>(L_628));
V_1 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_614^(int32_t)L_618))^(int32_t)L_622))^(int32_t)L_626))^(int32_t)L_629));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_630 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_631 = V_6;
NullCheck(L_630);
int32_t L_632 = ((int32_t)((uint32_t)L_631>>((int32_t)24)));
uint32_t L_633 = (L_630)->GetAt(static_cast<il2cpp_array_size_t>(L_632));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_634 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_635 = V_7;
NullCheck(L_634);
int32_t L_636 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_635>>((int32_t)16))))));
uint32_t L_637 = (L_634)->GetAt(static_cast<il2cpp_array_size_t>(L_636));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_638 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_639 = V_4;
NullCheck(L_638);
int32_t L_640 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_639>>8)))));
uint32_t L_641 = (L_638)->GetAt(static_cast<il2cpp_array_size_t>(L_640));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_642 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_643 = V_5;
NullCheck(L_642);
int32_t L_644 = (((int32_t)((uint8_t)L_643)));
uint32_t L_645 = (L_642)->GetAt(static_cast<il2cpp_array_size_t>(L_644));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_646 = ___ekey2;
NullCheck(L_646);
int32_t L_647 = ((int32_t)34);
uint32_t L_648 = (L_646)->GetAt(static_cast<il2cpp_array_size_t>(L_647));
V_2 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_633^(int32_t)L_637))^(int32_t)L_641))^(int32_t)L_645))^(int32_t)L_648));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_649 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_650 = V_7;
NullCheck(L_649);
int32_t L_651 = ((int32_t)((uint32_t)L_650>>((int32_t)24)));
uint32_t L_652 = (L_649)->GetAt(static_cast<il2cpp_array_size_t>(L_651));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_653 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_654 = V_4;
NullCheck(L_653);
int32_t L_655 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_654>>((int32_t)16))))));
uint32_t L_656 = (L_653)->GetAt(static_cast<il2cpp_array_size_t>(L_655));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_657 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_658 = V_5;
NullCheck(L_657);
int32_t L_659 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_658>>8)))));
uint32_t L_660 = (L_657)->GetAt(static_cast<il2cpp_array_size_t>(L_659));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_661 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_662 = V_6;
NullCheck(L_661);
int32_t L_663 = (((int32_t)((uint8_t)L_662)));
uint32_t L_664 = (L_661)->GetAt(static_cast<il2cpp_array_size_t>(L_663));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_665 = ___ekey2;
NullCheck(L_665);
int32_t L_666 = ((int32_t)35);
uint32_t L_667 = (L_665)->GetAt(static_cast<il2cpp_array_size_t>(L_666));
V_3 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_652^(int32_t)L_656))^(int32_t)L_660))^(int32_t)L_664))^(int32_t)L_667));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_668 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_669 = V_0;
NullCheck(L_668);
int32_t L_670 = ((int32_t)((uint32_t)L_669>>((int32_t)24)));
uint32_t L_671 = (L_668)->GetAt(static_cast<il2cpp_array_size_t>(L_670));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_672 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_673 = V_1;
NullCheck(L_672);
int32_t L_674 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_673>>((int32_t)16))))));
uint32_t L_675 = (L_672)->GetAt(static_cast<il2cpp_array_size_t>(L_674));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_676 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_677 = V_2;
NullCheck(L_676);
int32_t L_678 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_677>>8)))));
uint32_t L_679 = (L_676)->GetAt(static_cast<il2cpp_array_size_t>(L_678));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_680 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_681 = V_3;
NullCheck(L_680);
int32_t L_682 = (((int32_t)((uint8_t)L_681)));
uint32_t L_683 = (L_680)->GetAt(static_cast<il2cpp_array_size_t>(L_682));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_684 = ___ekey2;
NullCheck(L_684);
int32_t L_685 = ((int32_t)36);
uint32_t L_686 = (L_684)->GetAt(static_cast<il2cpp_array_size_t>(L_685));
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_671^(int32_t)L_675))^(int32_t)L_679))^(int32_t)L_683))^(int32_t)L_686));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_687 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_688 = V_1;
NullCheck(L_687);
int32_t L_689 = ((int32_t)((uint32_t)L_688>>((int32_t)24)));
uint32_t L_690 = (L_687)->GetAt(static_cast<il2cpp_array_size_t>(L_689));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_691 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_692 = V_2;
NullCheck(L_691);
int32_t L_693 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_692>>((int32_t)16))))));
uint32_t L_694 = (L_691)->GetAt(static_cast<il2cpp_array_size_t>(L_693));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_695 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_696 = V_3;
NullCheck(L_695);
int32_t L_697 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_696>>8)))));
uint32_t L_698 = (L_695)->GetAt(static_cast<il2cpp_array_size_t>(L_697));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_699 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_700 = V_0;
NullCheck(L_699);
int32_t L_701 = (((int32_t)((uint8_t)L_700)));
uint32_t L_702 = (L_699)->GetAt(static_cast<il2cpp_array_size_t>(L_701));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_703 = ___ekey2;
NullCheck(L_703);
int32_t L_704 = ((int32_t)37);
uint32_t L_705 = (L_703)->GetAt(static_cast<il2cpp_array_size_t>(L_704));
V_5 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_690^(int32_t)L_694))^(int32_t)L_698))^(int32_t)L_702))^(int32_t)L_705));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_706 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_707 = V_2;
NullCheck(L_706);
int32_t L_708 = ((int32_t)((uint32_t)L_707>>((int32_t)24)));
uint32_t L_709 = (L_706)->GetAt(static_cast<il2cpp_array_size_t>(L_708));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_710 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_711 = V_3;
NullCheck(L_710);
int32_t L_712 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_711>>((int32_t)16))))));
uint32_t L_713 = (L_710)->GetAt(static_cast<il2cpp_array_size_t>(L_712));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_714 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_715 = V_0;
NullCheck(L_714);
int32_t L_716 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_715>>8)))));
uint32_t L_717 = (L_714)->GetAt(static_cast<il2cpp_array_size_t>(L_716));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_718 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_719 = V_1;
NullCheck(L_718);
int32_t L_720 = (((int32_t)((uint8_t)L_719)));
uint32_t L_721 = (L_718)->GetAt(static_cast<il2cpp_array_size_t>(L_720));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_722 = ___ekey2;
NullCheck(L_722);
int32_t L_723 = ((int32_t)38);
uint32_t L_724 = (L_722)->GetAt(static_cast<il2cpp_array_size_t>(L_723));
V_6 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_709^(int32_t)L_713))^(int32_t)L_717))^(int32_t)L_721))^(int32_t)L_724));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_725 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_726 = V_3;
NullCheck(L_725);
int32_t L_727 = ((int32_t)((uint32_t)L_726>>((int32_t)24)));
uint32_t L_728 = (L_725)->GetAt(static_cast<il2cpp_array_size_t>(L_727));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_729 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_730 = V_0;
NullCheck(L_729);
int32_t L_731 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_730>>((int32_t)16))))));
uint32_t L_732 = (L_729)->GetAt(static_cast<il2cpp_array_size_t>(L_731));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_733 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_734 = V_1;
NullCheck(L_733);
int32_t L_735 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_734>>8)))));
uint32_t L_736 = (L_733)->GetAt(static_cast<il2cpp_array_size_t>(L_735));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_737 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_738 = V_2;
NullCheck(L_737);
int32_t L_739 = (((int32_t)((uint8_t)L_738)));
uint32_t L_740 = (L_737)->GetAt(static_cast<il2cpp_array_size_t>(L_739));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_741 = ___ekey2;
NullCheck(L_741);
int32_t L_742 = ((int32_t)39);
uint32_t L_743 = (L_741)->GetAt(static_cast<il2cpp_array_size_t>(L_742));
V_7 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_728^(int32_t)L_732))^(int32_t)L_736))^(int32_t)L_740))^(int32_t)L_743));
int32_t L_744 = __this->get_Nr_14();
if ((((int32_t)L_744) <= ((int32_t)((int32_t)10))))
{
goto IL_0ad4;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_745 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_746 = V_4;
NullCheck(L_745);
int32_t L_747 = ((int32_t)((uint32_t)L_746>>((int32_t)24)));
uint32_t L_748 = (L_745)->GetAt(static_cast<il2cpp_array_size_t>(L_747));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_749 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_750 = V_5;
NullCheck(L_749);
int32_t L_751 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_750>>((int32_t)16))))));
uint32_t L_752 = (L_749)->GetAt(static_cast<il2cpp_array_size_t>(L_751));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_753 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_754 = V_6;
NullCheck(L_753);
int32_t L_755 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_754>>8)))));
uint32_t L_756 = (L_753)->GetAt(static_cast<il2cpp_array_size_t>(L_755));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_757 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_758 = V_7;
NullCheck(L_757);
int32_t L_759 = (((int32_t)((uint8_t)L_758)));
uint32_t L_760 = (L_757)->GetAt(static_cast<il2cpp_array_size_t>(L_759));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_761 = ___ekey2;
NullCheck(L_761);
int32_t L_762 = ((int32_t)40);
uint32_t L_763 = (L_761)->GetAt(static_cast<il2cpp_array_size_t>(L_762));
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_748^(int32_t)L_752))^(int32_t)L_756))^(int32_t)L_760))^(int32_t)L_763));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_764 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_765 = V_5;
NullCheck(L_764);
int32_t L_766 = ((int32_t)((uint32_t)L_765>>((int32_t)24)));
uint32_t L_767 = (L_764)->GetAt(static_cast<il2cpp_array_size_t>(L_766));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_768 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_769 = V_6;
NullCheck(L_768);
int32_t L_770 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_769>>((int32_t)16))))));
uint32_t L_771 = (L_768)->GetAt(static_cast<il2cpp_array_size_t>(L_770));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_772 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_773 = V_7;
NullCheck(L_772);
int32_t L_774 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_773>>8)))));
uint32_t L_775 = (L_772)->GetAt(static_cast<il2cpp_array_size_t>(L_774));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_776 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_777 = V_4;
NullCheck(L_776);
int32_t L_778 = (((int32_t)((uint8_t)L_777)));
uint32_t L_779 = (L_776)->GetAt(static_cast<il2cpp_array_size_t>(L_778));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_780 = ___ekey2;
NullCheck(L_780);
int32_t L_781 = ((int32_t)41);
uint32_t L_782 = (L_780)->GetAt(static_cast<il2cpp_array_size_t>(L_781));
V_1 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_767^(int32_t)L_771))^(int32_t)L_775))^(int32_t)L_779))^(int32_t)L_782));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_783 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_784 = V_6;
NullCheck(L_783);
int32_t L_785 = ((int32_t)((uint32_t)L_784>>((int32_t)24)));
uint32_t L_786 = (L_783)->GetAt(static_cast<il2cpp_array_size_t>(L_785));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_787 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_788 = V_7;
NullCheck(L_787);
int32_t L_789 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_788>>((int32_t)16))))));
uint32_t L_790 = (L_787)->GetAt(static_cast<il2cpp_array_size_t>(L_789));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_791 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_792 = V_4;
NullCheck(L_791);
int32_t L_793 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_792>>8)))));
uint32_t L_794 = (L_791)->GetAt(static_cast<il2cpp_array_size_t>(L_793));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_795 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_796 = V_5;
NullCheck(L_795);
int32_t L_797 = (((int32_t)((uint8_t)L_796)));
uint32_t L_798 = (L_795)->GetAt(static_cast<il2cpp_array_size_t>(L_797));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_799 = ___ekey2;
NullCheck(L_799);
int32_t L_800 = ((int32_t)42);
uint32_t L_801 = (L_799)->GetAt(static_cast<il2cpp_array_size_t>(L_800));
V_2 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_786^(int32_t)L_790))^(int32_t)L_794))^(int32_t)L_798))^(int32_t)L_801));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_802 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_803 = V_7;
NullCheck(L_802);
int32_t L_804 = ((int32_t)((uint32_t)L_803>>((int32_t)24)));
uint32_t L_805 = (L_802)->GetAt(static_cast<il2cpp_array_size_t>(L_804));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_806 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_807 = V_4;
NullCheck(L_806);
int32_t L_808 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_807>>((int32_t)16))))));
uint32_t L_809 = (L_806)->GetAt(static_cast<il2cpp_array_size_t>(L_808));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_810 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_811 = V_5;
NullCheck(L_810);
int32_t L_812 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_811>>8)))));
uint32_t L_813 = (L_810)->GetAt(static_cast<il2cpp_array_size_t>(L_812));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_814 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_815 = V_6;
NullCheck(L_814);
int32_t L_816 = (((int32_t)((uint8_t)L_815)));
uint32_t L_817 = (L_814)->GetAt(static_cast<il2cpp_array_size_t>(L_816));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_818 = ___ekey2;
NullCheck(L_818);
int32_t L_819 = ((int32_t)43);
uint32_t L_820 = (L_818)->GetAt(static_cast<il2cpp_array_size_t>(L_819));
V_3 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_805^(int32_t)L_809))^(int32_t)L_813))^(int32_t)L_817))^(int32_t)L_820));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_821 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_822 = V_0;
NullCheck(L_821);
int32_t L_823 = ((int32_t)((uint32_t)L_822>>((int32_t)24)));
uint32_t L_824 = (L_821)->GetAt(static_cast<il2cpp_array_size_t>(L_823));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_825 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_826 = V_1;
NullCheck(L_825);
int32_t L_827 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_826>>((int32_t)16))))));
uint32_t L_828 = (L_825)->GetAt(static_cast<il2cpp_array_size_t>(L_827));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_829 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_830 = V_2;
NullCheck(L_829);
int32_t L_831 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_830>>8)))));
uint32_t L_832 = (L_829)->GetAt(static_cast<il2cpp_array_size_t>(L_831));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_833 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_834 = V_3;
NullCheck(L_833);
int32_t L_835 = (((int32_t)((uint8_t)L_834)));
uint32_t L_836 = (L_833)->GetAt(static_cast<il2cpp_array_size_t>(L_835));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_837 = ___ekey2;
NullCheck(L_837);
int32_t L_838 = ((int32_t)44);
uint32_t L_839 = (L_837)->GetAt(static_cast<il2cpp_array_size_t>(L_838));
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_824^(int32_t)L_828))^(int32_t)L_832))^(int32_t)L_836))^(int32_t)L_839));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_840 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_841 = V_1;
NullCheck(L_840);
int32_t L_842 = ((int32_t)((uint32_t)L_841>>((int32_t)24)));
uint32_t L_843 = (L_840)->GetAt(static_cast<il2cpp_array_size_t>(L_842));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_844 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_845 = V_2;
NullCheck(L_844);
int32_t L_846 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_845>>((int32_t)16))))));
uint32_t L_847 = (L_844)->GetAt(static_cast<il2cpp_array_size_t>(L_846));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_848 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_849 = V_3;
NullCheck(L_848);
int32_t L_850 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_849>>8)))));
uint32_t L_851 = (L_848)->GetAt(static_cast<il2cpp_array_size_t>(L_850));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_852 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_853 = V_0;
NullCheck(L_852);
int32_t L_854 = (((int32_t)((uint8_t)L_853)));
uint32_t L_855 = (L_852)->GetAt(static_cast<il2cpp_array_size_t>(L_854));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_856 = ___ekey2;
NullCheck(L_856);
int32_t L_857 = ((int32_t)45);
uint32_t L_858 = (L_856)->GetAt(static_cast<il2cpp_array_size_t>(L_857));
V_5 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_843^(int32_t)L_847))^(int32_t)L_851))^(int32_t)L_855))^(int32_t)L_858));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_859 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_860 = V_2;
NullCheck(L_859);
int32_t L_861 = ((int32_t)((uint32_t)L_860>>((int32_t)24)));
uint32_t L_862 = (L_859)->GetAt(static_cast<il2cpp_array_size_t>(L_861));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_863 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_864 = V_3;
NullCheck(L_863);
int32_t L_865 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_864>>((int32_t)16))))));
uint32_t L_866 = (L_863)->GetAt(static_cast<il2cpp_array_size_t>(L_865));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_867 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_868 = V_0;
NullCheck(L_867);
int32_t L_869 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_868>>8)))));
uint32_t L_870 = (L_867)->GetAt(static_cast<il2cpp_array_size_t>(L_869));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_871 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_872 = V_1;
NullCheck(L_871);
int32_t L_873 = (((int32_t)((uint8_t)L_872)));
uint32_t L_874 = (L_871)->GetAt(static_cast<il2cpp_array_size_t>(L_873));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_875 = ___ekey2;
NullCheck(L_875);
int32_t L_876 = ((int32_t)46);
uint32_t L_877 = (L_875)->GetAt(static_cast<il2cpp_array_size_t>(L_876));
V_6 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_862^(int32_t)L_866))^(int32_t)L_870))^(int32_t)L_874))^(int32_t)L_877));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_878 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_879 = V_3;
NullCheck(L_878);
int32_t L_880 = ((int32_t)((uint32_t)L_879>>((int32_t)24)));
uint32_t L_881 = (L_878)->GetAt(static_cast<il2cpp_array_size_t>(L_880));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_882 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_883 = V_0;
NullCheck(L_882);
int32_t L_884 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_883>>((int32_t)16))))));
uint32_t L_885 = (L_882)->GetAt(static_cast<il2cpp_array_size_t>(L_884));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_886 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_887 = V_1;
NullCheck(L_886);
int32_t L_888 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_887>>8)))));
uint32_t L_889 = (L_886)->GetAt(static_cast<il2cpp_array_size_t>(L_888));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_890 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_891 = V_2;
NullCheck(L_890);
int32_t L_892 = (((int32_t)((uint8_t)L_891)));
uint32_t L_893 = (L_890)->GetAt(static_cast<il2cpp_array_size_t>(L_892));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_894 = ___ekey2;
NullCheck(L_894);
int32_t L_895 = ((int32_t)47);
uint32_t L_896 = (L_894)->GetAt(static_cast<il2cpp_array_size_t>(L_895));
V_7 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_881^(int32_t)L_885))^(int32_t)L_889))^(int32_t)L_893))^(int32_t)L_896));
V_8 = ((int32_t)48);
int32_t L_897 = __this->get_Nr_14();
if ((((int32_t)L_897) <= ((int32_t)((int32_t)12))))
{
goto IL_0ad4;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_898 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_899 = V_4;
NullCheck(L_898);
int32_t L_900 = ((int32_t)((uint32_t)L_899>>((int32_t)24)));
uint32_t L_901 = (L_898)->GetAt(static_cast<il2cpp_array_size_t>(L_900));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_902 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_903 = V_5;
NullCheck(L_902);
int32_t L_904 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_903>>((int32_t)16))))));
uint32_t L_905 = (L_902)->GetAt(static_cast<il2cpp_array_size_t>(L_904));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_906 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_907 = V_6;
NullCheck(L_906);
int32_t L_908 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_907>>8)))));
uint32_t L_909 = (L_906)->GetAt(static_cast<il2cpp_array_size_t>(L_908));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_910 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_911 = V_7;
NullCheck(L_910);
int32_t L_912 = (((int32_t)((uint8_t)L_911)));
uint32_t L_913 = (L_910)->GetAt(static_cast<il2cpp_array_size_t>(L_912));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_914 = ___ekey2;
NullCheck(L_914);
int32_t L_915 = ((int32_t)48);
uint32_t L_916 = (L_914)->GetAt(static_cast<il2cpp_array_size_t>(L_915));
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_901^(int32_t)L_905))^(int32_t)L_909))^(int32_t)L_913))^(int32_t)L_916));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_917 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_918 = V_5;
NullCheck(L_917);
int32_t L_919 = ((int32_t)((uint32_t)L_918>>((int32_t)24)));
uint32_t L_920 = (L_917)->GetAt(static_cast<il2cpp_array_size_t>(L_919));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_921 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_922 = V_6;
NullCheck(L_921);
int32_t L_923 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_922>>((int32_t)16))))));
uint32_t L_924 = (L_921)->GetAt(static_cast<il2cpp_array_size_t>(L_923));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_925 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_926 = V_7;
NullCheck(L_925);
int32_t L_927 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_926>>8)))));
uint32_t L_928 = (L_925)->GetAt(static_cast<il2cpp_array_size_t>(L_927));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_929 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_930 = V_4;
NullCheck(L_929);
int32_t L_931 = (((int32_t)((uint8_t)L_930)));
uint32_t L_932 = (L_929)->GetAt(static_cast<il2cpp_array_size_t>(L_931));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_933 = ___ekey2;
NullCheck(L_933);
int32_t L_934 = ((int32_t)49);
uint32_t L_935 = (L_933)->GetAt(static_cast<il2cpp_array_size_t>(L_934));
V_1 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_920^(int32_t)L_924))^(int32_t)L_928))^(int32_t)L_932))^(int32_t)L_935));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_936 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_937 = V_6;
NullCheck(L_936);
int32_t L_938 = ((int32_t)((uint32_t)L_937>>((int32_t)24)));
uint32_t L_939 = (L_936)->GetAt(static_cast<il2cpp_array_size_t>(L_938));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_940 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_941 = V_7;
NullCheck(L_940);
int32_t L_942 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_941>>((int32_t)16))))));
uint32_t L_943 = (L_940)->GetAt(static_cast<il2cpp_array_size_t>(L_942));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_944 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_945 = V_4;
NullCheck(L_944);
int32_t L_946 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_945>>8)))));
uint32_t L_947 = (L_944)->GetAt(static_cast<il2cpp_array_size_t>(L_946));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_948 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_949 = V_5;
NullCheck(L_948);
int32_t L_950 = (((int32_t)((uint8_t)L_949)));
uint32_t L_951 = (L_948)->GetAt(static_cast<il2cpp_array_size_t>(L_950));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_952 = ___ekey2;
NullCheck(L_952);
int32_t L_953 = ((int32_t)50);
uint32_t L_954 = (L_952)->GetAt(static_cast<il2cpp_array_size_t>(L_953));
V_2 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_939^(int32_t)L_943))^(int32_t)L_947))^(int32_t)L_951))^(int32_t)L_954));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_955 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_956 = V_7;
NullCheck(L_955);
int32_t L_957 = ((int32_t)((uint32_t)L_956>>((int32_t)24)));
uint32_t L_958 = (L_955)->GetAt(static_cast<il2cpp_array_size_t>(L_957));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_959 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_960 = V_4;
NullCheck(L_959);
int32_t L_961 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_960>>((int32_t)16))))));
uint32_t L_962 = (L_959)->GetAt(static_cast<il2cpp_array_size_t>(L_961));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_963 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_964 = V_5;
NullCheck(L_963);
int32_t L_965 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_964>>8)))));
uint32_t L_966 = (L_963)->GetAt(static_cast<il2cpp_array_size_t>(L_965));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_967 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_968 = V_6;
NullCheck(L_967);
int32_t L_969 = (((int32_t)((uint8_t)L_968)));
uint32_t L_970 = (L_967)->GetAt(static_cast<il2cpp_array_size_t>(L_969));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_971 = ___ekey2;
NullCheck(L_971);
int32_t L_972 = ((int32_t)51);
uint32_t L_973 = (L_971)->GetAt(static_cast<il2cpp_array_size_t>(L_972));
V_3 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_958^(int32_t)L_962))^(int32_t)L_966))^(int32_t)L_970))^(int32_t)L_973));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_974 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_975 = V_0;
NullCheck(L_974);
int32_t L_976 = ((int32_t)((uint32_t)L_975>>((int32_t)24)));
uint32_t L_977 = (L_974)->GetAt(static_cast<il2cpp_array_size_t>(L_976));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_978 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_979 = V_1;
NullCheck(L_978);
int32_t L_980 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_979>>((int32_t)16))))));
uint32_t L_981 = (L_978)->GetAt(static_cast<il2cpp_array_size_t>(L_980));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_982 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_983 = V_2;
NullCheck(L_982);
int32_t L_984 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_983>>8)))));
uint32_t L_985 = (L_982)->GetAt(static_cast<il2cpp_array_size_t>(L_984));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_986 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_987 = V_3;
NullCheck(L_986);
int32_t L_988 = (((int32_t)((uint8_t)L_987)));
uint32_t L_989 = (L_986)->GetAt(static_cast<il2cpp_array_size_t>(L_988));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_990 = ___ekey2;
NullCheck(L_990);
int32_t L_991 = ((int32_t)52);
uint32_t L_992 = (L_990)->GetAt(static_cast<il2cpp_array_size_t>(L_991));
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_977^(int32_t)L_981))^(int32_t)L_985))^(int32_t)L_989))^(int32_t)L_992));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_993 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_994 = V_1;
NullCheck(L_993);
int32_t L_995 = ((int32_t)((uint32_t)L_994>>((int32_t)24)));
uint32_t L_996 = (L_993)->GetAt(static_cast<il2cpp_array_size_t>(L_995));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_997 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_998 = V_2;
NullCheck(L_997);
int32_t L_999 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_998>>((int32_t)16))))));
uint32_t L_1000 = (L_997)->GetAt(static_cast<il2cpp_array_size_t>(L_999));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1001 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_1002 = V_3;
NullCheck(L_1001);
int32_t L_1003 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1002>>8)))));
uint32_t L_1004 = (L_1001)->GetAt(static_cast<il2cpp_array_size_t>(L_1003));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1005 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_1006 = V_0;
NullCheck(L_1005);
int32_t L_1007 = (((int32_t)((uint8_t)L_1006)));
uint32_t L_1008 = (L_1005)->GetAt(static_cast<il2cpp_array_size_t>(L_1007));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1009 = ___ekey2;
NullCheck(L_1009);
int32_t L_1010 = ((int32_t)53);
uint32_t L_1011 = (L_1009)->GetAt(static_cast<il2cpp_array_size_t>(L_1010));
V_5 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_996^(int32_t)L_1000))^(int32_t)L_1004))^(int32_t)L_1008))^(int32_t)L_1011));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1012 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_1013 = V_2;
NullCheck(L_1012);
int32_t L_1014 = ((int32_t)((uint32_t)L_1013>>((int32_t)24)));
uint32_t L_1015 = (L_1012)->GetAt(static_cast<il2cpp_array_size_t>(L_1014));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1016 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_1017 = V_3;
NullCheck(L_1016);
int32_t L_1018 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1017>>((int32_t)16))))));
uint32_t L_1019 = (L_1016)->GetAt(static_cast<il2cpp_array_size_t>(L_1018));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1020 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_1021 = V_0;
NullCheck(L_1020);
int32_t L_1022 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1021>>8)))));
uint32_t L_1023 = (L_1020)->GetAt(static_cast<il2cpp_array_size_t>(L_1022));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1024 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_1025 = V_1;
NullCheck(L_1024);
int32_t L_1026 = (((int32_t)((uint8_t)L_1025)));
uint32_t L_1027 = (L_1024)->GetAt(static_cast<il2cpp_array_size_t>(L_1026));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1028 = ___ekey2;
NullCheck(L_1028);
int32_t L_1029 = ((int32_t)54);
uint32_t L_1030 = (L_1028)->GetAt(static_cast<il2cpp_array_size_t>(L_1029));
V_6 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_1015^(int32_t)L_1019))^(int32_t)L_1023))^(int32_t)L_1027))^(int32_t)L_1030));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1031 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T0_18();
uint32_t L_1032 = V_3;
NullCheck(L_1031);
int32_t L_1033 = ((int32_t)((uint32_t)L_1032>>((int32_t)24)));
uint32_t L_1034 = (L_1031)->GetAt(static_cast<il2cpp_array_size_t>(L_1033));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1035 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T1_19();
uint32_t L_1036 = V_0;
NullCheck(L_1035);
int32_t L_1037 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1036>>((int32_t)16))))));
uint32_t L_1038 = (L_1035)->GetAt(static_cast<il2cpp_array_size_t>(L_1037));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1039 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T2_20();
uint32_t L_1040 = V_1;
NullCheck(L_1039);
int32_t L_1041 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1040>>8)))));
uint32_t L_1042 = (L_1039)->GetAt(static_cast<il2cpp_array_size_t>(L_1041));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1043 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_T3_21();
uint32_t L_1044 = V_2;
NullCheck(L_1043);
int32_t L_1045 = (((int32_t)((uint8_t)L_1044)));
uint32_t L_1046 = (L_1043)->GetAt(static_cast<il2cpp_array_size_t>(L_1045));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1047 = ___ekey2;
NullCheck(L_1047);
int32_t L_1048 = ((int32_t)55);
uint32_t L_1049 = (L_1047)->GetAt(static_cast<il2cpp_array_size_t>(L_1048));
V_7 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_1034^(int32_t)L_1038))^(int32_t)L_1042))^(int32_t)L_1046))^(int32_t)L_1049));
V_8 = ((int32_t)56);
}
IL_0ad4:
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1050 = ___outdata1;
IL2CPP_RUNTIME_CLASS_INIT(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var);
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1051 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1052 = V_4;
NullCheck(L_1051);
int32_t L_1053 = ((int32_t)((uint32_t)L_1052>>((int32_t)24)));
uint8_t L_1054 = (L_1051)->GetAt(static_cast<il2cpp_array_size_t>(L_1053));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1055 = ___ekey2;
int32_t L_1056 = V_8;
NullCheck(L_1055);
int32_t L_1057 = L_1056;
uint32_t L_1058 = (L_1055)->GetAt(static_cast<il2cpp_array_size_t>(L_1057));
NullCheck(L_1050);
(L_1050)->SetAt(static_cast<il2cpp_array_size_t>(0), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1054^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1058>>((int32_t)24))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1059 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1060 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1061 = V_5;
NullCheck(L_1060);
int32_t L_1062 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1061>>((int32_t)16))))));
uint8_t L_1063 = (L_1060)->GetAt(static_cast<il2cpp_array_size_t>(L_1062));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1064 = ___ekey2;
int32_t L_1065 = V_8;
NullCheck(L_1064);
int32_t L_1066 = L_1065;
uint32_t L_1067 = (L_1064)->GetAt(static_cast<il2cpp_array_size_t>(L_1066));
NullCheck(L_1059);
(L_1059)->SetAt(static_cast<il2cpp_array_size_t>(1), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1063^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1067>>((int32_t)16))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1068 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1069 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1070 = V_6;
NullCheck(L_1069);
int32_t L_1071 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1070>>8)))));
uint8_t L_1072 = (L_1069)->GetAt(static_cast<il2cpp_array_size_t>(L_1071));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1073 = ___ekey2;
int32_t L_1074 = V_8;
NullCheck(L_1073);
int32_t L_1075 = L_1074;
uint32_t L_1076 = (L_1073)->GetAt(static_cast<il2cpp_array_size_t>(L_1075));
NullCheck(L_1068);
(L_1068)->SetAt(static_cast<il2cpp_array_size_t>(2), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1072^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1076>>8)))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1077 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1078 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1079 = V_7;
NullCheck(L_1078);
int32_t L_1080 = (((int32_t)((uint8_t)L_1079)));
uint8_t L_1081 = (L_1078)->GetAt(static_cast<il2cpp_array_size_t>(L_1080));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1082 = ___ekey2;
int32_t L_1083 = V_8;
int32_t L_1084 = L_1083;
V_8 = ((int32_t)il2cpp_codegen_add((int32_t)L_1084, (int32_t)1));
NullCheck(L_1082);
int32_t L_1085 = L_1084;
uint32_t L_1086 = (L_1082)->GetAt(static_cast<il2cpp_array_size_t>(L_1085));
NullCheck(L_1077);
(L_1077)->SetAt(static_cast<il2cpp_array_size_t>(3), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1081^(int32_t)(((int32_t)((uint8_t)L_1086)))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1087 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1088 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1089 = V_5;
NullCheck(L_1088);
int32_t L_1090 = ((int32_t)((uint32_t)L_1089>>((int32_t)24)));
uint8_t L_1091 = (L_1088)->GetAt(static_cast<il2cpp_array_size_t>(L_1090));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1092 = ___ekey2;
int32_t L_1093 = V_8;
NullCheck(L_1092);
int32_t L_1094 = L_1093;
uint32_t L_1095 = (L_1092)->GetAt(static_cast<il2cpp_array_size_t>(L_1094));
NullCheck(L_1087);
(L_1087)->SetAt(static_cast<il2cpp_array_size_t>(4), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1091^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1095>>((int32_t)24))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1096 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1097 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1098 = V_6;
NullCheck(L_1097);
int32_t L_1099 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1098>>((int32_t)16))))));
uint8_t L_1100 = (L_1097)->GetAt(static_cast<il2cpp_array_size_t>(L_1099));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1101 = ___ekey2;
int32_t L_1102 = V_8;
NullCheck(L_1101);
int32_t L_1103 = L_1102;
uint32_t L_1104 = (L_1101)->GetAt(static_cast<il2cpp_array_size_t>(L_1103));
NullCheck(L_1096);
(L_1096)->SetAt(static_cast<il2cpp_array_size_t>(5), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1100^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1104>>((int32_t)16))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1105 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1106 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1107 = V_7;
NullCheck(L_1106);
int32_t L_1108 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1107>>8)))));
uint8_t L_1109 = (L_1106)->GetAt(static_cast<il2cpp_array_size_t>(L_1108));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1110 = ___ekey2;
int32_t L_1111 = V_8;
NullCheck(L_1110);
int32_t L_1112 = L_1111;
uint32_t L_1113 = (L_1110)->GetAt(static_cast<il2cpp_array_size_t>(L_1112));
NullCheck(L_1105);
(L_1105)->SetAt(static_cast<il2cpp_array_size_t>(6), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1109^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1113>>8)))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1114 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1115 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1116 = V_4;
NullCheck(L_1115);
int32_t L_1117 = (((int32_t)((uint8_t)L_1116)));
uint8_t L_1118 = (L_1115)->GetAt(static_cast<il2cpp_array_size_t>(L_1117));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1119 = ___ekey2;
int32_t L_1120 = V_8;
int32_t L_1121 = L_1120;
V_8 = ((int32_t)il2cpp_codegen_add((int32_t)L_1121, (int32_t)1));
NullCheck(L_1119);
int32_t L_1122 = L_1121;
uint32_t L_1123 = (L_1119)->GetAt(static_cast<il2cpp_array_size_t>(L_1122));
NullCheck(L_1114);
(L_1114)->SetAt(static_cast<il2cpp_array_size_t>(7), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1118^(int32_t)(((int32_t)((uint8_t)L_1123)))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1124 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1125 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1126 = V_6;
NullCheck(L_1125);
int32_t L_1127 = ((int32_t)((uint32_t)L_1126>>((int32_t)24)));
uint8_t L_1128 = (L_1125)->GetAt(static_cast<il2cpp_array_size_t>(L_1127));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1129 = ___ekey2;
int32_t L_1130 = V_8;
NullCheck(L_1129);
int32_t L_1131 = L_1130;
uint32_t L_1132 = (L_1129)->GetAt(static_cast<il2cpp_array_size_t>(L_1131));
NullCheck(L_1124);
(L_1124)->SetAt(static_cast<il2cpp_array_size_t>(8), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1128^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1132>>((int32_t)24))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1133 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1134 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1135 = V_7;
NullCheck(L_1134);
int32_t L_1136 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1135>>((int32_t)16))))));
uint8_t L_1137 = (L_1134)->GetAt(static_cast<il2cpp_array_size_t>(L_1136));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1138 = ___ekey2;
int32_t L_1139 = V_8;
NullCheck(L_1138);
int32_t L_1140 = L_1139;
uint32_t L_1141 = (L_1138)->GetAt(static_cast<il2cpp_array_size_t>(L_1140));
NullCheck(L_1133);
(L_1133)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)9)), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1137^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1141>>((int32_t)16))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1142 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1143 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1144 = V_4;
NullCheck(L_1143);
int32_t L_1145 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1144>>8)))));
uint8_t L_1146 = (L_1143)->GetAt(static_cast<il2cpp_array_size_t>(L_1145));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1147 = ___ekey2;
int32_t L_1148 = V_8;
NullCheck(L_1147);
int32_t L_1149 = L_1148;
uint32_t L_1150 = (L_1147)->GetAt(static_cast<il2cpp_array_size_t>(L_1149));
NullCheck(L_1142);
(L_1142)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)10)), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1146^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1150>>8)))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1151 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1152 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1153 = V_5;
NullCheck(L_1152);
int32_t L_1154 = (((int32_t)((uint8_t)L_1153)));
uint8_t L_1155 = (L_1152)->GetAt(static_cast<il2cpp_array_size_t>(L_1154));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1156 = ___ekey2;
int32_t L_1157 = V_8;
int32_t L_1158 = L_1157;
V_8 = ((int32_t)il2cpp_codegen_add((int32_t)L_1158, (int32_t)1));
NullCheck(L_1156);
int32_t L_1159 = L_1158;
uint32_t L_1160 = (L_1156)->GetAt(static_cast<il2cpp_array_size_t>(L_1159));
NullCheck(L_1151);
(L_1151)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)11)), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1155^(int32_t)(((int32_t)((uint8_t)L_1160)))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1161 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1162 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1163 = V_7;
NullCheck(L_1162);
int32_t L_1164 = ((int32_t)((uint32_t)L_1163>>((int32_t)24)));
uint8_t L_1165 = (L_1162)->GetAt(static_cast<il2cpp_array_size_t>(L_1164));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1166 = ___ekey2;
int32_t L_1167 = V_8;
NullCheck(L_1166);
int32_t L_1168 = L_1167;
uint32_t L_1169 = (L_1166)->GetAt(static_cast<il2cpp_array_size_t>(L_1168));
NullCheck(L_1161);
(L_1161)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)12)), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1165^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1169>>((int32_t)24))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1170 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1171 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1172 = V_4;
NullCheck(L_1171);
int32_t L_1173 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1172>>((int32_t)16))))));
uint8_t L_1174 = (L_1171)->GetAt(static_cast<il2cpp_array_size_t>(L_1173));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1175 = ___ekey2;
int32_t L_1176 = V_8;
NullCheck(L_1175);
int32_t L_1177 = L_1176;
uint32_t L_1178 = (L_1175)->GetAt(static_cast<il2cpp_array_size_t>(L_1177));
NullCheck(L_1170);
(L_1170)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)13)), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1174^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1178>>((int32_t)16))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1179 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1180 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1181 = V_5;
NullCheck(L_1180);
int32_t L_1182 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1181>>8)))));
uint8_t L_1183 = (L_1180)->GetAt(static_cast<il2cpp_array_size_t>(L_1182));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1184 = ___ekey2;
int32_t L_1185 = V_8;
NullCheck(L_1184);
int32_t L_1186 = L_1185;
uint32_t L_1187 = (L_1184)->GetAt(static_cast<il2cpp_array_size_t>(L_1186));
NullCheck(L_1179);
(L_1179)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)14)), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1183^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1187>>8)))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1188 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1189 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_SBox_16();
uint32_t L_1190 = V_6;
NullCheck(L_1189);
int32_t L_1191 = (((int32_t)((uint8_t)L_1190)));
uint8_t L_1192 = (L_1189)->GetAt(static_cast<il2cpp_array_size_t>(L_1191));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1193 = ___ekey2;
int32_t L_1194 = V_8;
int32_t L_1195 = L_1194;
V_8 = ((int32_t)il2cpp_codegen_add((int32_t)L_1195, (int32_t)1));
NullCheck(L_1193);
int32_t L_1196 = L_1195;
uint32_t L_1197 = (L_1193)->GetAt(static_cast<il2cpp_array_size_t>(L_1196));
NullCheck(L_1188);
(L_1188)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)15)), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1192^(int32_t)(((int32_t)((uint8_t)L_1197)))))))));
return;
}
}
// System.Void System.Security.Cryptography.AesTransform::Decrypt128(System.Byte[],System.Byte[],System.UInt32[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesTransform_Decrypt128_m1AE10B230A47A294B5B10EFD9C8243B02DBEA463 (AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208 * __this, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___indata0, ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* ___outdata1, UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* ___ekey2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (AesTransform_Decrypt128_m1AE10B230A47A294B5B10EFD9C8243B02DBEA463_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
uint32_t V_0 = 0;
uint32_t V_1 = 0;
uint32_t V_2 = 0;
uint32_t V_3 = 0;
uint32_t V_4 = 0;
uint32_t V_5 = 0;
uint32_t V_6 = 0;
uint32_t V_7 = 0;
int32_t V_8 = 0;
{
V_8 = ((int32_t)40);
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_0 = ___indata0;
NullCheck(L_0);
int32_t L_1 = 0;
uint8_t L_2 = (L_0)->GetAt(static_cast<il2cpp_array_size_t>(L_1));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_3 = ___indata0;
NullCheck(L_3);
int32_t L_4 = 1;
uint8_t L_5 = (L_3)->GetAt(static_cast<il2cpp_array_size_t>(L_4));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_6 = ___indata0;
NullCheck(L_6);
int32_t L_7 = 2;
uint8_t L_8 = (L_6)->GetAt(static_cast<il2cpp_array_size_t>(L_7));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_9 = ___indata0;
NullCheck(L_9);
int32_t L_10 = 3;
uint8_t L_11 = (L_9)->GetAt(static_cast<il2cpp_array_size_t>(L_10));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_12 = ___ekey2;
NullCheck(L_12);
int32_t L_13 = 0;
uint32_t L_14 = (L_12)->GetAt(static_cast<il2cpp_array_size_t>(L_13));
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_2<<(int32_t)((int32_t)24)))|(int32_t)((int32_t)((int32_t)L_5<<(int32_t)((int32_t)16)))))|(int32_t)((int32_t)((int32_t)L_8<<(int32_t)8))))|(int32_t)L_11))^(int32_t)L_14));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_15 = ___indata0;
NullCheck(L_15);
int32_t L_16 = 4;
uint8_t L_17 = (L_15)->GetAt(static_cast<il2cpp_array_size_t>(L_16));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_18 = ___indata0;
NullCheck(L_18);
int32_t L_19 = 5;
uint8_t L_20 = (L_18)->GetAt(static_cast<il2cpp_array_size_t>(L_19));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_21 = ___indata0;
NullCheck(L_21);
int32_t L_22 = 6;
uint8_t L_23 = (L_21)->GetAt(static_cast<il2cpp_array_size_t>(L_22));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_24 = ___indata0;
NullCheck(L_24);
int32_t L_25 = 7;
uint8_t L_26 = (L_24)->GetAt(static_cast<il2cpp_array_size_t>(L_25));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_27 = ___ekey2;
NullCheck(L_27);
int32_t L_28 = 1;
uint32_t L_29 = (L_27)->GetAt(static_cast<il2cpp_array_size_t>(L_28));
V_1 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_17<<(int32_t)((int32_t)24)))|(int32_t)((int32_t)((int32_t)L_20<<(int32_t)((int32_t)16)))))|(int32_t)((int32_t)((int32_t)L_23<<(int32_t)8))))|(int32_t)L_26))^(int32_t)L_29));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_30 = ___indata0;
NullCheck(L_30);
int32_t L_31 = 8;
uint8_t L_32 = (L_30)->GetAt(static_cast<il2cpp_array_size_t>(L_31));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_33 = ___indata0;
NullCheck(L_33);
int32_t L_34 = ((int32_t)9);
uint8_t L_35 = (L_33)->GetAt(static_cast<il2cpp_array_size_t>(L_34));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_36 = ___indata0;
NullCheck(L_36);
int32_t L_37 = ((int32_t)10);
uint8_t L_38 = (L_36)->GetAt(static_cast<il2cpp_array_size_t>(L_37));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_39 = ___indata0;
NullCheck(L_39);
int32_t L_40 = ((int32_t)11);
uint8_t L_41 = (L_39)->GetAt(static_cast<il2cpp_array_size_t>(L_40));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_42 = ___ekey2;
NullCheck(L_42);
int32_t L_43 = 2;
uint32_t L_44 = (L_42)->GetAt(static_cast<il2cpp_array_size_t>(L_43));
V_2 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_32<<(int32_t)((int32_t)24)))|(int32_t)((int32_t)((int32_t)L_35<<(int32_t)((int32_t)16)))))|(int32_t)((int32_t)((int32_t)L_38<<(int32_t)8))))|(int32_t)L_41))^(int32_t)L_44));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_45 = ___indata0;
NullCheck(L_45);
int32_t L_46 = ((int32_t)12);
uint8_t L_47 = (L_45)->GetAt(static_cast<il2cpp_array_size_t>(L_46));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_48 = ___indata0;
NullCheck(L_48);
int32_t L_49 = ((int32_t)13);
uint8_t L_50 = (L_48)->GetAt(static_cast<il2cpp_array_size_t>(L_49));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_51 = ___indata0;
NullCheck(L_51);
int32_t L_52 = ((int32_t)14);
uint8_t L_53 = (L_51)->GetAt(static_cast<il2cpp_array_size_t>(L_52));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_54 = ___indata0;
NullCheck(L_54);
int32_t L_55 = ((int32_t)15);
uint8_t L_56 = (L_54)->GetAt(static_cast<il2cpp_array_size_t>(L_55));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_57 = ___ekey2;
NullCheck(L_57);
int32_t L_58 = 3;
uint32_t L_59 = (L_57)->GetAt(static_cast<il2cpp_array_size_t>(L_58));
V_3 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_47<<(int32_t)((int32_t)24)))|(int32_t)((int32_t)((int32_t)L_50<<(int32_t)((int32_t)16)))))|(int32_t)((int32_t)((int32_t)L_53<<(int32_t)8))))|(int32_t)L_56))^(int32_t)L_59));
IL2CPP_RUNTIME_CLASS_INIT(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_60 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_61 = V_0;
NullCheck(L_60);
int32_t L_62 = ((int32_t)((uint32_t)L_61>>((int32_t)24)));
uint32_t L_63 = (L_60)->GetAt(static_cast<il2cpp_array_size_t>(L_62));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_64 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_65 = V_3;
NullCheck(L_64);
int32_t L_66 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_65>>((int32_t)16))))));
uint32_t L_67 = (L_64)->GetAt(static_cast<il2cpp_array_size_t>(L_66));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_68 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_69 = V_2;
NullCheck(L_68);
int32_t L_70 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_69>>8)))));
uint32_t L_71 = (L_68)->GetAt(static_cast<il2cpp_array_size_t>(L_70));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_72 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_73 = V_1;
NullCheck(L_72);
int32_t L_74 = (((int32_t)((uint8_t)L_73)));
uint32_t L_75 = (L_72)->GetAt(static_cast<il2cpp_array_size_t>(L_74));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_76 = ___ekey2;
NullCheck(L_76);
int32_t L_77 = 4;
uint32_t L_78 = (L_76)->GetAt(static_cast<il2cpp_array_size_t>(L_77));
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_63^(int32_t)L_67))^(int32_t)L_71))^(int32_t)L_75))^(int32_t)L_78));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_79 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_80 = V_1;
NullCheck(L_79);
int32_t L_81 = ((int32_t)((uint32_t)L_80>>((int32_t)24)));
uint32_t L_82 = (L_79)->GetAt(static_cast<il2cpp_array_size_t>(L_81));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_83 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_84 = V_0;
NullCheck(L_83);
int32_t L_85 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_84>>((int32_t)16))))));
uint32_t L_86 = (L_83)->GetAt(static_cast<il2cpp_array_size_t>(L_85));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_87 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_88 = V_3;
NullCheck(L_87);
int32_t L_89 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_88>>8)))));
uint32_t L_90 = (L_87)->GetAt(static_cast<il2cpp_array_size_t>(L_89));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_91 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_92 = V_2;
NullCheck(L_91);
int32_t L_93 = (((int32_t)((uint8_t)L_92)));
uint32_t L_94 = (L_91)->GetAt(static_cast<il2cpp_array_size_t>(L_93));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_95 = ___ekey2;
NullCheck(L_95);
int32_t L_96 = 5;
uint32_t L_97 = (L_95)->GetAt(static_cast<il2cpp_array_size_t>(L_96));
V_5 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_82^(int32_t)L_86))^(int32_t)L_90))^(int32_t)L_94))^(int32_t)L_97));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_98 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_99 = V_2;
NullCheck(L_98);
int32_t L_100 = ((int32_t)((uint32_t)L_99>>((int32_t)24)));
uint32_t L_101 = (L_98)->GetAt(static_cast<il2cpp_array_size_t>(L_100));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_102 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_103 = V_1;
NullCheck(L_102);
int32_t L_104 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_103>>((int32_t)16))))));
uint32_t L_105 = (L_102)->GetAt(static_cast<il2cpp_array_size_t>(L_104));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_106 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_107 = V_0;
NullCheck(L_106);
int32_t L_108 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_107>>8)))));
uint32_t L_109 = (L_106)->GetAt(static_cast<il2cpp_array_size_t>(L_108));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_110 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_111 = V_3;
NullCheck(L_110);
int32_t L_112 = (((int32_t)((uint8_t)L_111)));
uint32_t L_113 = (L_110)->GetAt(static_cast<il2cpp_array_size_t>(L_112));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_114 = ___ekey2;
NullCheck(L_114);
int32_t L_115 = 6;
uint32_t L_116 = (L_114)->GetAt(static_cast<il2cpp_array_size_t>(L_115));
V_6 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_101^(int32_t)L_105))^(int32_t)L_109))^(int32_t)L_113))^(int32_t)L_116));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_117 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_118 = V_3;
NullCheck(L_117);
int32_t L_119 = ((int32_t)((uint32_t)L_118>>((int32_t)24)));
uint32_t L_120 = (L_117)->GetAt(static_cast<il2cpp_array_size_t>(L_119));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_121 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_122 = V_2;
NullCheck(L_121);
int32_t L_123 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_122>>((int32_t)16))))));
uint32_t L_124 = (L_121)->GetAt(static_cast<il2cpp_array_size_t>(L_123));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_125 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_126 = V_1;
NullCheck(L_125);
int32_t L_127 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_126>>8)))));
uint32_t L_128 = (L_125)->GetAt(static_cast<il2cpp_array_size_t>(L_127));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_129 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_130 = V_0;
NullCheck(L_129);
int32_t L_131 = (((int32_t)((uint8_t)L_130)));
uint32_t L_132 = (L_129)->GetAt(static_cast<il2cpp_array_size_t>(L_131));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_133 = ___ekey2;
NullCheck(L_133);
int32_t L_134 = 7;
uint32_t L_135 = (L_133)->GetAt(static_cast<il2cpp_array_size_t>(L_134));
V_7 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_120^(int32_t)L_124))^(int32_t)L_128))^(int32_t)L_132))^(int32_t)L_135));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_136 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_137 = V_4;
NullCheck(L_136);
int32_t L_138 = ((int32_t)((uint32_t)L_137>>((int32_t)24)));
uint32_t L_139 = (L_136)->GetAt(static_cast<il2cpp_array_size_t>(L_138));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_140 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_141 = V_7;
NullCheck(L_140);
int32_t L_142 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_141>>((int32_t)16))))));
uint32_t L_143 = (L_140)->GetAt(static_cast<il2cpp_array_size_t>(L_142));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_144 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_145 = V_6;
NullCheck(L_144);
int32_t L_146 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_145>>8)))));
uint32_t L_147 = (L_144)->GetAt(static_cast<il2cpp_array_size_t>(L_146));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_148 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_149 = V_5;
NullCheck(L_148);
int32_t L_150 = (((int32_t)((uint8_t)L_149)));
uint32_t L_151 = (L_148)->GetAt(static_cast<il2cpp_array_size_t>(L_150));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_152 = ___ekey2;
NullCheck(L_152);
int32_t L_153 = 8;
uint32_t L_154 = (L_152)->GetAt(static_cast<il2cpp_array_size_t>(L_153));
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_139^(int32_t)L_143))^(int32_t)L_147))^(int32_t)L_151))^(int32_t)L_154));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_155 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_156 = V_5;
NullCheck(L_155);
int32_t L_157 = ((int32_t)((uint32_t)L_156>>((int32_t)24)));
uint32_t L_158 = (L_155)->GetAt(static_cast<il2cpp_array_size_t>(L_157));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_159 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_160 = V_4;
NullCheck(L_159);
int32_t L_161 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_160>>((int32_t)16))))));
uint32_t L_162 = (L_159)->GetAt(static_cast<il2cpp_array_size_t>(L_161));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_163 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_164 = V_7;
NullCheck(L_163);
int32_t L_165 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_164>>8)))));
uint32_t L_166 = (L_163)->GetAt(static_cast<il2cpp_array_size_t>(L_165));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_167 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_168 = V_6;
NullCheck(L_167);
int32_t L_169 = (((int32_t)((uint8_t)L_168)));
uint32_t L_170 = (L_167)->GetAt(static_cast<il2cpp_array_size_t>(L_169));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_171 = ___ekey2;
NullCheck(L_171);
int32_t L_172 = ((int32_t)9);
uint32_t L_173 = (L_171)->GetAt(static_cast<il2cpp_array_size_t>(L_172));
V_1 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_158^(int32_t)L_162))^(int32_t)L_166))^(int32_t)L_170))^(int32_t)L_173));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_174 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_175 = V_6;
NullCheck(L_174);
int32_t L_176 = ((int32_t)((uint32_t)L_175>>((int32_t)24)));
uint32_t L_177 = (L_174)->GetAt(static_cast<il2cpp_array_size_t>(L_176));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_178 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_179 = V_5;
NullCheck(L_178);
int32_t L_180 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_179>>((int32_t)16))))));
uint32_t L_181 = (L_178)->GetAt(static_cast<il2cpp_array_size_t>(L_180));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_182 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_183 = V_4;
NullCheck(L_182);
int32_t L_184 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_183>>8)))));
uint32_t L_185 = (L_182)->GetAt(static_cast<il2cpp_array_size_t>(L_184));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_186 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_187 = V_7;
NullCheck(L_186);
int32_t L_188 = (((int32_t)((uint8_t)L_187)));
uint32_t L_189 = (L_186)->GetAt(static_cast<il2cpp_array_size_t>(L_188));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_190 = ___ekey2;
NullCheck(L_190);
int32_t L_191 = ((int32_t)10);
uint32_t L_192 = (L_190)->GetAt(static_cast<il2cpp_array_size_t>(L_191));
V_2 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_177^(int32_t)L_181))^(int32_t)L_185))^(int32_t)L_189))^(int32_t)L_192));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_193 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_194 = V_7;
NullCheck(L_193);
int32_t L_195 = ((int32_t)((uint32_t)L_194>>((int32_t)24)));
uint32_t L_196 = (L_193)->GetAt(static_cast<il2cpp_array_size_t>(L_195));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_197 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_198 = V_6;
NullCheck(L_197);
int32_t L_199 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_198>>((int32_t)16))))));
uint32_t L_200 = (L_197)->GetAt(static_cast<il2cpp_array_size_t>(L_199));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_201 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_202 = V_5;
NullCheck(L_201);
int32_t L_203 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_202>>8)))));
uint32_t L_204 = (L_201)->GetAt(static_cast<il2cpp_array_size_t>(L_203));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_205 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_206 = V_4;
NullCheck(L_205);
int32_t L_207 = (((int32_t)((uint8_t)L_206)));
uint32_t L_208 = (L_205)->GetAt(static_cast<il2cpp_array_size_t>(L_207));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_209 = ___ekey2;
NullCheck(L_209);
int32_t L_210 = ((int32_t)11);
uint32_t L_211 = (L_209)->GetAt(static_cast<il2cpp_array_size_t>(L_210));
V_3 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_196^(int32_t)L_200))^(int32_t)L_204))^(int32_t)L_208))^(int32_t)L_211));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_212 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_213 = V_0;
NullCheck(L_212);
int32_t L_214 = ((int32_t)((uint32_t)L_213>>((int32_t)24)));
uint32_t L_215 = (L_212)->GetAt(static_cast<il2cpp_array_size_t>(L_214));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_216 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_217 = V_3;
NullCheck(L_216);
int32_t L_218 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_217>>((int32_t)16))))));
uint32_t L_219 = (L_216)->GetAt(static_cast<il2cpp_array_size_t>(L_218));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_220 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_221 = V_2;
NullCheck(L_220);
int32_t L_222 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_221>>8)))));
uint32_t L_223 = (L_220)->GetAt(static_cast<il2cpp_array_size_t>(L_222));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_224 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_225 = V_1;
NullCheck(L_224);
int32_t L_226 = (((int32_t)((uint8_t)L_225)));
uint32_t L_227 = (L_224)->GetAt(static_cast<il2cpp_array_size_t>(L_226));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_228 = ___ekey2;
NullCheck(L_228);
int32_t L_229 = ((int32_t)12);
uint32_t L_230 = (L_228)->GetAt(static_cast<il2cpp_array_size_t>(L_229));
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_215^(int32_t)L_219))^(int32_t)L_223))^(int32_t)L_227))^(int32_t)L_230));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_231 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_232 = V_1;
NullCheck(L_231);
int32_t L_233 = ((int32_t)((uint32_t)L_232>>((int32_t)24)));
uint32_t L_234 = (L_231)->GetAt(static_cast<il2cpp_array_size_t>(L_233));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_235 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_236 = V_0;
NullCheck(L_235);
int32_t L_237 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_236>>((int32_t)16))))));
uint32_t L_238 = (L_235)->GetAt(static_cast<il2cpp_array_size_t>(L_237));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_239 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_240 = V_3;
NullCheck(L_239);
int32_t L_241 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_240>>8)))));
uint32_t L_242 = (L_239)->GetAt(static_cast<il2cpp_array_size_t>(L_241));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_243 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_244 = V_2;
NullCheck(L_243);
int32_t L_245 = (((int32_t)((uint8_t)L_244)));
uint32_t L_246 = (L_243)->GetAt(static_cast<il2cpp_array_size_t>(L_245));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_247 = ___ekey2;
NullCheck(L_247);
int32_t L_248 = ((int32_t)13);
uint32_t L_249 = (L_247)->GetAt(static_cast<il2cpp_array_size_t>(L_248));
V_5 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_234^(int32_t)L_238))^(int32_t)L_242))^(int32_t)L_246))^(int32_t)L_249));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_250 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_251 = V_2;
NullCheck(L_250);
int32_t L_252 = ((int32_t)((uint32_t)L_251>>((int32_t)24)));
uint32_t L_253 = (L_250)->GetAt(static_cast<il2cpp_array_size_t>(L_252));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_254 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_255 = V_1;
NullCheck(L_254);
int32_t L_256 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_255>>((int32_t)16))))));
uint32_t L_257 = (L_254)->GetAt(static_cast<il2cpp_array_size_t>(L_256));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_258 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_259 = V_0;
NullCheck(L_258);
int32_t L_260 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_259>>8)))));
uint32_t L_261 = (L_258)->GetAt(static_cast<il2cpp_array_size_t>(L_260));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_262 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_263 = V_3;
NullCheck(L_262);
int32_t L_264 = (((int32_t)((uint8_t)L_263)));
uint32_t L_265 = (L_262)->GetAt(static_cast<il2cpp_array_size_t>(L_264));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_266 = ___ekey2;
NullCheck(L_266);
int32_t L_267 = ((int32_t)14);
uint32_t L_268 = (L_266)->GetAt(static_cast<il2cpp_array_size_t>(L_267));
V_6 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_253^(int32_t)L_257))^(int32_t)L_261))^(int32_t)L_265))^(int32_t)L_268));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_269 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_270 = V_3;
NullCheck(L_269);
int32_t L_271 = ((int32_t)((uint32_t)L_270>>((int32_t)24)));
uint32_t L_272 = (L_269)->GetAt(static_cast<il2cpp_array_size_t>(L_271));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_273 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_274 = V_2;
NullCheck(L_273);
int32_t L_275 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_274>>((int32_t)16))))));
uint32_t L_276 = (L_273)->GetAt(static_cast<il2cpp_array_size_t>(L_275));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_277 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_278 = V_1;
NullCheck(L_277);
int32_t L_279 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_278>>8)))));
uint32_t L_280 = (L_277)->GetAt(static_cast<il2cpp_array_size_t>(L_279));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_281 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_282 = V_0;
NullCheck(L_281);
int32_t L_283 = (((int32_t)((uint8_t)L_282)));
uint32_t L_284 = (L_281)->GetAt(static_cast<il2cpp_array_size_t>(L_283));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_285 = ___ekey2;
NullCheck(L_285);
int32_t L_286 = ((int32_t)15);
uint32_t L_287 = (L_285)->GetAt(static_cast<il2cpp_array_size_t>(L_286));
V_7 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_272^(int32_t)L_276))^(int32_t)L_280))^(int32_t)L_284))^(int32_t)L_287));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_288 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_289 = V_4;
NullCheck(L_288);
int32_t L_290 = ((int32_t)((uint32_t)L_289>>((int32_t)24)));
uint32_t L_291 = (L_288)->GetAt(static_cast<il2cpp_array_size_t>(L_290));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_292 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_293 = V_7;
NullCheck(L_292);
int32_t L_294 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_293>>((int32_t)16))))));
uint32_t L_295 = (L_292)->GetAt(static_cast<il2cpp_array_size_t>(L_294));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_296 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_297 = V_6;
NullCheck(L_296);
int32_t L_298 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_297>>8)))));
uint32_t L_299 = (L_296)->GetAt(static_cast<il2cpp_array_size_t>(L_298));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_300 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_301 = V_5;
NullCheck(L_300);
int32_t L_302 = (((int32_t)((uint8_t)L_301)));
uint32_t L_303 = (L_300)->GetAt(static_cast<il2cpp_array_size_t>(L_302));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_304 = ___ekey2;
NullCheck(L_304);
int32_t L_305 = ((int32_t)16);
uint32_t L_306 = (L_304)->GetAt(static_cast<il2cpp_array_size_t>(L_305));
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_291^(int32_t)L_295))^(int32_t)L_299))^(int32_t)L_303))^(int32_t)L_306));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_307 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_308 = V_5;
NullCheck(L_307);
int32_t L_309 = ((int32_t)((uint32_t)L_308>>((int32_t)24)));
uint32_t L_310 = (L_307)->GetAt(static_cast<il2cpp_array_size_t>(L_309));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_311 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_312 = V_4;
NullCheck(L_311);
int32_t L_313 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_312>>((int32_t)16))))));
uint32_t L_314 = (L_311)->GetAt(static_cast<il2cpp_array_size_t>(L_313));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_315 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_316 = V_7;
NullCheck(L_315);
int32_t L_317 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_316>>8)))));
uint32_t L_318 = (L_315)->GetAt(static_cast<il2cpp_array_size_t>(L_317));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_319 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_320 = V_6;
NullCheck(L_319);
int32_t L_321 = (((int32_t)((uint8_t)L_320)));
uint32_t L_322 = (L_319)->GetAt(static_cast<il2cpp_array_size_t>(L_321));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_323 = ___ekey2;
NullCheck(L_323);
int32_t L_324 = ((int32_t)17);
uint32_t L_325 = (L_323)->GetAt(static_cast<il2cpp_array_size_t>(L_324));
V_1 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_310^(int32_t)L_314))^(int32_t)L_318))^(int32_t)L_322))^(int32_t)L_325));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_326 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_327 = V_6;
NullCheck(L_326);
int32_t L_328 = ((int32_t)((uint32_t)L_327>>((int32_t)24)));
uint32_t L_329 = (L_326)->GetAt(static_cast<il2cpp_array_size_t>(L_328));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_330 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_331 = V_5;
NullCheck(L_330);
int32_t L_332 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_331>>((int32_t)16))))));
uint32_t L_333 = (L_330)->GetAt(static_cast<il2cpp_array_size_t>(L_332));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_334 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_335 = V_4;
NullCheck(L_334);
int32_t L_336 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_335>>8)))));
uint32_t L_337 = (L_334)->GetAt(static_cast<il2cpp_array_size_t>(L_336));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_338 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_339 = V_7;
NullCheck(L_338);
int32_t L_340 = (((int32_t)((uint8_t)L_339)));
uint32_t L_341 = (L_338)->GetAt(static_cast<il2cpp_array_size_t>(L_340));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_342 = ___ekey2;
NullCheck(L_342);
int32_t L_343 = ((int32_t)18);
uint32_t L_344 = (L_342)->GetAt(static_cast<il2cpp_array_size_t>(L_343));
V_2 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_329^(int32_t)L_333))^(int32_t)L_337))^(int32_t)L_341))^(int32_t)L_344));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_345 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_346 = V_7;
NullCheck(L_345);
int32_t L_347 = ((int32_t)((uint32_t)L_346>>((int32_t)24)));
uint32_t L_348 = (L_345)->GetAt(static_cast<il2cpp_array_size_t>(L_347));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_349 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_350 = V_6;
NullCheck(L_349);
int32_t L_351 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_350>>((int32_t)16))))));
uint32_t L_352 = (L_349)->GetAt(static_cast<il2cpp_array_size_t>(L_351));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_353 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_354 = V_5;
NullCheck(L_353);
int32_t L_355 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_354>>8)))));
uint32_t L_356 = (L_353)->GetAt(static_cast<il2cpp_array_size_t>(L_355));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_357 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_358 = V_4;
NullCheck(L_357);
int32_t L_359 = (((int32_t)((uint8_t)L_358)));
uint32_t L_360 = (L_357)->GetAt(static_cast<il2cpp_array_size_t>(L_359));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_361 = ___ekey2;
NullCheck(L_361);
int32_t L_362 = ((int32_t)19);
uint32_t L_363 = (L_361)->GetAt(static_cast<il2cpp_array_size_t>(L_362));
V_3 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_348^(int32_t)L_352))^(int32_t)L_356))^(int32_t)L_360))^(int32_t)L_363));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_364 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_365 = V_0;
NullCheck(L_364);
int32_t L_366 = ((int32_t)((uint32_t)L_365>>((int32_t)24)));
uint32_t L_367 = (L_364)->GetAt(static_cast<il2cpp_array_size_t>(L_366));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_368 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_369 = V_3;
NullCheck(L_368);
int32_t L_370 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_369>>((int32_t)16))))));
uint32_t L_371 = (L_368)->GetAt(static_cast<il2cpp_array_size_t>(L_370));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_372 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_373 = V_2;
NullCheck(L_372);
int32_t L_374 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_373>>8)))));
uint32_t L_375 = (L_372)->GetAt(static_cast<il2cpp_array_size_t>(L_374));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_376 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_377 = V_1;
NullCheck(L_376);
int32_t L_378 = (((int32_t)((uint8_t)L_377)));
uint32_t L_379 = (L_376)->GetAt(static_cast<il2cpp_array_size_t>(L_378));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_380 = ___ekey2;
NullCheck(L_380);
int32_t L_381 = ((int32_t)20);
uint32_t L_382 = (L_380)->GetAt(static_cast<il2cpp_array_size_t>(L_381));
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_367^(int32_t)L_371))^(int32_t)L_375))^(int32_t)L_379))^(int32_t)L_382));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_383 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_384 = V_1;
NullCheck(L_383);
int32_t L_385 = ((int32_t)((uint32_t)L_384>>((int32_t)24)));
uint32_t L_386 = (L_383)->GetAt(static_cast<il2cpp_array_size_t>(L_385));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_387 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_388 = V_0;
NullCheck(L_387);
int32_t L_389 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_388>>((int32_t)16))))));
uint32_t L_390 = (L_387)->GetAt(static_cast<il2cpp_array_size_t>(L_389));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_391 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_392 = V_3;
NullCheck(L_391);
int32_t L_393 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_392>>8)))));
uint32_t L_394 = (L_391)->GetAt(static_cast<il2cpp_array_size_t>(L_393));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_395 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_396 = V_2;
NullCheck(L_395);
int32_t L_397 = (((int32_t)((uint8_t)L_396)));
uint32_t L_398 = (L_395)->GetAt(static_cast<il2cpp_array_size_t>(L_397));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_399 = ___ekey2;
NullCheck(L_399);
int32_t L_400 = ((int32_t)21);
uint32_t L_401 = (L_399)->GetAt(static_cast<il2cpp_array_size_t>(L_400));
V_5 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_386^(int32_t)L_390))^(int32_t)L_394))^(int32_t)L_398))^(int32_t)L_401));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_402 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_403 = V_2;
NullCheck(L_402);
int32_t L_404 = ((int32_t)((uint32_t)L_403>>((int32_t)24)));
uint32_t L_405 = (L_402)->GetAt(static_cast<il2cpp_array_size_t>(L_404));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_406 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_407 = V_1;
NullCheck(L_406);
int32_t L_408 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_407>>((int32_t)16))))));
uint32_t L_409 = (L_406)->GetAt(static_cast<il2cpp_array_size_t>(L_408));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_410 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_411 = V_0;
NullCheck(L_410);
int32_t L_412 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_411>>8)))));
uint32_t L_413 = (L_410)->GetAt(static_cast<il2cpp_array_size_t>(L_412));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_414 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_415 = V_3;
NullCheck(L_414);
int32_t L_416 = (((int32_t)((uint8_t)L_415)));
uint32_t L_417 = (L_414)->GetAt(static_cast<il2cpp_array_size_t>(L_416));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_418 = ___ekey2;
NullCheck(L_418);
int32_t L_419 = ((int32_t)22);
uint32_t L_420 = (L_418)->GetAt(static_cast<il2cpp_array_size_t>(L_419));
V_6 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_405^(int32_t)L_409))^(int32_t)L_413))^(int32_t)L_417))^(int32_t)L_420));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_421 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_422 = V_3;
NullCheck(L_421);
int32_t L_423 = ((int32_t)((uint32_t)L_422>>((int32_t)24)));
uint32_t L_424 = (L_421)->GetAt(static_cast<il2cpp_array_size_t>(L_423));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_425 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_426 = V_2;
NullCheck(L_425);
int32_t L_427 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_426>>((int32_t)16))))));
uint32_t L_428 = (L_425)->GetAt(static_cast<il2cpp_array_size_t>(L_427));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_429 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_430 = V_1;
NullCheck(L_429);
int32_t L_431 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_430>>8)))));
uint32_t L_432 = (L_429)->GetAt(static_cast<il2cpp_array_size_t>(L_431));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_433 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_434 = V_0;
NullCheck(L_433);
int32_t L_435 = (((int32_t)((uint8_t)L_434)));
uint32_t L_436 = (L_433)->GetAt(static_cast<il2cpp_array_size_t>(L_435));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_437 = ___ekey2;
NullCheck(L_437);
int32_t L_438 = ((int32_t)23);
uint32_t L_439 = (L_437)->GetAt(static_cast<il2cpp_array_size_t>(L_438));
V_7 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_424^(int32_t)L_428))^(int32_t)L_432))^(int32_t)L_436))^(int32_t)L_439));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_440 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_441 = V_4;
NullCheck(L_440);
int32_t L_442 = ((int32_t)((uint32_t)L_441>>((int32_t)24)));
uint32_t L_443 = (L_440)->GetAt(static_cast<il2cpp_array_size_t>(L_442));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_444 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_445 = V_7;
NullCheck(L_444);
int32_t L_446 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_445>>((int32_t)16))))));
uint32_t L_447 = (L_444)->GetAt(static_cast<il2cpp_array_size_t>(L_446));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_448 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_449 = V_6;
NullCheck(L_448);
int32_t L_450 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_449>>8)))));
uint32_t L_451 = (L_448)->GetAt(static_cast<il2cpp_array_size_t>(L_450));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_452 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_453 = V_5;
NullCheck(L_452);
int32_t L_454 = (((int32_t)((uint8_t)L_453)));
uint32_t L_455 = (L_452)->GetAt(static_cast<il2cpp_array_size_t>(L_454));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_456 = ___ekey2;
NullCheck(L_456);
int32_t L_457 = ((int32_t)24);
uint32_t L_458 = (L_456)->GetAt(static_cast<il2cpp_array_size_t>(L_457));
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_443^(int32_t)L_447))^(int32_t)L_451))^(int32_t)L_455))^(int32_t)L_458));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_459 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_460 = V_5;
NullCheck(L_459);
int32_t L_461 = ((int32_t)((uint32_t)L_460>>((int32_t)24)));
uint32_t L_462 = (L_459)->GetAt(static_cast<il2cpp_array_size_t>(L_461));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_463 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_464 = V_4;
NullCheck(L_463);
int32_t L_465 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_464>>((int32_t)16))))));
uint32_t L_466 = (L_463)->GetAt(static_cast<il2cpp_array_size_t>(L_465));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_467 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_468 = V_7;
NullCheck(L_467);
int32_t L_469 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_468>>8)))));
uint32_t L_470 = (L_467)->GetAt(static_cast<il2cpp_array_size_t>(L_469));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_471 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_472 = V_6;
NullCheck(L_471);
int32_t L_473 = (((int32_t)((uint8_t)L_472)));
uint32_t L_474 = (L_471)->GetAt(static_cast<il2cpp_array_size_t>(L_473));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_475 = ___ekey2;
NullCheck(L_475);
int32_t L_476 = ((int32_t)25);
uint32_t L_477 = (L_475)->GetAt(static_cast<il2cpp_array_size_t>(L_476));
V_1 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_462^(int32_t)L_466))^(int32_t)L_470))^(int32_t)L_474))^(int32_t)L_477));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_478 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_479 = V_6;
NullCheck(L_478);
int32_t L_480 = ((int32_t)((uint32_t)L_479>>((int32_t)24)));
uint32_t L_481 = (L_478)->GetAt(static_cast<il2cpp_array_size_t>(L_480));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_482 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_483 = V_5;
NullCheck(L_482);
int32_t L_484 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_483>>((int32_t)16))))));
uint32_t L_485 = (L_482)->GetAt(static_cast<il2cpp_array_size_t>(L_484));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_486 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_487 = V_4;
NullCheck(L_486);
int32_t L_488 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_487>>8)))));
uint32_t L_489 = (L_486)->GetAt(static_cast<il2cpp_array_size_t>(L_488));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_490 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_491 = V_7;
NullCheck(L_490);
int32_t L_492 = (((int32_t)((uint8_t)L_491)));
uint32_t L_493 = (L_490)->GetAt(static_cast<il2cpp_array_size_t>(L_492));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_494 = ___ekey2;
NullCheck(L_494);
int32_t L_495 = ((int32_t)26);
uint32_t L_496 = (L_494)->GetAt(static_cast<il2cpp_array_size_t>(L_495));
V_2 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_481^(int32_t)L_485))^(int32_t)L_489))^(int32_t)L_493))^(int32_t)L_496));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_497 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_498 = V_7;
NullCheck(L_497);
int32_t L_499 = ((int32_t)((uint32_t)L_498>>((int32_t)24)));
uint32_t L_500 = (L_497)->GetAt(static_cast<il2cpp_array_size_t>(L_499));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_501 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_502 = V_6;
NullCheck(L_501);
int32_t L_503 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_502>>((int32_t)16))))));
uint32_t L_504 = (L_501)->GetAt(static_cast<il2cpp_array_size_t>(L_503));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_505 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_506 = V_5;
NullCheck(L_505);
int32_t L_507 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_506>>8)))));
uint32_t L_508 = (L_505)->GetAt(static_cast<il2cpp_array_size_t>(L_507));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_509 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_510 = V_4;
NullCheck(L_509);
int32_t L_511 = (((int32_t)((uint8_t)L_510)));
uint32_t L_512 = (L_509)->GetAt(static_cast<il2cpp_array_size_t>(L_511));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_513 = ___ekey2;
NullCheck(L_513);
int32_t L_514 = ((int32_t)27);
uint32_t L_515 = (L_513)->GetAt(static_cast<il2cpp_array_size_t>(L_514));
V_3 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_500^(int32_t)L_504))^(int32_t)L_508))^(int32_t)L_512))^(int32_t)L_515));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_516 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_517 = V_0;
NullCheck(L_516);
int32_t L_518 = ((int32_t)((uint32_t)L_517>>((int32_t)24)));
uint32_t L_519 = (L_516)->GetAt(static_cast<il2cpp_array_size_t>(L_518));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_520 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_521 = V_3;
NullCheck(L_520);
int32_t L_522 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_521>>((int32_t)16))))));
uint32_t L_523 = (L_520)->GetAt(static_cast<il2cpp_array_size_t>(L_522));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_524 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_525 = V_2;
NullCheck(L_524);
int32_t L_526 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_525>>8)))));
uint32_t L_527 = (L_524)->GetAt(static_cast<il2cpp_array_size_t>(L_526));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_528 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_529 = V_1;
NullCheck(L_528);
int32_t L_530 = (((int32_t)((uint8_t)L_529)));
uint32_t L_531 = (L_528)->GetAt(static_cast<il2cpp_array_size_t>(L_530));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_532 = ___ekey2;
NullCheck(L_532);
int32_t L_533 = ((int32_t)28);
uint32_t L_534 = (L_532)->GetAt(static_cast<il2cpp_array_size_t>(L_533));
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_519^(int32_t)L_523))^(int32_t)L_527))^(int32_t)L_531))^(int32_t)L_534));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_535 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_536 = V_1;
NullCheck(L_535);
int32_t L_537 = ((int32_t)((uint32_t)L_536>>((int32_t)24)));
uint32_t L_538 = (L_535)->GetAt(static_cast<il2cpp_array_size_t>(L_537));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_539 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_540 = V_0;
NullCheck(L_539);
int32_t L_541 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_540>>((int32_t)16))))));
uint32_t L_542 = (L_539)->GetAt(static_cast<il2cpp_array_size_t>(L_541));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_543 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_544 = V_3;
NullCheck(L_543);
int32_t L_545 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_544>>8)))));
uint32_t L_546 = (L_543)->GetAt(static_cast<il2cpp_array_size_t>(L_545));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_547 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_548 = V_2;
NullCheck(L_547);
int32_t L_549 = (((int32_t)((uint8_t)L_548)));
uint32_t L_550 = (L_547)->GetAt(static_cast<il2cpp_array_size_t>(L_549));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_551 = ___ekey2;
NullCheck(L_551);
int32_t L_552 = ((int32_t)29);
uint32_t L_553 = (L_551)->GetAt(static_cast<il2cpp_array_size_t>(L_552));
V_5 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_538^(int32_t)L_542))^(int32_t)L_546))^(int32_t)L_550))^(int32_t)L_553));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_554 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_555 = V_2;
NullCheck(L_554);
int32_t L_556 = ((int32_t)((uint32_t)L_555>>((int32_t)24)));
uint32_t L_557 = (L_554)->GetAt(static_cast<il2cpp_array_size_t>(L_556));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_558 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_559 = V_1;
NullCheck(L_558);
int32_t L_560 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_559>>((int32_t)16))))));
uint32_t L_561 = (L_558)->GetAt(static_cast<il2cpp_array_size_t>(L_560));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_562 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_563 = V_0;
NullCheck(L_562);
int32_t L_564 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_563>>8)))));
uint32_t L_565 = (L_562)->GetAt(static_cast<il2cpp_array_size_t>(L_564));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_566 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_567 = V_3;
NullCheck(L_566);
int32_t L_568 = (((int32_t)((uint8_t)L_567)));
uint32_t L_569 = (L_566)->GetAt(static_cast<il2cpp_array_size_t>(L_568));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_570 = ___ekey2;
NullCheck(L_570);
int32_t L_571 = ((int32_t)30);
uint32_t L_572 = (L_570)->GetAt(static_cast<il2cpp_array_size_t>(L_571));
V_6 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_557^(int32_t)L_561))^(int32_t)L_565))^(int32_t)L_569))^(int32_t)L_572));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_573 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_574 = V_3;
NullCheck(L_573);
int32_t L_575 = ((int32_t)((uint32_t)L_574>>((int32_t)24)));
uint32_t L_576 = (L_573)->GetAt(static_cast<il2cpp_array_size_t>(L_575));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_577 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_578 = V_2;
NullCheck(L_577);
int32_t L_579 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_578>>((int32_t)16))))));
uint32_t L_580 = (L_577)->GetAt(static_cast<il2cpp_array_size_t>(L_579));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_581 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_582 = V_1;
NullCheck(L_581);
int32_t L_583 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_582>>8)))));
uint32_t L_584 = (L_581)->GetAt(static_cast<il2cpp_array_size_t>(L_583));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_585 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_586 = V_0;
NullCheck(L_585);
int32_t L_587 = (((int32_t)((uint8_t)L_586)));
uint32_t L_588 = (L_585)->GetAt(static_cast<il2cpp_array_size_t>(L_587));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_589 = ___ekey2;
NullCheck(L_589);
int32_t L_590 = ((int32_t)31);
uint32_t L_591 = (L_589)->GetAt(static_cast<il2cpp_array_size_t>(L_590));
V_7 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_576^(int32_t)L_580))^(int32_t)L_584))^(int32_t)L_588))^(int32_t)L_591));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_592 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_593 = V_4;
NullCheck(L_592);
int32_t L_594 = ((int32_t)((uint32_t)L_593>>((int32_t)24)));
uint32_t L_595 = (L_592)->GetAt(static_cast<il2cpp_array_size_t>(L_594));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_596 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_597 = V_7;
NullCheck(L_596);
int32_t L_598 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_597>>((int32_t)16))))));
uint32_t L_599 = (L_596)->GetAt(static_cast<il2cpp_array_size_t>(L_598));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_600 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_601 = V_6;
NullCheck(L_600);
int32_t L_602 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_601>>8)))));
uint32_t L_603 = (L_600)->GetAt(static_cast<il2cpp_array_size_t>(L_602));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_604 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_605 = V_5;
NullCheck(L_604);
int32_t L_606 = (((int32_t)((uint8_t)L_605)));
uint32_t L_607 = (L_604)->GetAt(static_cast<il2cpp_array_size_t>(L_606));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_608 = ___ekey2;
NullCheck(L_608);
int32_t L_609 = ((int32_t)32);
uint32_t L_610 = (L_608)->GetAt(static_cast<il2cpp_array_size_t>(L_609));
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_595^(int32_t)L_599))^(int32_t)L_603))^(int32_t)L_607))^(int32_t)L_610));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_611 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_612 = V_5;
NullCheck(L_611);
int32_t L_613 = ((int32_t)((uint32_t)L_612>>((int32_t)24)));
uint32_t L_614 = (L_611)->GetAt(static_cast<il2cpp_array_size_t>(L_613));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_615 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_616 = V_4;
NullCheck(L_615);
int32_t L_617 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_616>>((int32_t)16))))));
uint32_t L_618 = (L_615)->GetAt(static_cast<il2cpp_array_size_t>(L_617));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_619 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_620 = V_7;
NullCheck(L_619);
int32_t L_621 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_620>>8)))));
uint32_t L_622 = (L_619)->GetAt(static_cast<il2cpp_array_size_t>(L_621));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_623 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_624 = V_6;
NullCheck(L_623);
int32_t L_625 = (((int32_t)((uint8_t)L_624)));
uint32_t L_626 = (L_623)->GetAt(static_cast<il2cpp_array_size_t>(L_625));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_627 = ___ekey2;
NullCheck(L_627);
int32_t L_628 = ((int32_t)33);
uint32_t L_629 = (L_627)->GetAt(static_cast<il2cpp_array_size_t>(L_628));
V_1 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_614^(int32_t)L_618))^(int32_t)L_622))^(int32_t)L_626))^(int32_t)L_629));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_630 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_631 = V_6;
NullCheck(L_630);
int32_t L_632 = ((int32_t)((uint32_t)L_631>>((int32_t)24)));
uint32_t L_633 = (L_630)->GetAt(static_cast<il2cpp_array_size_t>(L_632));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_634 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_635 = V_5;
NullCheck(L_634);
int32_t L_636 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_635>>((int32_t)16))))));
uint32_t L_637 = (L_634)->GetAt(static_cast<il2cpp_array_size_t>(L_636));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_638 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_639 = V_4;
NullCheck(L_638);
int32_t L_640 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_639>>8)))));
uint32_t L_641 = (L_638)->GetAt(static_cast<il2cpp_array_size_t>(L_640));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_642 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_643 = V_7;
NullCheck(L_642);
int32_t L_644 = (((int32_t)((uint8_t)L_643)));
uint32_t L_645 = (L_642)->GetAt(static_cast<il2cpp_array_size_t>(L_644));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_646 = ___ekey2;
NullCheck(L_646);
int32_t L_647 = ((int32_t)34);
uint32_t L_648 = (L_646)->GetAt(static_cast<il2cpp_array_size_t>(L_647));
V_2 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_633^(int32_t)L_637))^(int32_t)L_641))^(int32_t)L_645))^(int32_t)L_648));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_649 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_650 = V_7;
NullCheck(L_649);
int32_t L_651 = ((int32_t)((uint32_t)L_650>>((int32_t)24)));
uint32_t L_652 = (L_649)->GetAt(static_cast<il2cpp_array_size_t>(L_651));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_653 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_654 = V_6;
NullCheck(L_653);
int32_t L_655 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_654>>((int32_t)16))))));
uint32_t L_656 = (L_653)->GetAt(static_cast<il2cpp_array_size_t>(L_655));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_657 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_658 = V_5;
NullCheck(L_657);
int32_t L_659 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_658>>8)))));
uint32_t L_660 = (L_657)->GetAt(static_cast<il2cpp_array_size_t>(L_659));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_661 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_662 = V_4;
NullCheck(L_661);
int32_t L_663 = (((int32_t)((uint8_t)L_662)));
uint32_t L_664 = (L_661)->GetAt(static_cast<il2cpp_array_size_t>(L_663));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_665 = ___ekey2;
NullCheck(L_665);
int32_t L_666 = ((int32_t)35);
uint32_t L_667 = (L_665)->GetAt(static_cast<il2cpp_array_size_t>(L_666));
V_3 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_652^(int32_t)L_656))^(int32_t)L_660))^(int32_t)L_664))^(int32_t)L_667));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_668 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_669 = V_0;
NullCheck(L_668);
int32_t L_670 = ((int32_t)((uint32_t)L_669>>((int32_t)24)));
uint32_t L_671 = (L_668)->GetAt(static_cast<il2cpp_array_size_t>(L_670));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_672 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_673 = V_3;
NullCheck(L_672);
int32_t L_674 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_673>>((int32_t)16))))));
uint32_t L_675 = (L_672)->GetAt(static_cast<il2cpp_array_size_t>(L_674));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_676 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_677 = V_2;
NullCheck(L_676);
int32_t L_678 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_677>>8)))));
uint32_t L_679 = (L_676)->GetAt(static_cast<il2cpp_array_size_t>(L_678));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_680 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_681 = V_1;
NullCheck(L_680);
int32_t L_682 = (((int32_t)((uint8_t)L_681)));
uint32_t L_683 = (L_680)->GetAt(static_cast<il2cpp_array_size_t>(L_682));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_684 = ___ekey2;
NullCheck(L_684);
int32_t L_685 = ((int32_t)36);
uint32_t L_686 = (L_684)->GetAt(static_cast<il2cpp_array_size_t>(L_685));
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_671^(int32_t)L_675))^(int32_t)L_679))^(int32_t)L_683))^(int32_t)L_686));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_687 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_688 = V_1;
NullCheck(L_687);
int32_t L_689 = ((int32_t)((uint32_t)L_688>>((int32_t)24)));
uint32_t L_690 = (L_687)->GetAt(static_cast<il2cpp_array_size_t>(L_689));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_691 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_692 = V_0;
NullCheck(L_691);
int32_t L_693 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_692>>((int32_t)16))))));
uint32_t L_694 = (L_691)->GetAt(static_cast<il2cpp_array_size_t>(L_693));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_695 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_696 = V_3;
NullCheck(L_695);
int32_t L_697 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_696>>8)))));
uint32_t L_698 = (L_695)->GetAt(static_cast<il2cpp_array_size_t>(L_697));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_699 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_700 = V_2;
NullCheck(L_699);
int32_t L_701 = (((int32_t)((uint8_t)L_700)));
uint32_t L_702 = (L_699)->GetAt(static_cast<il2cpp_array_size_t>(L_701));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_703 = ___ekey2;
NullCheck(L_703);
int32_t L_704 = ((int32_t)37);
uint32_t L_705 = (L_703)->GetAt(static_cast<il2cpp_array_size_t>(L_704));
V_5 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_690^(int32_t)L_694))^(int32_t)L_698))^(int32_t)L_702))^(int32_t)L_705));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_706 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_707 = V_2;
NullCheck(L_706);
int32_t L_708 = ((int32_t)((uint32_t)L_707>>((int32_t)24)));
uint32_t L_709 = (L_706)->GetAt(static_cast<il2cpp_array_size_t>(L_708));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_710 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_711 = V_1;
NullCheck(L_710);
int32_t L_712 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_711>>((int32_t)16))))));
uint32_t L_713 = (L_710)->GetAt(static_cast<il2cpp_array_size_t>(L_712));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_714 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_715 = V_0;
NullCheck(L_714);
int32_t L_716 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_715>>8)))));
uint32_t L_717 = (L_714)->GetAt(static_cast<il2cpp_array_size_t>(L_716));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_718 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_719 = V_3;
NullCheck(L_718);
int32_t L_720 = (((int32_t)((uint8_t)L_719)));
uint32_t L_721 = (L_718)->GetAt(static_cast<il2cpp_array_size_t>(L_720));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_722 = ___ekey2;
NullCheck(L_722);
int32_t L_723 = ((int32_t)38);
uint32_t L_724 = (L_722)->GetAt(static_cast<il2cpp_array_size_t>(L_723));
V_6 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_709^(int32_t)L_713))^(int32_t)L_717))^(int32_t)L_721))^(int32_t)L_724));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_725 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_726 = V_3;
NullCheck(L_725);
int32_t L_727 = ((int32_t)((uint32_t)L_726>>((int32_t)24)));
uint32_t L_728 = (L_725)->GetAt(static_cast<il2cpp_array_size_t>(L_727));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_729 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_730 = V_2;
NullCheck(L_729);
int32_t L_731 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_730>>((int32_t)16))))));
uint32_t L_732 = (L_729)->GetAt(static_cast<il2cpp_array_size_t>(L_731));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_733 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_734 = V_1;
NullCheck(L_733);
int32_t L_735 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_734>>8)))));
uint32_t L_736 = (L_733)->GetAt(static_cast<il2cpp_array_size_t>(L_735));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_737 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_738 = V_0;
NullCheck(L_737);
int32_t L_739 = (((int32_t)((uint8_t)L_738)));
uint32_t L_740 = (L_737)->GetAt(static_cast<il2cpp_array_size_t>(L_739));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_741 = ___ekey2;
NullCheck(L_741);
int32_t L_742 = ((int32_t)39);
uint32_t L_743 = (L_741)->GetAt(static_cast<il2cpp_array_size_t>(L_742));
V_7 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_728^(int32_t)L_732))^(int32_t)L_736))^(int32_t)L_740))^(int32_t)L_743));
int32_t L_744 = __this->get_Nr_14();
if ((((int32_t)L_744) <= ((int32_t)((int32_t)10))))
{
goto IL_0ad4;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_745 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_746 = V_4;
NullCheck(L_745);
int32_t L_747 = ((int32_t)((uint32_t)L_746>>((int32_t)24)));
uint32_t L_748 = (L_745)->GetAt(static_cast<il2cpp_array_size_t>(L_747));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_749 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_750 = V_7;
NullCheck(L_749);
int32_t L_751 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_750>>((int32_t)16))))));
uint32_t L_752 = (L_749)->GetAt(static_cast<il2cpp_array_size_t>(L_751));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_753 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_754 = V_6;
NullCheck(L_753);
int32_t L_755 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_754>>8)))));
uint32_t L_756 = (L_753)->GetAt(static_cast<il2cpp_array_size_t>(L_755));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_757 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_758 = V_5;
NullCheck(L_757);
int32_t L_759 = (((int32_t)((uint8_t)L_758)));
uint32_t L_760 = (L_757)->GetAt(static_cast<il2cpp_array_size_t>(L_759));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_761 = ___ekey2;
NullCheck(L_761);
int32_t L_762 = ((int32_t)40);
uint32_t L_763 = (L_761)->GetAt(static_cast<il2cpp_array_size_t>(L_762));
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_748^(int32_t)L_752))^(int32_t)L_756))^(int32_t)L_760))^(int32_t)L_763));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_764 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_765 = V_5;
NullCheck(L_764);
int32_t L_766 = ((int32_t)((uint32_t)L_765>>((int32_t)24)));
uint32_t L_767 = (L_764)->GetAt(static_cast<il2cpp_array_size_t>(L_766));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_768 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_769 = V_4;
NullCheck(L_768);
int32_t L_770 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_769>>((int32_t)16))))));
uint32_t L_771 = (L_768)->GetAt(static_cast<il2cpp_array_size_t>(L_770));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_772 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_773 = V_7;
NullCheck(L_772);
int32_t L_774 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_773>>8)))));
uint32_t L_775 = (L_772)->GetAt(static_cast<il2cpp_array_size_t>(L_774));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_776 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_777 = V_6;
NullCheck(L_776);
int32_t L_778 = (((int32_t)((uint8_t)L_777)));
uint32_t L_779 = (L_776)->GetAt(static_cast<il2cpp_array_size_t>(L_778));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_780 = ___ekey2;
NullCheck(L_780);
int32_t L_781 = ((int32_t)41);
uint32_t L_782 = (L_780)->GetAt(static_cast<il2cpp_array_size_t>(L_781));
V_1 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_767^(int32_t)L_771))^(int32_t)L_775))^(int32_t)L_779))^(int32_t)L_782));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_783 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_784 = V_6;
NullCheck(L_783);
int32_t L_785 = ((int32_t)((uint32_t)L_784>>((int32_t)24)));
uint32_t L_786 = (L_783)->GetAt(static_cast<il2cpp_array_size_t>(L_785));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_787 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_788 = V_5;
NullCheck(L_787);
int32_t L_789 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_788>>((int32_t)16))))));
uint32_t L_790 = (L_787)->GetAt(static_cast<il2cpp_array_size_t>(L_789));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_791 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_792 = V_4;
NullCheck(L_791);
int32_t L_793 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_792>>8)))));
uint32_t L_794 = (L_791)->GetAt(static_cast<il2cpp_array_size_t>(L_793));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_795 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_796 = V_7;
NullCheck(L_795);
int32_t L_797 = (((int32_t)((uint8_t)L_796)));
uint32_t L_798 = (L_795)->GetAt(static_cast<il2cpp_array_size_t>(L_797));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_799 = ___ekey2;
NullCheck(L_799);
int32_t L_800 = ((int32_t)42);
uint32_t L_801 = (L_799)->GetAt(static_cast<il2cpp_array_size_t>(L_800));
V_2 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_786^(int32_t)L_790))^(int32_t)L_794))^(int32_t)L_798))^(int32_t)L_801));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_802 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_803 = V_7;
NullCheck(L_802);
int32_t L_804 = ((int32_t)((uint32_t)L_803>>((int32_t)24)));
uint32_t L_805 = (L_802)->GetAt(static_cast<il2cpp_array_size_t>(L_804));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_806 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_807 = V_6;
NullCheck(L_806);
int32_t L_808 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_807>>((int32_t)16))))));
uint32_t L_809 = (L_806)->GetAt(static_cast<il2cpp_array_size_t>(L_808));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_810 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_811 = V_5;
NullCheck(L_810);
int32_t L_812 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_811>>8)))));
uint32_t L_813 = (L_810)->GetAt(static_cast<il2cpp_array_size_t>(L_812));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_814 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_815 = V_4;
NullCheck(L_814);
int32_t L_816 = (((int32_t)((uint8_t)L_815)));
uint32_t L_817 = (L_814)->GetAt(static_cast<il2cpp_array_size_t>(L_816));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_818 = ___ekey2;
NullCheck(L_818);
int32_t L_819 = ((int32_t)43);
uint32_t L_820 = (L_818)->GetAt(static_cast<il2cpp_array_size_t>(L_819));
V_3 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_805^(int32_t)L_809))^(int32_t)L_813))^(int32_t)L_817))^(int32_t)L_820));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_821 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_822 = V_0;
NullCheck(L_821);
int32_t L_823 = ((int32_t)((uint32_t)L_822>>((int32_t)24)));
uint32_t L_824 = (L_821)->GetAt(static_cast<il2cpp_array_size_t>(L_823));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_825 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_826 = V_3;
NullCheck(L_825);
int32_t L_827 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_826>>((int32_t)16))))));
uint32_t L_828 = (L_825)->GetAt(static_cast<il2cpp_array_size_t>(L_827));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_829 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_830 = V_2;
NullCheck(L_829);
int32_t L_831 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_830>>8)))));
uint32_t L_832 = (L_829)->GetAt(static_cast<il2cpp_array_size_t>(L_831));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_833 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_834 = V_1;
NullCheck(L_833);
int32_t L_835 = (((int32_t)((uint8_t)L_834)));
uint32_t L_836 = (L_833)->GetAt(static_cast<il2cpp_array_size_t>(L_835));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_837 = ___ekey2;
NullCheck(L_837);
int32_t L_838 = ((int32_t)44);
uint32_t L_839 = (L_837)->GetAt(static_cast<il2cpp_array_size_t>(L_838));
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_824^(int32_t)L_828))^(int32_t)L_832))^(int32_t)L_836))^(int32_t)L_839));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_840 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_841 = V_1;
NullCheck(L_840);
int32_t L_842 = ((int32_t)((uint32_t)L_841>>((int32_t)24)));
uint32_t L_843 = (L_840)->GetAt(static_cast<il2cpp_array_size_t>(L_842));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_844 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_845 = V_0;
NullCheck(L_844);
int32_t L_846 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_845>>((int32_t)16))))));
uint32_t L_847 = (L_844)->GetAt(static_cast<il2cpp_array_size_t>(L_846));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_848 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_849 = V_3;
NullCheck(L_848);
int32_t L_850 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_849>>8)))));
uint32_t L_851 = (L_848)->GetAt(static_cast<il2cpp_array_size_t>(L_850));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_852 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_853 = V_2;
NullCheck(L_852);
int32_t L_854 = (((int32_t)((uint8_t)L_853)));
uint32_t L_855 = (L_852)->GetAt(static_cast<il2cpp_array_size_t>(L_854));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_856 = ___ekey2;
NullCheck(L_856);
int32_t L_857 = ((int32_t)45);
uint32_t L_858 = (L_856)->GetAt(static_cast<il2cpp_array_size_t>(L_857));
V_5 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_843^(int32_t)L_847))^(int32_t)L_851))^(int32_t)L_855))^(int32_t)L_858));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_859 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_860 = V_2;
NullCheck(L_859);
int32_t L_861 = ((int32_t)((uint32_t)L_860>>((int32_t)24)));
uint32_t L_862 = (L_859)->GetAt(static_cast<il2cpp_array_size_t>(L_861));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_863 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_864 = V_1;
NullCheck(L_863);
int32_t L_865 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_864>>((int32_t)16))))));
uint32_t L_866 = (L_863)->GetAt(static_cast<il2cpp_array_size_t>(L_865));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_867 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_868 = V_0;
NullCheck(L_867);
int32_t L_869 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_868>>8)))));
uint32_t L_870 = (L_867)->GetAt(static_cast<il2cpp_array_size_t>(L_869));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_871 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_872 = V_3;
NullCheck(L_871);
int32_t L_873 = (((int32_t)((uint8_t)L_872)));
uint32_t L_874 = (L_871)->GetAt(static_cast<il2cpp_array_size_t>(L_873));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_875 = ___ekey2;
NullCheck(L_875);
int32_t L_876 = ((int32_t)46);
uint32_t L_877 = (L_875)->GetAt(static_cast<il2cpp_array_size_t>(L_876));
V_6 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_862^(int32_t)L_866))^(int32_t)L_870))^(int32_t)L_874))^(int32_t)L_877));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_878 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_879 = V_3;
NullCheck(L_878);
int32_t L_880 = ((int32_t)((uint32_t)L_879>>((int32_t)24)));
uint32_t L_881 = (L_878)->GetAt(static_cast<il2cpp_array_size_t>(L_880));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_882 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_883 = V_2;
NullCheck(L_882);
int32_t L_884 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_883>>((int32_t)16))))));
uint32_t L_885 = (L_882)->GetAt(static_cast<il2cpp_array_size_t>(L_884));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_886 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_887 = V_1;
NullCheck(L_886);
int32_t L_888 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_887>>8)))));
uint32_t L_889 = (L_886)->GetAt(static_cast<il2cpp_array_size_t>(L_888));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_890 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_891 = V_0;
NullCheck(L_890);
int32_t L_892 = (((int32_t)((uint8_t)L_891)));
uint32_t L_893 = (L_890)->GetAt(static_cast<il2cpp_array_size_t>(L_892));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_894 = ___ekey2;
NullCheck(L_894);
int32_t L_895 = ((int32_t)47);
uint32_t L_896 = (L_894)->GetAt(static_cast<il2cpp_array_size_t>(L_895));
V_7 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_881^(int32_t)L_885))^(int32_t)L_889))^(int32_t)L_893))^(int32_t)L_896));
V_8 = ((int32_t)48);
int32_t L_897 = __this->get_Nr_14();
if ((((int32_t)L_897) <= ((int32_t)((int32_t)12))))
{
goto IL_0ad4;
}
}
{
IL2CPP_RUNTIME_CLASS_INIT(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_898 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_899 = V_4;
NullCheck(L_898);
int32_t L_900 = ((int32_t)((uint32_t)L_899>>((int32_t)24)));
uint32_t L_901 = (L_898)->GetAt(static_cast<il2cpp_array_size_t>(L_900));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_902 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_903 = V_7;
NullCheck(L_902);
int32_t L_904 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_903>>((int32_t)16))))));
uint32_t L_905 = (L_902)->GetAt(static_cast<il2cpp_array_size_t>(L_904));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_906 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_907 = V_6;
NullCheck(L_906);
int32_t L_908 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_907>>8)))));
uint32_t L_909 = (L_906)->GetAt(static_cast<il2cpp_array_size_t>(L_908));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_910 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_911 = V_5;
NullCheck(L_910);
int32_t L_912 = (((int32_t)((uint8_t)L_911)));
uint32_t L_913 = (L_910)->GetAt(static_cast<il2cpp_array_size_t>(L_912));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_914 = ___ekey2;
NullCheck(L_914);
int32_t L_915 = ((int32_t)48);
uint32_t L_916 = (L_914)->GetAt(static_cast<il2cpp_array_size_t>(L_915));
V_0 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_901^(int32_t)L_905))^(int32_t)L_909))^(int32_t)L_913))^(int32_t)L_916));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_917 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_918 = V_5;
NullCheck(L_917);
int32_t L_919 = ((int32_t)((uint32_t)L_918>>((int32_t)24)));
uint32_t L_920 = (L_917)->GetAt(static_cast<il2cpp_array_size_t>(L_919));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_921 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_922 = V_4;
NullCheck(L_921);
int32_t L_923 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_922>>((int32_t)16))))));
uint32_t L_924 = (L_921)->GetAt(static_cast<il2cpp_array_size_t>(L_923));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_925 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_926 = V_7;
NullCheck(L_925);
int32_t L_927 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_926>>8)))));
uint32_t L_928 = (L_925)->GetAt(static_cast<il2cpp_array_size_t>(L_927));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_929 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_930 = V_6;
NullCheck(L_929);
int32_t L_931 = (((int32_t)((uint8_t)L_930)));
uint32_t L_932 = (L_929)->GetAt(static_cast<il2cpp_array_size_t>(L_931));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_933 = ___ekey2;
NullCheck(L_933);
int32_t L_934 = ((int32_t)49);
uint32_t L_935 = (L_933)->GetAt(static_cast<il2cpp_array_size_t>(L_934));
V_1 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_920^(int32_t)L_924))^(int32_t)L_928))^(int32_t)L_932))^(int32_t)L_935));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_936 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_937 = V_6;
NullCheck(L_936);
int32_t L_938 = ((int32_t)((uint32_t)L_937>>((int32_t)24)));
uint32_t L_939 = (L_936)->GetAt(static_cast<il2cpp_array_size_t>(L_938));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_940 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_941 = V_5;
NullCheck(L_940);
int32_t L_942 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_941>>((int32_t)16))))));
uint32_t L_943 = (L_940)->GetAt(static_cast<il2cpp_array_size_t>(L_942));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_944 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_945 = V_4;
NullCheck(L_944);
int32_t L_946 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_945>>8)))));
uint32_t L_947 = (L_944)->GetAt(static_cast<il2cpp_array_size_t>(L_946));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_948 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_949 = V_7;
NullCheck(L_948);
int32_t L_950 = (((int32_t)((uint8_t)L_949)));
uint32_t L_951 = (L_948)->GetAt(static_cast<il2cpp_array_size_t>(L_950));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_952 = ___ekey2;
NullCheck(L_952);
int32_t L_953 = ((int32_t)50);
uint32_t L_954 = (L_952)->GetAt(static_cast<il2cpp_array_size_t>(L_953));
V_2 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_939^(int32_t)L_943))^(int32_t)L_947))^(int32_t)L_951))^(int32_t)L_954));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_955 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_956 = V_7;
NullCheck(L_955);
int32_t L_957 = ((int32_t)((uint32_t)L_956>>((int32_t)24)));
uint32_t L_958 = (L_955)->GetAt(static_cast<il2cpp_array_size_t>(L_957));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_959 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_960 = V_6;
NullCheck(L_959);
int32_t L_961 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_960>>((int32_t)16))))));
uint32_t L_962 = (L_959)->GetAt(static_cast<il2cpp_array_size_t>(L_961));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_963 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_964 = V_5;
NullCheck(L_963);
int32_t L_965 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_964>>8)))));
uint32_t L_966 = (L_963)->GetAt(static_cast<il2cpp_array_size_t>(L_965));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_967 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_968 = V_4;
NullCheck(L_967);
int32_t L_969 = (((int32_t)((uint8_t)L_968)));
uint32_t L_970 = (L_967)->GetAt(static_cast<il2cpp_array_size_t>(L_969));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_971 = ___ekey2;
NullCheck(L_971);
int32_t L_972 = ((int32_t)51);
uint32_t L_973 = (L_971)->GetAt(static_cast<il2cpp_array_size_t>(L_972));
V_3 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_958^(int32_t)L_962))^(int32_t)L_966))^(int32_t)L_970))^(int32_t)L_973));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_974 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_975 = V_0;
NullCheck(L_974);
int32_t L_976 = ((int32_t)((uint32_t)L_975>>((int32_t)24)));
uint32_t L_977 = (L_974)->GetAt(static_cast<il2cpp_array_size_t>(L_976));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_978 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_979 = V_3;
NullCheck(L_978);
int32_t L_980 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_979>>((int32_t)16))))));
uint32_t L_981 = (L_978)->GetAt(static_cast<il2cpp_array_size_t>(L_980));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_982 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_983 = V_2;
NullCheck(L_982);
int32_t L_984 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_983>>8)))));
uint32_t L_985 = (L_982)->GetAt(static_cast<il2cpp_array_size_t>(L_984));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_986 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_987 = V_1;
NullCheck(L_986);
int32_t L_988 = (((int32_t)((uint8_t)L_987)));
uint32_t L_989 = (L_986)->GetAt(static_cast<il2cpp_array_size_t>(L_988));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_990 = ___ekey2;
NullCheck(L_990);
int32_t L_991 = ((int32_t)52);
uint32_t L_992 = (L_990)->GetAt(static_cast<il2cpp_array_size_t>(L_991));
V_4 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_977^(int32_t)L_981))^(int32_t)L_985))^(int32_t)L_989))^(int32_t)L_992));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_993 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_994 = V_1;
NullCheck(L_993);
int32_t L_995 = ((int32_t)((uint32_t)L_994>>((int32_t)24)));
uint32_t L_996 = (L_993)->GetAt(static_cast<il2cpp_array_size_t>(L_995));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_997 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_998 = V_0;
NullCheck(L_997);
int32_t L_999 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_998>>((int32_t)16))))));
uint32_t L_1000 = (L_997)->GetAt(static_cast<il2cpp_array_size_t>(L_999));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1001 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_1002 = V_3;
NullCheck(L_1001);
int32_t L_1003 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1002>>8)))));
uint32_t L_1004 = (L_1001)->GetAt(static_cast<il2cpp_array_size_t>(L_1003));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1005 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_1006 = V_2;
NullCheck(L_1005);
int32_t L_1007 = (((int32_t)((uint8_t)L_1006)));
uint32_t L_1008 = (L_1005)->GetAt(static_cast<il2cpp_array_size_t>(L_1007));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1009 = ___ekey2;
NullCheck(L_1009);
int32_t L_1010 = ((int32_t)53);
uint32_t L_1011 = (L_1009)->GetAt(static_cast<il2cpp_array_size_t>(L_1010));
V_5 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_996^(int32_t)L_1000))^(int32_t)L_1004))^(int32_t)L_1008))^(int32_t)L_1011));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1012 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_1013 = V_2;
NullCheck(L_1012);
int32_t L_1014 = ((int32_t)((uint32_t)L_1013>>((int32_t)24)));
uint32_t L_1015 = (L_1012)->GetAt(static_cast<il2cpp_array_size_t>(L_1014));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1016 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_1017 = V_1;
NullCheck(L_1016);
int32_t L_1018 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1017>>((int32_t)16))))));
uint32_t L_1019 = (L_1016)->GetAt(static_cast<il2cpp_array_size_t>(L_1018));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1020 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_1021 = V_0;
NullCheck(L_1020);
int32_t L_1022 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1021>>8)))));
uint32_t L_1023 = (L_1020)->GetAt(static_cast<il2cpp_array_size_t>(L_1022));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1024 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_1025 = V_3;
NullCheck(L_1024);
int32_t L_1026 = (((int32_t)((uint8_t)L_1025)));
uint32_t L_1027 = (L_1024)->GetAt(static_cast<il2cpp_array_size_t>(L_1026));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1028 = ___ekey2;
NullCheck(L_1028);
int32_t L_1029 = ((int32_t)54);
uint32_t L_1030 = (L_1028)->GetAt(static_cast<il2cpp_array_size_t>(L_1029));
V_6 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_1015^(int32_t)L_1019))^(int32_t)L_1023))^(int32_t)L_1027))^(int32_t)L_1030));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1031 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT0_22();
uint32_t L_1032 = V_3;
NullCheck(L_1031);
int32_t L_1033 = ((int32_t)((uint32_t)L_1032>>((int32_t)24)));
uint32_t L_1034 = (L_1031)->GetAt(static_cast<il2cpp_array_size_t>(L_1033));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1035 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT1_23();
uint32_t L_1036 = V_2;
NullCheck(L_1035);
int32_t L_1037 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1036>>((int32_t)16))))));
uint32_t L_1038 = (L_1035)->GetAt(static_cast<il2cpp_array_size_t>(L_1037));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1039 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT2_24();
uint32_t L_1040 = V_1;
NullCheck(L_1039);
int32_t L_1041 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1040>>8)))));
uint32_t L_1042 = (L_1039)->GetAt(static_cast<il2cpp_array_size_t>(L_1041));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1043 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iT3_25();
uint32_t L_1044 = V_0;
NullCheck(L_1043);
int32_t L_1045 = (((int32_t)((uint8_t)L_1044)));
uint32_t L_1046 = (L_1043)->GetAt(static_cast<il2cpp_array_size_t>(L_1045));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1047 = ___ekey2;
NullCheck(L_1047);
int32_t L_1048 = ((int32_t)55);
uint32_t L_1049 = (L_1047)->GetAt(static_cast<il2cpp_array_size_t>(L_1048));
V_7 = ((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)((int32_t)L_1034^(int32_t)L_1038))^(int32_t)L_1042))^(int32_t)L_1046))^(int32_t)L_1049));
V_8 = ((int32_t)56);
}
IL_0ad4:
{
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1050 = ___outdata1;
IL2CPP_RUNTIME_CLASS_INIT(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var);
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1051 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1052 = V_4;
NullCheck(L_1051);
int32_t L_1053 = ((int32_t)((uint32_t)L_1052>>((int32_t)24)));
uint8_t L_1054 = (L_1051)->GetAt(static_cast<il2cpp_array_size_t>(L_1053));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1055 = ___ekey2;
int32_t L_1056 = V_8;
NullCheck(L_1055);
int32_t L_1057 = L_1056;
uint32_t L_1058 = (L_1055)->GetAt(static_cast<il2cpp_array_size_t>(L_1057));
NullCheck(L_1050);
(L_1050)->SetAt(static_cast<il2cpp_array_size_t>(0), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1054^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1058>>((int32_t)24))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1059 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1060 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1061 = V_7;
NullCheck(L_1060);
int32_t L_1062 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1061>>((int32_t)16))))));
uint8_t L_1063 = (L_1060)->GetAt(static_cast<il2cpp_array_size_t>(L_1062));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1064 = ___ekey2;
int32_t L_1065 = V_8;
NullCheck(L_1064);
int32_t L_1066 = L_1065;
uint32_t L_1067 = (L_1064)->GetAt(static_cast<il2cpp_array_size_t>(L_1066));
NullCheck(L_1059);
(L_1059)->SetAt(static_cast<il2cpp_array_size_t>(1), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1063^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1067>>((int32_t)16))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1068 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1069 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1070 = V_6;
NullCheck(L_1069);
int32_t L_1071 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1070>>8)))));
uint8_t L_1072 = (L_1069)->GetAt(static_cast<il2cpp_array_size_t>(L_1071));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1073 = ___ekey2;
int32_t L_1074 = V_8;
NullCheck(L_1073);
int32_t L_1075 = L_1074;
uint32_t L_1076 = (L_1073)->GetAt(static_cast<il2cpp_array_size_t>(L_1075));
NullCheck(L_1068);
(L_1068)->SetAt(static_cast<il2cpp_array_size_t>(2), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1072^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1076>>8)))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1077 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1078 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1079 = V_5;
NullCheck(L_1078);
int32_t L_1080 = (((int32_t)((uint8_t)L_1079)));
uint8_t L_1081 = (L_1078)->GetAt(static_cast<il2cpp_array_size_t>(L_1080));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1082 = ___ekey2;
int32_t L_1083 = V_8;
int32_t L_1084 = L_1083;
V_8 = ((int32_t)il2cpp_codegen_add((int32_t)L_1084, (int32_t)1));
NullCheck(L_1082);
int32_t L_1085 = L_1084;
uint32_t L_1086 = (L_1082)->GetAt(static_cast<il2cpp_array_size_t>(L_1085));
NullCheck(L_1077);
(L_1077)->SetAt(static_cast<il2cpp_array_size_t>(3), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1081^(int32_t)(((int32_t)((uint8_t)L_1086)))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1087 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1088 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1089 = V_5;
NullCheck(L_1088);
int32_t L_1090 = ((int32_t)((uint32_t)L_1089>>((int32_t)24)));
uint8_t L_1091 = (L_1088)->GetAt(static_cast<il2cpp_array_size_t>(L_1090));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1092 = ___ekey2;
int32_t L_1093 = V_8;
NullCheck(L_1092);
int32_t L_1094 = L_1093;
uint32_t L_1095 = (L_1092)->GetAt(static_cast<il2cpp_array_size_t>(L_1094));
NullCheck(L_1087);
(L_1087)->SetAt(static_cast<il2cpp_array_size_t>(4), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1091^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1095>>((int32_t)24))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1096 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1097 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1098 = V_4;
NullCheck(L_1097);
int32_t L_1099 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1098>>((int32_t)16))))));
uint8_t L_1100 = (L_1097)->GetAt(static_cast<il2cpp_array_size_t>(L_1099));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1101 = ___ekey2;
int32_t L_1102 = V_8;
NullCheck(L_1101);
int32_t L_1103 = L_1102;
uint32_t L_1104 = (L_1101)->GetAt(static_cast<il2cpp_array_size_t>(L_1103));
NullCheck(L_1096);
(L_1096)->SetAt(static_cast<il2cpp_array_size_t>(5), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1100^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1104>>((int32_t)16))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1105 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1106 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1107 = V_7;
NullCheck(L_1106);
int32_t L_1108 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1107>>8)))));
uint8_t L_1109 = (L_1106)->GetAt(static_cast<il2cpp_array_size_t>(L_1108));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1110 = ___ekey2;
int32_t L_1111 = V_8;
NullCheck(L_1110);
int32_t L_1112 = L_1111;
uint32_t L_1113 = (L_1110)->GetAt(static_cast<il2cpp_array_size_t>(L_1112));
NullCheck(L_1105);
(L_1105)->SetAt(static_cast<il2cpp_array_size_t>(6), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1109^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1113>>8)))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1114 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1115 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1116 = V_6;
NullCheck(L_1115);
int32_t L_1117 = (((int32_t)((uint8_t)L_1116)));
uint8_t L_1118 = (L_1115)->GetAt(static_cast<il2cpp_array_size_t>(L_1117));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1119 = ___ekey2;
int32_t L_1120 = V_8;
int32_t L_1121 = L_1120;
V_8 = ((int32_t)il2cpp_codegen_add((int32_t)L_1121, (int32_t)1));
NullCheck(L_1119);
int32_t L_1122 = L_1121;
uint32_t L_1123 = (L_1119)->GetAt(static_cast<il2cpp_array_size_t>(L_1122));
NullCheck(L_1114);
(L_1114)->SetAt(static_cast<il2cpp_array_size_t>(7), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1118^(int32_t)(((int32_t)((uint8_t)L_1123)))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1124 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1125 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1126 = V_6;
NullCheck(L_1125);
int32_t L_1127 = ((int32_t)((uint32_t)L_1126>>((int32_t)24)));
uint8_t L_1128 = (L_1125)->GetAt(static_cast<il2cpp_array_size_t>(L_1127));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1129 = ___ekey2;
int32_t L_1130 = V_8;
NullCheck(L_1129);
int32_t L_1131 = L_1130;
uint32_t L_1132 = (L_1129)->GetAt(static_cast<il2cpp_array_size_t>(L_1131));
NullCheck(L_1124);
(L_1124)->SetAt(static_cast<il2cpp_array_size_t>(8), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1128^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1132>>((int32_t)24))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1133 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1134 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1135 = V_5;
NullCheck(L_1134);
int32_t L_1136 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1135>>((int32_t)16))))));
uint8_t L_1137 = (L_1134)->GetAt(static_cast<il2cpp_array_size_t>(L_1136));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1138 = ___ekey2;
int32_t L_1139 = V_8;
NullCheck(L_1138);
int32_t L_1140 = L_1139;
uint32_t L_1141 = (L_1138)->GetAt(static_cast<il2cpp_array_size_t>(L_1140));
NullCheck(L_1133);
(L_1133)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)9)), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1137^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1141>>((int32_t)16))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1142 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1143 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1144 = V_4;
NullCheck(L_1143);
int32_t L_1145 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1144>>8)))));
uint8_t L_1146 = (L_1143)->GetAt(static_cast<il2cpp_array_size_t>(L_1145));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1147 = ___ekey2;
int32_t L_1148 = V_8;
NullCheck(L_1147);
int32_t L_1149 = L_1148;
uint32_t L_1150 = (L_1147)->GetAt(static_cast<il2cpp_array_size_t>(L_1149));
NullCheck(L_1142);
(L_1142)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)10)), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1146^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1150>>8)))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1151 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1152 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1153 = V_7;
NullCheck(L_1152);
int32_t L_1154 = (((int32_t)((uint8_t)L_1153)));
uint8_t L_1155 = (L_1152)->GetAt(static_cast<il2cpp_array_size_t>(L_1154));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1156 = ___ekey2;
int32_t L_1157 = V_8;
int32_t L_1158 = L_1157;
V_8 = ((int32_t)il2cpp_codegen_add((int32_t)L_1158, (int32_t)1));
NullCheck(L_1156);
int32_t L_1159 = L_1158;
uint32_t L_1160 = (L_1156)->GetAt(static_cast<il2cpp_array_size_t>(L_1159));
NullCheck(L_1151);
(L_1151)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)11)), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1155^(int32_t)(((int32_t)((uint8_t)L_1160)))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1161 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1162 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1163 = V_7;
NullCheck(L_1162);
int32_t L_1164 = ((int32_t)((uint32_t)L_1163>>((int32_t)24)));
uint8_t L_1165 = (L_1162)->GetAt(static_cast<il2cpp_array_size_t>(L_1164));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1166 = ___ekey2;
int32_t L_1167 = V_8;
NullCheck(L_1166);
int32_t L_1168 = L_1167;
uint32_t L_1169 = (L_1166)->GetAt(static_cast<il2cpp_array_size_t>(L_1168));
NullCheck(L_1161);
(L_1161)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)12)), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1165^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1169>>((int32_t)24))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1170 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1171 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1172 = V_6;
NullCheck(L_1171);
int32_t L_1173 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1172>>((int32_t)16))))));
uint8_t L_1174 = (L_1171)->GetAt(static_cast<il2cpp_array_size_t>(L_1173));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1175 = ___ekey2;
int32_t L_1176 = V_8;
NullCheck(L_1175);
int32_t L_1177 = L_1176;
uint32_t L_1178 = (L_1175)->GetAt(static_cast<il2cpp_array_size_t>(L_1177));
NullCheck(L_1170);
(L_1170)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)13)), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1174^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1178>>((int32_t)16))))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1179 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1180 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1181 = V_5;
NullCheck(L_1180);
int32_t L_1182 = (((int32_t)((uint8_t)((int32_t)((uint32_t)L_1181>>8)))));
uint8_t L_1183 = (L_1180)->GetAt(static_cast<il2cpp_array_size_t>(L_1182));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1184 = ___ekey2;
int32_t L_1185 = V_8;
NullCheck(L_1184);
int32_t L_1186 = L_1185;
uint32_t L_1187 = (L_1184)->GetAt(static_cast<il2cpp_array_size_t>(L_1186));
NullCheck(L_1179);
(L_1179)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)14)), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1183^(int32_t)(((int32_t)((uint8_t)((int32_t)((uint32_t)L_1187>>8)))))))))));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1188 = ___outdata1;
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_1189 = ((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->get_iSBox_17();
uint32_t L_1190 = V_4;
NullCheck(L_1189);
int32_t L_1191 = (((int32_t)((uint8_t)L_1190)));
uint8_t L_1192 = (L_1189)->GetAt(static_cast<il2cpp_array_size_t>(L_1191));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1193 = ___ekey2;
int32_t L_1194 = V_8;
int32_t L_1195 = L_1194;
V_8 = ((int32_t)il2cpp_codegen_add((int32_t)L_1195, (int32_t)1));
NullCheck(L_1193);
int32_t L_1196 = L_1195;
uint32_t L_1197 = (L_1193)->GetAt(static_cast<il2cpp_array_size_t>(L_1196));
NullCheck(L_1188);
(L_1188)->SetAt(static_cast<il2cpp_array_size_t>(((int32_t)15)), (uint8_t)(((int32_t)((uint8_t)((int32_t)((int32_t)L_1192^(int32_t)(((int32_t)((uint8_t)L_1197)))))))));
return;
}
}
// System.Void System.Security.Cryptography.AesTransform::.cctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void AesTransform__cctor_mDEA197C50BA055FF76B7ECFEB5C1FD7900CE4325 (const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (AesTransform__cctor_mDEA197C50BA055FF76B7ECFEB5C1FD7900CE4325_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_0 = (UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)SZArrayNew(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB_il2cpp_TypeInfo_var, (uint32_t)((int32_t)30));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_1 = L_0;
RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF L_2 = { reinterpret_cast<intptr_t> (U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____0AA802CD6847EB893FE786B5EA5168B2FDCD7B93_0_FieldInfo_var) };
RuntimeHelpers_InitializeArray_m29F50CDFEEE0AB868200291366253DD4737BC76A((RuntimeArray *)(RuntimeArray *)L_1, L_2, /*hidden argument*/NULL);
((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->set_Rcon_15(L_1);
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_3 = (ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821*)(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821*)SZArrayNew(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821_il2cpp_TypeInfo_var, (uint32_t)((int32_t)256));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_4 = L_3;
RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF L_5 = { reinterpret_cast<intptr_t> (U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____8F22C9ECE1331718CBD268A9BBFD2F5E451441E3_8_FieldInfo_var) };
RuntimeHelpers_InitializeArray_m29F50CDFEEE0AB868200291366253DD4737BC76A((RuntimeArray *)(RuntimeArray *)L_4, L_5, /*hidden argument*/NULL);
((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->set_SBox_16(L_4);
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_6 = (ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821*)(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821*)SZArrayNew(ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821_il2cpp_TypeInfo_var, (uint32_t)((int32_t)256));
ByteU5BU5D_tD06FDBE8142446525DF1C40351D523A228373821* L_7 = L_6;
RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF L_8 = { reinterpret_cast<intptr_t> (U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____0C4110BC17D746F018F47B49E0EB0D6590F69939_1_FieldInfo_var) };
RuntimeHelpers_InitializeArray_m29F50CDFEEE0AB868200291366253DD4737BC76A((RuntimeArray *)(RuntimeArray *)L_7, L_8, /*hidden argument*/NULL);
((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->set_iSBox_17(L_7);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_9 = (UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)SZArrayNew(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB_il2cpp_TypeInfo_var, (uint32_t)((int32_t)256));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_10 = L_9;
RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF L_11 = { reinterpret_cast<intptr_t> (U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____30A0358B25B1372DD598BB4B1AC56AD6B8F08A47_5_FieldInfo_var) };
RuntimeHelpers_InitializeArray_m29F50CDFEEE0AB868200291366253DD4737BC76A((RuntimeArray *)(RuntimeArray *)L_10, L_11, /*hidden argument*/NULL);
((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->set_T0_18(L_10);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_12 = (UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)SZArrayNew(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB_il2cpp_TypeInfo_var, (uint32_t)((int32_t)256));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_13 = L_12;
RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF L_14 = { reinterpret_cast<intptr_t> (U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____AE2F76ECEF8B08F0BC7EA95DCFE945E1727927C9_10_FieldInfo_var) };
RuntimeHelpers_InitializeArray_m29F50CDFEEE0AB868200291366253DD4737BC76A((RuntimeArray *)(RuntimeArray *)L_13, L_14, /*hidden argument*/NULL);
((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->set_T1_19(L_13);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_15 = (UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)SZArrayNew(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB_il2cpp_TypeInfo_var, (uint32_t)((int32_t)256));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_16 = L_15;
RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF L_17 = { reinterpret_cast<intptr_t> (U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____23DFDCA6F045D4257BF5AC8CB1CF2EFADAFE9B94_4_FieldInfo_var) };
RuntimeHelpers_InitializeArray_m29F50CDFEEE0AB868200291366253DD4737BC76A((RuntimeArray *)(RuntimeArray *)L_16, L_17, /*hidden argument*/NULL);
((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->set_T2_20(L_16);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_18 = (UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)SZArrayNew(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB_il2cpp_TypeInfo_var, (uint32_t)((int32_t)256));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_19 = L_18;
RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF L_20 = { reinterpret_cast<intptr_t> (U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____5B5DF5A459E902D96F7DB0FB235A25346CA85C5D_6_FieldInfo_var) };
RuntimeHelpers_InitializeArray_m29F50CDFEEE0AB868200291366253DD4737BC76A((RuntimeArray *)(RuntimeArray *)L_19, L_20, /*hidden argument*/NULL);
((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->set_T3_21(L_19);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_21 = (UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)SZArrayNew(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB_il2cpp_TypeInfo_var, (uint32_t)((int32_t)256));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_22 = L_21;
RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF L_23 = { reinterpret_cast<intptr_t> (U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____A02DD1D8604EA8EC2D2BDA717A93A4EE85F13E53_9_FieldInfo_var) };
RuntimeHelpers_InitializeArray_m29F50CDFEEE0AB868200291366253DD4737BC76A((RuntimeArray *)(RuntimeArray *)L_22, L_23, /*hidden argument*/NULL);
((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->set_iT0_22(L_22);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_24 = (UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)SZArrayNew(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB_il2cpp_TypeInfo_var, (uint32_t)((int32_t)256));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_25 = L_24;
RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF L_26 = { reinterpret_cast<intptr_t> (U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____5BE411F1438EAEF33726D855E99011D5FECDDD4E_7_FieldInfo_var) };
RuntimeHelpers_InitializeArray_m29F50CDFEEE0AB868200291366253DD4737BC76A((RuntimeArray *)(RuntimeArray *)L_25, L_26, /*hidden argument*/NULL);
((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->set_iT1_23(L_25);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_27 = (UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)SZArrayNew(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB_il2cpp_TypeInfo_var, (uint32_t)((int32_t)256));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_28 = L_27;
RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF L_29 = { reinterpret_cast<intptr_t> (U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____20733E1283D873EBE47133A95C233E11B76F5F11_2_FieldInfo_var) };
RuntimeHelpers_InitializeArray_m29F50CDFEEE0AB868200291366253DD4737BC76A((RuntimeArray *)(RuntimeArray *)L_28, L_29, /*hidden argument*/NULL);
((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->set_iT2_24(L_28);
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_30 = (UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB*)SZArrayNew(UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB_il2cpp_TypeInfo_var, (uint32_t)((int32_t)256));
UInt32U5BU5D_t9AA834AF2940E75BBF8E3F08FF0D20D266DB71CB* L_31 = L_30;
RuntimeFieldHandle_t844BDF00E8E6FE69D9AEAA7657F09018B864F4EF L_32 = { reinterpret_cast<intptr_t> (U3CPrivateImplementationDetailsU3E_t14917ACC6E0C738A985023D2ECB9D4BAC153CB5C____21F4CBF8283FF1CAEB4A39316A97FC1D6DF1D35E_3_FieldInfo_var) };
RuntimeHelpers_InitializeArray_m29F50CDFEEE0AB868200291366253DD4737BC76A((RuntimeArray *)(RuntimeArray *)L_31, L_32, /*hidden argument*/NULL);
((AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_StaticFields*)il2cpp_codegen_static_fields_for(AesTransform_tEC263AC15300586978DFC864CFE6D82314C7A208_il2cpp_TypeInfo_var))->set_iT3_25(L_31);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Threading.ReaderWriterCount::.ctor()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterCount__ctor_m1BBD3EB1DFD5837AE05A5B72DB01657C1546C0EF (ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * __this, const RuntimeMethod* method)
{
{
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0(__this, /*hidden argument*/NULL);
return;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Threading.ReaderWriterLockSlim::InitializeThreadCounts()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_InitializeThreadCounts_m6B26A0D91D196DBD41FD8C823CA33EE1CBACCA62 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
__this->set_upgradeLockOwnerId_7((-1));
__this->set_writeLockOwnerId_8((-1));
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::.ctor(System.Threading.LockRecursionPolicy)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim__ctor_mF9D168D6A94D7B6F669313541D7302A6BD9C7FF1 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, int32_t ___recursionPolicy0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ReaderWriterLockSlim__ctor_mF9D168D6A94D7B6F669313541D7302A6BD9C7FF1_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
Object__ctor_m925ECA5E85CA100E3FB86A4F9E15C120E9A184C0(__this, /*hidden argument*/NULL);
int32_t L_0 = ___recursionPolicy0;
if ((!(((uint32_t)L_0) == ((uint32_t)1))))
{
goto IL_0011;
}
}
{
__this->set_fIsReentrant_0((bool)1);
}
IL_0011:
{
ReaderWriterLockSlim_InitializeThreadCounts_m6B26A0D91D196DBD41FD8C823CA33EE1CBACCA62(__this, /*hidden argument*/NULL);
__this->set_fNoWaiters_6((bool)1);
int64_t L_1 = Interlocked_Increment_mC76DFF0EEFD78295EB586C282E4B64AA6595C0DC((int64_t*)(((ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_StaticFields*)il2cpp_codegen_static_fields_for(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_il2cpp_TypeInfo_var))->get_address_of_s_nextLockID_13()), /*hidden argument*/NULL);
__this->set_lockID_14(L_1);
return;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::IsRWEntryEmpty(System.Threading.ReaderWriterCount)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_IsRWEntryEmpty_m81FB0780C065C2D3ADF7662E8C89938FF86596B9 (ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * ___rwc0, const RuntimeMethod* method)
{
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_0 = ___rwc0;
NullCheck(L_0);
int64_t L_1 = L_0->get_lockID_0();
if (L_1)
{
goto IL_000a;
}
}
{
return (bool)1;
}
IL_000a:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_2 = ___rwc0;
NullCheck(L_2);
int32_t L_3 = L_2->get_readercount_1();
if (L_3)
{
goto IL_0024;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_4 = ___rwc0;
NullCheck(L_4);
int32_t L_5 = L_4->get_writercount_2();
if (L_5)
{
goto IL_0024;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_6 = ___rwc0;
NullCheck(L_6);
int32_t L_7 = L_6->get_upgradecount_3();
if (L_7)
{
goto IL_0024;
}
}
{
return (bool)1;
}
IL_0024:
{
return (bool)0;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::IsRwHashEntryChanged(System.Threading.ReaderWriterCount)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_IsRwHashEntryChanged_m0224E239675EDC26497D7097C004AAC052561AF0 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * ___lrwc0, const RuntimeMethod* method)
{
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_0 = ___lrwc0;
NullCheck(L_0);
int64_t L_1 = L_0->get_lockID_0();
int64_t L_2 = __this->get_lockID_14();
return (bool)((((int32_t)((((int64_t)L_1) == ((int64_t)L_2))? 1 : 0)) == ((int32_t)0))? 1 : 0);
}
}
// System.Threading.ReaderWriterCount System.Threading.ReaderWriterLockSlim::GetThreadRWCount(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, bool ___dontAllocate0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * V_0 = NULL;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * V_1 = NULL;
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_0 = ((ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_ThreadStaticFields*)il2cpp_codegen_get_thread_static_data(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_il2cpp_TypeInfo_var))->get_t_rwc_15();
V_0 = L_0;
V_1 = (ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 *)NULL;
goto IL_0031;
}
IL_000a:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_1 = V_0;
NullCheck(L_1);
int64_t L_2 = L_1->get_lockID_0();
int64_t L_3 = __this->get_lockID_14();
if ((!(((uint64_t)L_2) == ((uint64_t)L_3))))
{
goto IL_001a;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_4 = V_0;
return L_4;
}
IL_001a:
{
bool L_5 = ___dontAllocate0;
if (L_5)
{
goto IL_002a;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_6 = V_1;
if (L_6)
{
goto IL_002a;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_7 = V_0;
bool L_8 = ReaderWriterLockSlim_IsRWEntryEmpty_m81FB0780C065C2D3ADF7662E8C89938FF86596B9_inline(L_7, /*hidden argument*/NULL);
if (!L_8)
{
goto IL_002a;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_9 = V_0;
V_1 = L_9;
}
IL_002a:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_10 = V_0;
NullCheck(L_10);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_11 = L_10->get_next_4();
V_0 = L_11;
}
IL_0031:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_12 = V_0;
if (L_12)
{
goto IL_000a;
}
}
{
bool L_13 = ___dontAllocate0;
if (!L_13)
{
goto IL_0039;
}
}
{
return (ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 *)NULL;
}
IL_0039:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_14 = V_1;
if (L_14)
{
goto IL_0053;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_15 = (ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 *)il2cpp_codegen_object_new(ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900_il2cpp_TypeInfo_var);
ReaderWriterCount__ctor_m1BBD3EB1DFD5837AE05A5B72DB01657C1546C0EF(L_15, /*hidden argument*/NULL);
V_1 = L_15;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_16 = V_1;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_17 = ((ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_ThreadStaticFields*)il2cpp_codegen_get_thread_static_data(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_il2cpp_TypeInfo_var))->get_t_rwc_15();
NullCheck(L_16);
L_16->set_next_4(L_17);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_18 = V_1;
((ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_ThreadStaticFields*)il2cpp_codegen_get_thread_static_data(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_il2cpp_TypeInfo_var))->set_t_rwc_15(L_18);
}
IL_0053:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_19 = V_1;
int64_t L_20 = __this->get_lockID_14();
NullCheck(L_19);
L_19->set_lockID_0(L_20);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_21 = V_1;
return L_21;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::EnterReadLock()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_EnterReadLock_mEDE8748AD6C8FDB430788B60C2E91331009C5A36 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
ReaderWriterLockSlim_TryEnterReadLock_m9DCDCD139A9F4717EAFB1795A89F9579B256AAB3(__this, (-1), /*hidden argument*/NULL);
return;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterReadLock(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterReadLock_m9DCDCD139A9F4717EAFB1795A89F9579B256AAB3 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, int32_t ___millisecondsTimeout0, const RuntimeMethod* method)
{
{
int32_t L_0 = ___millisecondsTimeout0;
TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 L_1;
memset((&L_1), 0, sizeof(L_1));
TimeoutTracker__ctor_m2238A5B6D938E911C2F7742E5A90E1E670F570F9((&L_1), L_0, /*hidden argument*/NULL);
bool L_2 = ReaderWriterLockSlim_TryEnterReadLock_mA430E93FBDC3DD271642867ACE99ADE739FD9815(__this, L_1, /*hidden argument*/NULL);
return L_2;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterReadLock(System.Threading.ReaderWriterLockSlim_TimeoutTracker)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterReadLock_mA430E93FBDC3DD271642867ACE99ADE739FD9815 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 ___timeout0, const RuntimeMethod* method)
{
{
TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 L_0 = ___timeout0;
bool L_1 = ReaderWriterLockSlim_TryEnterReadLockCore_m946546F9F496EF40AB1C4B24FA8466A4E2D4E1DA(__this, L_0, /*hidden argument*/NULL);
return L_1;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterReadLockCore(System.Threading.ReaderWriterLockSlim_TimeoutTracker)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterReadLockCore_m946546F9F496EF40AB1C4B24FA8466A4E2D4E1DA (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 ___timeout0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ReaderWriterLockSlim_TryEnterReadLockCore_m946546F9F496EF40AB1C4B24FA8466A4E2D4E1DA_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * V_0 = NULL;
int32_t V_1 = 0;
bool V_2 = false;
int32_t V_3 = 0;
{
bool L_0 = __this->get_fDisposed_18();
if (!L_0)
{
goto IL_000f;
}
}
{
ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A * L_1 = (ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A *)il2cpp_codegen_object_new(ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A_il2cpp_TypeInfo_var);
ObjectDisposedException__ctor_m8B5D23EA08E42BDE6BC5233CC666295F19BBD2F9(L_1, (String_t*)NULL, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, ReaderWriterLockSlim_TryEnterReadLockCore_m946546F9F496EF40AB1C4B24FA8466A4E2D4E1DA_RuntimeMethod_var);
}
IL_000f:
{
V_0 = (ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 *)NULL;
Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * L_2 = Thread_get_CurrentThread_mB7A83CAE2B9A74CEA053196DFD1AF1E7AB30A70E(/*hidden argument*/NULL);
NullCheck(L_2);
int32_t L_3 = Thread_get_ManagedThreadId_m7FA85162CB00713B94EF5708B19120F791D3AAD1(L_2, /*hidden argument*/NULL);
V_1 = L_3;
bool L_4 = __this->get_fIsReentrant_0();
if (L_4)
{
goto IL_009a;
}
}
{
int32_t L_5 = V_1;
int32_t L_6 = __this->get_writeLockOwnerId_8();
if ((!(((uint32_t)L_5) == ((uint32_t)L_6))))
{
goto IL_003d;
}
}
{
String_t* L_7 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteral2ECBD375CE3135E79828D5011999895D360C96FF, /*hidden argument*/NULL);
LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 * L_8 = (LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 *)il2cpp_codegen_object_new(LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9_il2cpp_TypeInfo_var);
LockRecursionException__ctor_mC4B847F5F4421F0B7EA18E302D346C35C8A2F9E1(L_8, L_7, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_8, NULL, ReaderWriterLockSlim_TryEnterReadLockCore_m946546F9F496EF40AB1C4B24FA8466A4E2D4E1DA_RuntimeMethod_var);
}
IL_003d:
{
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_9 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)0, /*hidden argument*/NULL);
V_0 = L_9;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_10 = V_0;
NullCheck(L_10);
int32_t L_11 = L_10->get_readercount_1();
if ((((int32_t)L_11) <= ((int32_t)0)))
{
goto IL_006a;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
String_t* L_12 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteral69F29D02EF38F7D5571FFBD7DFC80325B1377895, /*hidden argument*/NULL);
LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 * L_13 = (LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 *)il2cpp_codegen_object_new(LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9_il2cpp_TypeInfo_var);
LockRecursionException__ctor_mC4B847F5F4421F0B7EA18E302D346C35C8A2F9E1(L_13, L_12, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_13, NULL, ReaderWriterLockSlim_TryEnterReadLockCore_m946546F9F496EF40AB1C4B24FA8466A4E2D4E1DA_RuntimeMethod_var);
}
IL_006a:
{
int32_t L_14 = V_1;
int32_t L_15 = __this->get_upgradeLockOwnerId_7();
if ((!(((uint32_t)L_14) == ((uint32_t)L_15))))
{
goto IL_0128;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_16 = V_0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_17 = L_16;
NullCheck(L_17);
int32_t L_18 = L_17->get_readercount_1();
NullCheck(L_17);
L_17->set_readercount_1(((int32_t)il2cpp_codegen_add((int32_t)L_18, (int32_t)1)));
uint32_t L_19 = __this->get_owners_17();
__this->set_owners_17(((int32_t)il2cpp_codegen_add((int32_t)L_19, (int32_t)1)));
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
return (bool)1;
}
IL_009a:
{
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_20 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)0, /*hidden argument*/NULL);
V_0 = L_20;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_21 = V_0;
NullCheck(L_21);
int32_t L_22 = L_21->get_readercount_1();
if ((((int32_t)L_22) <= ((int32_t)0)))
{
goto IL_00c7;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_23 = V_0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_24 = L_23;
NullCheck(L_24);
int32_t L_25 = L_24->get_readercount_1();
NullCheck(L_24);
L_24->set_readercount_1(((int32_t)il2cpp_codegen_add((int32_t)L_25, (int32_t)1)));
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
return (bool)1;
}
IL_00c7:
{
int32_t L_26 = V_1;
int32_t L_27 = __this->get_upgradeLockOwnerId_7();
if ((!(((uint32_t)L_26) == ((uint32_t)L_27))))
{
goto IL_00fb;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_28 = V_0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_29 = L_28;
NullCheck(L_29);
int32_t L_30 = L_29->get_readercount_1();
NullCheck(L_29);
L_29->set_readercount_1(((int32_t)il2cpp_codegen_add((int32_t)L_30, (int32_t)1)));
uint32_t L_31 = __this->get_owners_17();
__this->set_owners_17(((int32_t)il2cpp_codegen_add((int32_t)L_31, (int32_t)1)));
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
__this->set_fUpgradeThreadHoldingRead_16((bool)1);
return (bool)1;
}
IL_00fb:
{
int32_t L_32 = V_1;
int32_t L_33 = __this->get_writeLockOwnerId_8();
if ((!(((uint32_t)L_32) == ((uint32_t)L_33))))
{
goto IL_0128;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_34 = V_0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_35 = L_34;
NullCheck(L_35);
int32_t L_36 = L_35->get_readercount_1();
NullCheck(L_35);
L_35->set_readercount_1(((int32_t)il2cpp_codegen_add((int32_t)L_36, (int32_t)1)));
uint32_t L_37 = __this->get_owners_17();
__this->set_owners_17(((int32_t)il2cpp_codegen_add((int32_t)L_37, (int32_t)1)));
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
return (bool)1;
}
IL_0128:
{
V_2 = (bool)1;
V_3 = 0;
}
IL_012c:
{
uint32_t L_38 = __this->get_owners_17();
if ((!(((uint32_t)L_38) < ((uint32_t)((int32_t)268435454)))))
{
goto IL_015a;
}
}
{
uint32_t L_39 = __this->get_owners_17();
__this->set_owners_17(((int32_t)il2cpp_codegen_add((int32_t)L_39, (int32_t)1)));
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_40 = V_0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_41 = L_40;
NullCheck(L_41);
int32_t L_42 = L_41->get_readercount_1();
NullCheck(L_41);
L_41->set_readercount_1(((int32_t)il2cpp_codegen_add((int32_t)L_42, (int32_t)1)));
goto IL_01f4;
}
IL_015a:
{
int32_t L_43 = V_3;
if ((((int32_t)L_43) >= ((int32_t)((int32_t)20))))
{
goto IL_0193;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
bool L_44 = TimeoutTracker_get_IsExpired_m3A2BF7A380901450677142E2863EB14A28B3EE85((TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 *)(&___timeout0), /*hidden argument*/NULL);
if (!L_44)
{
goto IL_0170;
}
}
{
return (bool)0;
}
IL_0170:
{
int32_t L_45 = V_3;
V_3 = ((int32_t)il2cpp_codegen_add((int32_t)L_45, (int32_t)1));
int32_t L_46 = V_3;
ReaderWriterLockSlim_SpinWait_m326D5ADB06292AEB146FCB7D577AA19E63C8A9EA(L_46, /*hidden argument*/NULL);
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_47 = V_0;
bool L_48 = ReaderWriterLockSlim_IsRwHashEntryChanged_m0224E239675EDC26497D7097C004AAC052561AF0(__this, L_47, /*hidden argument*/NULL);
if (!L_48)
{
goto IL_012c;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_49 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)0, /*hidden argument*/NULL);
V_0 = L_49;
goto IL_012c;
}
IL_0193:
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_50 = __this->get_readEvent_10();
if (L_50)
{
goto IL_01c1;
}
}
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 ** L_51 = __this->get_address_of_readEvent_10();
ReaderWriterLockSlim_LazyCreateEvent_mF1FB4CDE744ADC2CADEE4F020F095896E1C64D1A(__this, (EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 **)L_51, (bool)0, /*hidden argument*/NULL);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_52 = V_0;
bool L_53 = ReaderWriterLockSlim_IsRwHashEntryChanged_m0224E239675EDC26497D7097C004AAC052561AF0(__this, L_52, /*hidden argument*/NULL);
if (!L_53)
{
goto IL_012c;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_54 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)0, /*hidden argument*/NULL);
V_0 = L_54;
goto IL_012c;
}
IL_01c1:
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_55 = __this->get_readEvent_10();
uint32_t* L_56 = __this->get_address_of_numReadWaiters_3();
TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 L_57 = ___timeout0;
bool L_58 = ReaderWriterLockSlim_WaitOnEvent_mE15EA3B2BB1C0145C6014F71F635FA5AECC0CD7F(__this, L_55, (uint32_t*)L_56, L_57, (bool)0, /*hidden argument*/NULL);
V_2 = L_58;
bool L_59 = V_2;
if (L_59)
{
goto IL_01db;
}
}
{
return (bool)0;
}
IL_01db:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_60 = V_0;
bool L_61 = ReaderWriterLockSlim_IsRwHashEntryChanged_m0224E239675EDC26497D7097C004AAC052561AF0(__this, L_60, /*hidden argument*/NULL);
if (!L_61)
{
goto IL_012c;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_62 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)0, /*hidden argument*/NULL);
V_0 = L_62;
goto IL_012c;
}
IL_01f4:
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
bool L_63 = V_2;
return L_63;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::EnterWriteLock()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_EnterWriteLock_mC5FC7F22B1A618F9B6DA05EE25681FDD2C869461 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
ReaderWriterLockSlim_TryEnterWriteLock_m261EB842AE34C83257118B44645CB41B06F9750B(__this, (-1), /*hidden argument*/NULL);
return;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterWriteLock(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterWriteLock_m261EB842AE34C83257118B44645CB41B06F9750B (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, int32_t ___millisecondsTimeout0, const RuntimeMethod* method)
{
{
int32_t L_0 = ___millisecondsTimeout0;
TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 L_1;
memset((&L_1), 0, sizeof(L_1));
TimeoutTracker__ctor_m2238A5B6D938E911C2F7742E5A90E1E670F570F9((&L_1), L_0, /*hidden argument*/NULL);
bool L_2 = ReaderWriterLockSlim_TryEnterWriteLock_mD6B75A7D593659DB2591012ADF1AC9AE3156FBF9(__this, L_1, /*hidden argument*/NULL);
return L_2;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterWriteLock(System.Threading.ReaderWriterLockSlim_TimeoutTracker)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterWriteLock_mD6B75A7D593659DB2591012ADF1AC9AE3156FBF9 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 ___timeout0, const RuntimeMethod* method)
{
{
TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 L_0 = ___timeout0;
bool L_1 = ReaderWriterLockSlim_TryEnterWriteLockCore_m89767DB508CA2EDBAD19B727B0814DF5EA959F9E(__this, L_0, /*hidden argument*/NULL);
return L_1;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterWriteLockCore(System.Threading.ReaderWriterLockSlim_TimeoutTracker)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterWriteLockCore_m89767DB508CA2EDBAD19B727B0814DF5EA959F9E (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 ___timeout0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ReaderWriterLockSlim_TryEnterWriteLockCore_m89767DB508CA2EDBAD19B727B0814DF5EA959F9E_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * V_1 = NULL;
bool V_2 = false;
int32_t V_3 = 0;
uint32_t V_4 = 0;
{
bool L_0 = __this->get_fDisposed_18();
if (!L_0)
{
goto IL_000f;
}
}
{
ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A * L_1 = (ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A *)il2cpp_codegen_object_new(ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A_il2cpp_TypeInfo_var);
ObjectDisposedException__ctor_m8B5D23EA08E42BDE6BC5233CC666295F19BBD2F9(L_1, (String_t*)NULL, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, ReaderWriterLockSlim_TryEnterWriteLockCore_m89767DB508CA2EDBAD19B727B0814DF5EA959F9E_RuntimeMethod_var);
}
IL_000f:
{
Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * L_2 = Thread_get_CurrentThread_mB7A83CAE2B9A74CEA053196DFD1AF1E7AB30A70E(/*hidden argument*/NULL);
NullCheck(L_2);
int32_t L_3 = Thread_get_ManagedThreadId_m7FA85162CB00713B94EF5708B19120F791D3AAD1(L_2, /*hidden argument*/NULL);
V_0 = L_3;
V_2 = (bool)0;
bool L_4 = __this->get_fIsReentrant_0();
if (L_4)
{
goto IL_0078;
}
}
{
int32_t L_5 = V_0;
int32_t L_6 = __this->get_writeLockOwnerId_8();
if ((!(((uint32_t)L_5) == ((uint32_t)L_6))))
{
goto IL_003d;
}
}
{
String_t* L_7 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteral10C80EDD83941DF788671EE857634D37829B4A25, /*hidden argument*/NULL);
LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 * L_8 = (LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 *)il2cpp_codegen_object_new(LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9_il2cpp_TypeInfo_var);
LockRecursionException__ctor_mC4B847F5F4421F0B7EA18E302D346C35C8A2F9E1(L_8, L_7, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_8, NULL, ReaderWriterLockSlim_TryEnterWriteLockCore_m89767DB508CA2EDBAD19B727B0814DF5EA959F9E_RuntimeMethod_var);
}
IL_003d:
{
int32_t L_9 = V_0;
int32_t L_10 = __this->get_upgradeLockOwnerId_7();
if ((!(((uint32_t)L_9) == ((uint32_t)L_10))))
{
goto IL_0048;
}
}
{
V_2 = (bool)1;
}
IL_0048:
{
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_11 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)1, /*hidden argument*/NULL);
V_1 = L_11;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_12 = V_1;
if (!L_12)
{
goto IL_00d1;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_13 = V_1;
NullCheck(L_13);
int32_t L_14 = L_13->get_readercount_1();
if ((((int32_t)L_14) <= ((int32_t)0)))
{
goto IL_00d1;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
String_t* L_15 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteral4CB242DE8E5548B98BD01BE41F233316CF712862, /*hidden argument*/NULL);
LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 * L_16 = (LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 *)il2cpp_codegen_object_new(LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9_il2cpp_TypeInfo_var);
LockRecursionException__ctor_mC4B847F5F4421F0B7EA18E302D346C35C8A2F9E1(L_16, L_15, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_16, NULL, ReaderWriterLockSlim_TryEnterWriteLockCore_m89767DB508CA2EDBAD19B727B0814DF5EA959F9E_RuntimeMethod_var);
}
IL_0078:
{
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_17 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)0, /*hidden argument*/NULL);
V_1 = L_17;
int32_t L_18 = V_0;
int32_t L_19 = __this->get_writeLockOwnerId_8();
if ((!(((uint32_t)L_18) == ((uint32_t)L_19))))
{
goto IL_00a5;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_20 = V_1;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_21 = L_20;
NullCheck(L_21);
int32_t L_22 = L_21->get_writercount_2();
NullCheck(L_21);
L_21->set_writercount_2(((int32_t)il2cpp_codegen_add((int32_t)L_22, (int32_t)1)));
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
return (bool)1;
}
IL_00a5:
{
int32_t L_23 = V_0;
int32_t L_24 = __this->get_upgradeLockOwnerId_7();
if ((!(((uint32_t)L_23) == ((uint32_t)L_24))))
{
goto IL_00b2;
}
}
{
V_2 = (bool)1;
goto IL_00d1;
}
IL_00b2:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_25 = V_1;
NullCheck(L_25);
int32_t L_26 = L_25->get_readercount_1();
if ((((int32_t)L_26) <= ((int32_t)0)))
{
goto IL_00d1;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
String_t* L_27 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteral4CB242DE8E5548B98BD01BE41F233316CF712862, /*hidden argument*/NULL);
LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 * L_28 = (LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 *)il2cpp_codegen_object_new(LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9_il2cpp_TypeInfo_var);
LockRecursionException__ctor_mC4B847F5F4421F0B7EA18E302D346C35C8A2F9E1(L_28, L_27, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_28, NULL, ReaderWriterLockSlim_TryEnterWriteLockCore_m89767DB508CA2EDBAD19B727B0814DF5EA959F9E_RuntimeMethod_var);
}
IL_00d1:
{
V_3 = 0;
}
IL_00d3:
{
bool L_29 = ReaderWriterLockSlim_IsWriterAcquired_m0FC58A2B2697A2911D5C76D4D51E758ED006E3DD(__this, /*hidden argument*/NULL);
if (!L_29)
{
goto IL_00e6;
}
}
{
ReaderWriterLockSlim_SetWriterAcquired_mA707D12FB8981C8B7BA215DC0E912EF063CB215B(__this, /*hidden argument*/NULL);
goto IL_01c6;
}
IL_00e6:
{
bool L_30 = V_2;
if (!L_30)
{
goto IL_012e;
}
}
{
uint32_t L_31 = ReaderWriterLockSlim_GetNumReaders_m677B71BAF98B757FB32C4F0EB7D6E240E6D1A2B1(__this, /*hidden argument*/NULL);
V_4 = L_31;
uint32_t L_32 = V_4;
if ((!(((uint32_t)L_32) == ((uint32_t)1))))
{
goto IL_0101;
}
}
{
ReaderWriterLockSlim_SetWriterAcquired_mA707D12FB8981C8B7BA215DC0E912EF063CB215B(__this, /*hidden argument*/NULL);
goto IL_01c6;
}
IL_0101:
{
uint32_t L_33 = V_4;
if ((!(((uint32_t)L_33) == ((uint32_t)2))))
{
goto IL_012e;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_34 = V_1;
if (!L_34)
{
goto IL_012e;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_35 = V_1;
bool L_36 = ReaderWriterLockSlim_IsRwHashEntryChanged_m0224E239675EDC26497D7097C004AAC052561AF0(__this, L_35, /*hidden argument*/NULL);
if (!L_36)
{
goto IL_011a;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_37 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)0, /*hidden argument*/NULL);
V_1 = L_37;
}
IL_011a:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_38 = V_1;
NullCheck(L_38);
int32_t L_39 = L_38->get_readercount_1();
if ((((int32_t)L_39) <= ((int32_t)0)))
{
goto IL_012e;
}
}
{
ReaderWriterLockSlim_SetWriterAcquired_mA707D12FB8981C8B7BA215DC0E912EF063CB215B(__this, /*hidden argument*/NULL);
goto IL_01c6;
}
IL_012e:
{
int32_t L_40 = V_3;
if ((((int32_t)L_40) >= ((int32_t)((int32_t)20))))
{
goto IL_0159;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
bool L_41 = TimeoutTracker_get_IsExpired_m3A2BF7A380901450677142E2863EB14A28B3EE85((TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 *)(&___timeout0), /*hidden argument*/NULL);
if (!L_41)
{
goto IL_0144;
}
}
{
return (bool)0;
}
IL_0144:
{
int32_t L_42 = V_3;
V_3 = ((int32_t)il2cpp_codegen_add((int32_t)L_42, (int32_t)1));
int32_t L_43 = V_3;
ReaderWriterLockSlim_SpinWait_m326D5ADB06292AEB146FCB7D577AA19E63C8A9EA(L_43, /*hidden argument*/NULL);
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
goto IL_00d3;
}
IL_0159:
{
bool L_44 = V_2;
if (!L_44)
{
goto IL_0191;
}
}
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_45 = __this->get_waitUpgradeEvent_12();
if (L_45)
{
goto IL_0176;
}
}
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 ** L_46 = __this->get_address_of_waitUpgradeEvent_12();
ReaderWriterLockSlim_LazyCreateEvent_mF1FB4CDE744ADC2CADEE4F020F095896E1C64D1A(__this, (EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 **)L_46, (bool)1, /*hidden argument*/NULL);
goto IL_00d3;
}
IL_0176:
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_47 = __this->get_waitUpgradeEvent_12();
uint32_t* L_48 = __this->get_address_of_numWriteUpgradeWaiters_4();
TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 L_49 = ___timeout0;
bool L_50 = ReaderWriterLockSlim_WaitOnEvent_mE15EA3B2BB1C0145C6014F71F635FA5AECC0CD7F(__this, L_47, (uint32_t*)L_48, L_49, (bool)1, /*hidden argument*/NULL);
if (L_50)
{
goto IL_00d3;
}
}
{
return (bool)0;
}
IL_0191:
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_51 = __this->get_writeEvent_9();
if (L_51)
{
goto IL_01ab;
}
}
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 ** L_52 = __this->get_address_of_writeEvent_9();
ReaderWriterLockSlim_LazyCreateEvent_mF1FB4CDE744ADC2CADEE4F020F095896E1C64D1A(__this, (EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 **)L_52, (bool)1, /*hidden argument*/NULL);
goto IL_00d3;
}
IL_01ab:
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_53 = __this->get_writeEvent_9();
uint32_t* L_54 = __this->get_address_of_numWriteWaiters_2();
TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 L_55 = ___timeout0;
bool L_56 = ReaderWriterLockSlim_WaitOnEvent_mE15EA3B2BB1C0145C6014F71F635FA5AECC0CD7F(__this, L_53, (uint32_t*)L_54, L_55, (bool)1, /*hidden argument*/NULL);
if (L_56)
{
goto IL_00d3;
}
}
{
return (bool)0;
}
IL_01c6:
{
bool L_57 = __this->get_fIsReentrant_0();
if (!L_57)
{
goto IL_01ed;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_58 = V_1;
bool L_59 = ReaderWriterLockSlim_IsRwHashEntryChanged_m0224E239675EDC26497D7097C004AAC052561AF0(__this, L_58, /*hidden argument*/NULL);
if (!L_59)
{
goto IL_01df;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_60 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)0, /*hidden argument*/NULL);
V_1 = L_60;
}
IL_01df:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_61 = V_1;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_62 = L_61;
NullCheck(L_62);
int32_t L_63 = L_62->get_writercount_2();
NullCheck(L_62);
L_62->set_writercount_2(((int32_t)il2cpp_codegen_add((int32_t)L_63, (int32_t)1)));
}
IL_01ed:
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
int32_t L_64 = V_0;
__this->set_writeLockOwnerId_8(L_64);
return (bool)1;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::EnterUpgradeableReadLock()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_EnterUpgradeableReadLock_m0025F11E56CA9D8A3822BFE6CAB4D4BB9890DEFD (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
ReaderWriterLockSlim_TryEnterUpgradeableReadLock_m9F8188CC19D128C34EC9DBA2C09E576A3FAD6403(__this, (-1), /*hidden argument*/NULL);
return;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterUpgradeableReadLock(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterUpgradeableReadLock_m9F8188CC19D128C34EC9DBA2C09E576A3FAD6403 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, int32_t ___millisecondsTimeout0, const RuntimeMethod* method)
{
{
int32_t L_0 = ___millisecondsTimeout0;
TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 L_1;
memset((&L_1), 0, sizeof(L_1));
TimeoutTracker__ctor_m2238A5B6D938E911C2F7742E5A90E1E670F570F9((&L_1), L_0, /*hidden argument*/NULL);
bool L_2 = ReaderWriterLockSlim_TryEnterUpgradeableReadLock_mBFDA69E20364175224C97C8963B0EDDFA7B229A7(__this, L_1, /*hidden argument*/NULL);
return L_2;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterUpgradeableReadLock(System.Threading.ReaderWriterLockSlim_TimeoutTracker)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterUpgradeableReadLock_mBFDA69E20364175224C97C8963B0EDDFA7B229A7 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 ___timeout0, const RuntimeMethod* method)
{
{
TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 L_0 = ___timeout0;
bool L_1 = ReaderWriterLockSlim_TryEnterUpgradeableReadLockCore_m2275C4016382DCDD9A5B2EA8B1239C710486EBFB(__this, L_0, /*hidden argument*/NULL);
return L_1;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::TryEnterUpgradeableReadLockCore(System.Threading.ReaderWriterLockSlim_TimeoutTracker)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_TryEnterUpgradeableReadLockCore_m2275C4016382DCDD9A5B2EA8B1239C710486EBFB (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 ___timeout0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ReaderWriterLockSlim_TryEnterUpgradeableReadLockCore_m2275C4016382DCDD9A5B2EA8B1239C710486EBFB_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * V_1 = NULL;
int32_t V_2 = 0;
{
bool L_0 = __this->get_fDisposed_18();
if (!L_0)
{
goto IL_000f;
}
}
{
ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A * L_1 = (ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A *)il2cpp_codegen_object_new(ObjectDisposedException_tF68E471ECD1419AD7C51137B742837395F50B69A_il2cpp_TypeInfo_var);
ObjectDisposedException__ctor_m8B5D23EA08E42BDE6BC5233CC666295F19BBD2F9(L_1, (String_t*)NULL, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, ReaderWriterLockSlim_TryEnterUpgradeableReadLockCore_m2275C4016382DCDD9A5B2EA8B1239C710486EBFB_RuntimeMethod_var);
}
IL_000f:
{
Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * L_2 = Thread_get_CurrentThread_mB7A83CAE2B9A74CEA053196DFD1AF1E7AB30A70E(/*hidden argument*/NULL);
NullCheck(L_2);
int32_t L_3 = Thread_get_ManagedThreadId_m7FA85162CB00713B94EF5708B19120F791D3AAD1(L_2, /*hidden argument*/NULL);
V_0 = L_3;
bool L_4 = __this->get_fIsReentrant_0();
if (L_4)
{
goto IL_008a;
}
}
{
int32_t L_5 = V_0;
int32_t L_6 = __this->get_upgradeLockOwnerId_7();
if ((!(((uint32_t)L_5) == ((uint32_t)L_6))))
{
goto IL_003b;
}
}
{
String_t* L_7 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteralBB863394E44E7F0AB103B463E68E0DE654F40669, /*hidden argument*/NULL);
LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 * L_8 = (LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 *)il2cpp_codegen_object_new(LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9_il2cpp_TypeInfo_var);
LockRecursionException__ctor_mC4B847F5F4421F0B7EA18E302D346C35C8A2F9E1(L_8, L_7, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_8, NULL, ReaderWriterLockSlim_TryEnterUpgradeableReadLockCore_m2275C4016382DCDD9A5B2EA8B1239C710486EBFB_RuntimeMethod_var);
}
IL_003b:
{
int32_t L_9 = V_0;
int32_t L_10 = __this->get_writeLockOwnerId_8();
if ((!(((uint32_t)L_9) == ((uint32_t)L_10))))
{
goto IL_0054;
}
}
{
String_t* L_11 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteralC4CDA1BBE106A03CCFAA2F8227D0ACC029A16555, /*hidden argument*/NULL);
LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 * L_12 = (LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 *)il2cpp_codegen_object_new(LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9_il2cpp_TypeInfo_var);
LockRecursionException__ctor_mC4B847F5F4421F0B7EA18E302D346C35C8A2F9E1(L_12, L_11, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_12, NULL, ReaderWriterLockSlim_TryEnterUpgradeableReadLockCore_m2275C4016382DCDD9A5B2EA8B1239C710486EBFB_RuntimeMethod_var);
}
IL_0054:
{
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_13 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)1, /*hidden argument*/NULL);
V_1 = L_13;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_14 = V_1;
if (!L_14)
{
goto IL_011a;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_15 = V_1;
NullCheck(L_15);
int32_t L_16 = L_15->get_readercount_1();
if ((((int32_t)L_16) <= ((int32_t)0)))
{
goto IL_011a;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
String_t* L_17 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteral5249E2CEECA370436A4C6708678965453623EC52, /*hidden argument*/NULL);
LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 * L_18 = (LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 *)il2cpp_codegen_object_new(LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9_il2cpp_TypeInfo_var);
LockRecursionException__ctor_mC4B847F5F4421F0B7EA18E302D346C35C8A2F9E1(L_18, L_17, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_18, NULL, ReaderWriterLockSlim_TryEnterUpgradeableReadLockCore_m2275C4016382DCDD9A5B2EA8B1239C710486EBFB_RuntimeMethod_var);
}
IL_008a:
{
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_19 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)0, /*hidden argument*/NULL);
V_1 = L_19;
int32_t L_20 = V_0;
int32_t L_21 = __this->get_upgradeLockOwnerId_7();
if ((!(((uint32_t)L_20) == ((uint32_t)L_21))))
{
goto IL_00b7;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_22 = V_1;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_23 = L_22;
NullCheck(L_23);
int32_t L_24 = L_23->get_upgradecount_3();
NullCheck(L_23);
L_23->set_upgradecount_3(((int32_t)il2cpp_codegen_add((int32_t)L_24, (int32_t)1)));
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
return (bool)1;
}
IL_00b7:
{
int32_t L_25 = V_0;
int32_t L_26 = __this->get_writeLockOwnerId_8();
if ((!(((uint32_t)L_25) == ((uint32_t)L_26))))
{
goto IL_00fb;
}
}
{
uint32_t L_27 = __this->get_owners_17();
__this->set_owners_17(((int32_t)il2cpp_codegen_add((int32_t)L_27, (int32_t)1)));
int32_t L_28 = V_0;
__this->set_upgradeLockOwnerId_7(L_28);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_29 = V_1;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_30 = L_29;
NullCheck(L_30);
int32_t L_31 = L_30->get_upgradecount_3();
NullCheck(L_30);
L_30->set_upgradecount_3(((int32_t)il2cpp_codegen_add((int32_t)L_31, (int32_t)1)));
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_32 = V_1;
NullCheck(L_32);
int32_t L_33 = L_32->get_readercount_1();
if ((((int32_t)L_33) <= ((int32_t)0)))
{
goto IL_00f3;
}
}
{
__this->set_fUpgradeThreadHoldingRead_16((bool)1);
}
IL_00f3:
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
return (bool)1;
}
IL_00fb:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_34 = V_1;
NullCheck(L_34);
int32_t L_35 = L_34->get_readercount_1();
if ((((int32_t)L_35) <= ((int32_t)0)))
{
goto IL_011a;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
String_t* L_36 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteral5249E2CEECA370436A4C6708678965453623EC52, /*hidden argument*/NULL);
LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 * L_37 = (LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9 *)il2cpp_codegen_object_new(LockRecursionException_tB25740EFF8FBE39193D06FEDAD527853C70944B9_il2cpp_TypeInfo_var);
LockRecursionException__ctor_mC4B847F5F4421F0B7EA18E302D346C35C8A2F9E1(L_37, L_36, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_37, NULL, ReaderWriterLockSlim_TryEnterUpgradeableReadLockCore_m2275C4016382DCDD9A5B2EA8B1239C710486EBFB_RuntimeMethod_var);
}
IL_011a:
{
V_2 = 0;
}
IL_011c:
{
int32_t L_38 = __this->get_upgradeLockOwnerId_7();
if ((!(((uint32_t)L_38) == ((uint32_t)(-1)))))
{
goto IL_0149;
}
}
{
uint32_t L_39 = __this->get_owners_17();
if ((!(((uint32_t)L_39) < ((uint32_t)((int32_t)268435454)))))
{
goto IL_0149;
}
}
{
uint32_t L_40 = __this->get_owners_17();
__this->set_owners_17(((int32_t)il2cpp_codegen_add((int32_t)L_40, (int32_t)1)));
int32_t L_41 = V_0;
__this->set_upgradeLockOwnerId_7(L_41);
goto IL_01a3;
}
IL_0149:
{
int32_t L_42 = V_2;
if ((((int32_t)L_42) >= ((int32_t)((int32_t)20))))
{
goto IL_0171;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
bool L_43 = TimeoutTracker_get_IsExpired_m3A2BF7A380901450677142E2863EB14A28B3EE85((TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 *)(&___timeout0), /*hidden argument*/NULL);
if (!L_43)
{
goto IL_015f;
}
}
{
return (bool)0;
}
IL_015f:
{
int32_t L_44 = V_2;
V_2 = ((int32_t)il2cpp_codegen_add((int32_t)L_44, (int32_t)1));
int32_t L_45 = V_2;
ReaderWriterLockSlim_SpinWait_m326D5ADB06292AEB146FCB7D577AA19E63C8A9EA(L_45, /*hidden argument*/NULL);
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
goto IL_011c;
}
IL_0171:
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_46 = __this->get_upgradeEvent_11();
if (L_46)
{
goto IL_0188;
}
}
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 ** L_47 = __this->get_address_of_upgradeEvent_11();
ReaderWriterLockSlim_LazyCreateEvent_mF1FB4CDE744ADC2CADEE4F020F095896E1C64D1A(__this, (EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 **)L_47, (bool)1, /*hidden argument*/NULL);
goto IL_011c;
}
IL_0188:
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_48 = __this->get_upgradeEvent_11();
uint32_t* L_49 = __this->get_address_of_numUpgradeWaiters_5();
TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 L_50 = ___timeout0;
bool L_51 = ReaderWriterLockSlim_WaitOnEvent_mE15EA3B2BB1C0145C6014F71F635FA5AECC0CD7F(__this, L_48, (uint32_t*)L_49, L_50, (bool)0, /*hidden argument*/NULL);
if (L_51)
{
goto IL_011c;
}
}
{
return (bool)0;
}
IL_01a3:
{
bool L_52 = __this->get_fIsReentrant_0();
if (!L_52)
{
goto IL_01ca;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_53 = V_1;
bool L_54 = ReaderWriterLockSlim_IsRwHashEntryChanged_m0224E239675EDC26497D7097C004AAC052561AF0(__this, L_53, /*hidden argument*/NULL);
if (!L_54)
{
goto IL_01bc;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_55 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)0, /*hidden argument*/NULL);
V_1 = L_55;
}
IL_01bc:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_56 = V_1;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_57 = L_56;
NullCheck(L_57);
int32_t L_58 = L_57->get_upgradecount_3();
NullCheck(L_57);
L_57->set_upgradecount_3(((int32_t)il2cpp_codegen_add((int32_t)L_58, (int32_t)1)));
}
IL_01ca:
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
return (bool)1;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::ExitReadLock()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ExitReadLock_m7DF8D92A2E02017583EB8DB8380E61933ADAEE37 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ReaderWriterLockSlim_ExitReadLock_m7DF8D92A2E02017583EB8DB8380E61933ADAEE37_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * V_0 = NULL;
{
V_0 = (ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 *)NULL;
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_0 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)1, /*hidden argument*/NULL);
V_0 = L_0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_1 = V_0;
if (!L_1)
{
goto IL_001c;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_2 = V_0;
NullCheck(L_2);
int32_t L_3 = L_2->get_readercount_1();
if ((((int32_t)L_3) >= ((int32_t)1)))
{
goto IL_0032;
}
}
IL_001c:
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
String_t* L_4 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteralFF1C30AC5539B024798DA89177C788C04C382338, /*hidden argument*/NULL);
SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 * L_5 = (SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 *)il2cpp_codegen_object_new(SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4_il2cpp_TypeInfo_var);
SynchronizationLockException__ctor_m2D56EA848D40CF87417BFD4BE6426C39C6873FE9(L_5, L_4, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_5, NULL, ReaderWriterLockSlim_ExitReadLock_m7DF8D92A2E02017583EB8DB8380E61933ADAEE37_RuntimeMethod_var);
}
IL_0032:
{
bool L_6 = __this->get_fIsReentrant_0();
if (!L_6)
{
goto IL_0071;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_7 = V_0;
NullCheck(L_7);
int32_t L_8 = L_7->get_readercount_1();
if ((((int32_t)L_8) <= ((int32_t)1)))
{
goto IL_0058;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_9 = V_0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_10 = L_9;
NullCheck(L_10);
int32_t L_11 = L_10->get_readercount_1();
NullCheck(L_10);
L_10->set_readercount_1(((int32_t)il2cpp_codegen_subtract((int32_t)L_11, (int32_t)1)));
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
return;
}
IL_0058:
{
Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * L_12 = Thread_get_CurrentThread_mB7A83CAE2B9A74CEA053196DFD1AF1E7AB30A70E(/*hidden argument*/NULL);
NullCheck(L_12);
int32_t L_13 = Thread_get_ManagedThreadId_m7FA85162CB00713B94EF5708B19120F791D3AAD1(L_12, /*hidden argument*/NULL);
int32_t L_14 = __this->get_upgradeLockOwnerId_7();
if ((!(((uint32_t)L_13) == ((uint32_t)L_14))))
{
goto IL_0071;
}
}
{
__this->set_fUpgradeThreadHoldingRead_16((bool)0);
}
IL_0071:
{
uint32_t L_15 = __this->get_owners_17();
__this->set_owners_17(((int32_t)il2cpp_codegen_subtract((int32_t)L_15, (int32_t)1)));
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_16 = V_0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_17 = L_16;
NullCheck(L_17);
int32_t L_18 = L_17->get_readercount_1();
NullCheck(L_17);
L_17->set_readercount_1(((int32_t)il2cpp_codegen_subtract((int32_t)L_18, (int32_t)1)));
ReaderWriterLockSlim_ExitAndWakeUpAppropriateWaiters_mBE16B41DDB40A7F5016EA873CD9F9CA0A42D9386(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::ExitWriteLock()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ExitWriteLock_mE1E51CB12C3C895C5EB5CF0D42854A476502EAB3 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ReaderWriterLockSlim_ExitWriteLock_mE1E51CB12C3C895C5EB5CF0D42854A476502EAB3_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * G_B6_0 = NULL;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * G_B5_0 = NULL;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * G_B8_0 = NULL;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * G_B7_0 = NULL;
{
bool L_0 = __this->get_fIsReentrant_0();
if (L_0)
{
goto IL_0032;
}
}
{
Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * L_1 = Thread_get_CurrentThread_mB7A83CAE2B9A74CEA053196DFD1AF1E7AB30A70E(/*hidden argument*/NULL);
NullCheck(L_1);
int32_t L_2 = Thread_get_ManagedThreadId_m7FA85162CB00713B94EF5708B19120F791D3AAD1(L_1, /*hidden argument*/NULL);
int32_t L_3 = __this->get_writeLockOwnerId_8();
if ((((int32_t)L_2) == ((int32_t)L_3)))
{
goto IL_002a;
}
}
{
String_t* L_4 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteralB4F59191955C7D4FEB657A298BB9D296BE7E3278, /*hidden argument*/NULL);
SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 * L_5 = (SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 *)il2cpp_codegen_object_new(SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4_il2cpp_TypeInfo_var);
SynchronizationLockException__ctor_m2D56EA848D40CF87417BFD4BE6426C39C6873FE9(L_5, L_4, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_5, NULL, ReaderWriterLockSlim_ExitWriteLock_mE1E51CB12C3C895C5EB5CF0D42854A476502EAB3_RuntimeMethod_var);
}
IL_002a:
{
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
goto IL_0094;
}
IL_0032:
{
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_6 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)0, /*hidden argument*/NULL);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_7 = L_6;
G_B5_0 = L_7;
if (L_7)
{
G_B6_0 = L_7;
goto IL_0058;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
String_t* L_8 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteralB4F59191955C7D4FEB657A298BB9D296BE7E3278, /*hidden argument*/NULL);
SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 * L_9 = (SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 *)il2cpp_codegen_object_new(SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4_il2cpp_TypeInfo_var);
SynchronizationLockException__ctor_m2D56EA848D40CF87417BFD4BE6426C39C6873FE9(L_9, L_8, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_9, NULL, ReaderWriterLockSlim_ExitWriteLock_mE1E51CB12C3C895C5EB5CF0D42854A476502EAB3_RuntimeMethod_var);
}
IL_0058:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_10 = G_B6_0;
NullCheck(L_10);
int32_t L_11 = L_10->get_writercount_2();
G_B7_0 = L_10;
if ((((int32_t)L_11) >= ((int32_t)1)))
{
G_B8_0 = L_10;
goto IL_0077;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
String_t* L_12 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteralB4F59191955C7D4FEB657A298BB9D296BE7E3278, /*hidden argument*/NULL);
SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 * L_13 = (SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 *)il2cpp_codegen_object_new(SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4_il2cpp_TypeInfo_var);
SynchronizationLockException__ctor_m2D56EA848D40CF87417BFD4BE6426C39C6873FE9(L_13, L_12, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_13, NULL, ReaderWriterLockSlim_ExitWriteLock_mE1E51CB12C3C895C5EB5CF0D42854A476502EAB3_RuntimeMethod_var);
}
IL_0077:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_14 = G_B8_0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_15 = L_14;
NullCheck(L_15);
int32_t L_16 = L_15->get_writercount_2();
NullCheck(L_15);
L_15->set_writercount_2(((int32_t)il2cpp_codegen_subtract((int32_t)L_16, (int32_t)1)));
NullCheck(L_14);
int32_t L_17 = L_14->get_writercount_2();
if ((((int32_t)L_17) <= ((int32_t)0)))
{
goto IL_0094;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
return;
}
IL_0094:
{
ReaderWriterLockSlim_ClearWriterAcquired_m7D23840004AFD1C1C3A23C608590807D84844038(__this, /*hidden argument*/NULL);
__this->set_writeLockOwnerId_8((-1));
ReaderWriterLockSlim_ExitAndWakeUpAppropriateWaiters_mBE16B41DDB40A7F5016EA873CD9F9CA0A42D9386(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::ExitUpgradeableReadLock()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ExitUpgradeableReadLock_m4B7266ABD40B93FED0664E00B6AD371B69CBC471 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ReaderWriterLockSlim_ExitUpgradeableReadLock_m4B7266ABD40B93FED0664E00B6AD371B69CBC471_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * G_B6_0 = NULL;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * G_B5_0 = NULL;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * G_B8_0 = NULL;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * G_B7_0 = NULL;
{
bool L_0 = __this->get_fIsReentrant_0();
if (L_0)
{
goto IL_0032;
}
}
{
Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * L_1 = Thread_get_CurrentThread_mB7A83CAE2B9A74CEA053196DFD1AF1E7AB30A70E(/*hidden argument*/NULL);
NullCheck(L_1);
int32_t L_2 = Thread_get_ManagedThreadId_m7FA85162CB00713B94EF5708B19120F791D3AAD1(L_1, /*hidden argument*/NULL);
int32_t L_3 = __this->get_upgradeLockOwnerId_7();
if ((((int32_t)L_2) == ((int32_t)L_3)))
{
goto IL_002a;
}
}
{
String_t* L_4 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteralDAA18AA61E2D46E829CB9DF89DCA6C1C54E91FDC, /*hidden argument*/NULL);
SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 * L_5 = (SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 *)il2cpp_codegen_object_new(SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4_il2cpp_TypeInfo_var);
SynchronizationLockException__ctor_m2D56EA848D40CF87417BFD4BE6426C39C6873FE9(L_5, L_4, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_5, NULL, ReaderWriterLockSlim_ExitUpgradeableReadLock_m4B7266ABD40B93FED0664E00B6AD371B69CBC471_RuntimeMethod_var);
}
IL_002a:
{
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
goto IL_009b;
}
IL_0032:
{
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_6 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)1, /*hidden argument*/NULL);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_7 = L_6;
G_B5_0 = L_7;
if (L_7)
{
G_B6_0 = L_7;
goto IL_0058;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
String_t* L_8 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteralDAA18AA61E2D46E829CB9DF89DCA6C1C54E91FDC, /*hidden argument*/NULL);
SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 * L_9 = (SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 *)il2cpp_codegen_object_new(SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4_il2cpp_TypeInfo_var);
SynchronizationLockException__ctor_m2D56EA848D40CF87417BFD4BE6426C39C6873FE9(L_9, L_8, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_9, NULL, ReaderWriterLockSlim_ExitUpgradeableReadLock_m4B7266ABD40B93FED0664E00B6AD371B69CBC471_RuntimeMethod_var);
}
IL_0058:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_10 = G_B6_0;
NullCheck(L_10);
int32_t L_11 = L_10->get_upgradecount_3();
G_B7_0 = L_10;
if ((((int32_t)L_11) >= ((int32_t)1)))
{
G_B8_0 = L_10;
goto IL_0077;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
String_t* L_12 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteralDAA18AA61E2D46E829CB9DF89DCA6C1C54E91FDC, /*hidden argument*/NULL);
SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 * L_13 = (SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 *)il2cpp_codegen_object_new(SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4_il2cpp_TypeInfo_var);
SynchronizationLockException__ctor_m2D56EA848D40CF87417BFD4BE6426C39C6873FE9(L_13, L_12, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_13, NULL, ReaderWriterLockSlim_ExitUpgradeableReadLock_m4B7266ABD40B93FED0664E00B6AD371B69CBC471_RuntimeMethod_var);
}
IL_0077:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_14 = G_B8_0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_15 = L_14;
NullCheck(L_15);
int32_t L_16 = L_15->get_upgradecount_3();
NullCheck(L_15);
L_15->set_upgradecount_3(((int32_t)il2cpp_codegen_subtract((int32_t)L_16, (int32_t)1)));
NullCheck(L_14);
int32_t L_17 = L_14->get_upgradecount_3();
if ((((int32_t)L_17) <= ((int32_t)0)))
{
goto IL_0094;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
return;
}
IL_0094:
{
__this->set_fUpgradeThreadHoldingRead_16((bool)0);
}
IL_009b:
{
uint32_t L_18 = __this->get_owners_17();
__this->set_owners_17(((int32_t)il2cpp_codegen_subtract((int32_t)L_18, (int32_t)1)));
__this->set_upgradeLockOwnerId_7((-1));
ReaderWriterLockSlim_ExitAndWakeUpAppropriateWaiters_mBE16B41DDB40A7F5016EA873CD9F9CA0A42D9386(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::LazyCreateEvent(System.Threading.EventWaitHandle&,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_LazyCreateEvent_mF1FB4CDE744ADC2CADEE4F020F095896E1C64D1A (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 ** ___waitEvent0, bool ___makeAutoResetEvent1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ReaderWriterLockSlim_LazyCreateEvent_mF1FB4CDE744ADC2CADEE4F020F095896E1C64D1A_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * V_0 = NULL;
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
bool L_0 = ___makeAutoResetEvent1;
if (!L_0)
{
goto IL_0012;
}
}
{
AutoResetEvent_t2A1182CEEE4E184587D4DEAA4F382B810B21D3B7 * L_1 = (AutoResetEvent_t2A1182CEEE4E184587D4DEAA4F382B810B21D3B7 *)il2cpp_codegen_object_new(AutoResetEvent_t2A1182CEEE4E184587D4DEAA4F382B810B21D3B7_il2cpp_TypeInfo_var);
AutoResetEvent__ctor_m2A6F4D44E005E07021957D5134037747AE9890BE(L_1, (bool)0, /*hidden argument*/NULL);
V_0 = L_1;
goto IL_0019;
}
IL_0012:
{
ManualResetEvent_tDFAF117B200ECA4CCF4FD09593F949A016D55408 * L_2 = (ManualResetEvent_tDFAF117B200ECA4CCF4FD09593F949A016D55408 *)il2cpp_codegen_object_new(ManualResetEvent_tDFAF117B200ECA4CCF4FD09593F949A016D55408_il2cpp_TypeInfo_var);
ManualResetEvent__ctor_m8973D9E3C622B9602641C017A33870F51D0311E1(L_2, (bool)0, /*hidden argument*/NULL);
V_0 = L_2;
}
IL_0019:
{
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 ** L_3 = ___waitEvent0;
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_4 = *((EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 **)L_3);
if (L_4)
{
goto IL_0027;
}
}
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 ** L_5 = ___waitEvent0;
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_6 = V_0;
*((RuntimeObject **)L_5) = (RuntimeObject *)L_6;
Il2CppCodeGenWriteBarrier((void**)(RuntimeObject **)L_5, (void*)(RuntimeObject *)L_6);
return;
}
IL_0027:
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_7 = V_0;
NullCheck(L_7);
VirtActionInvoker0::Invoke(13 /* System.Void System.Threading.WaitHandle::Close() */, L_7);
return;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::WaitOnEvent(System.Threading.EventWaitHandle,System.UInt32&,System.Threading.ReaderWriterLockSlim_TimeoutTracker,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_WaitOnEvent_mE15EA3B2BB1C0145C6014F71F635FA5AECC0CD7F (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * ___waitEvent0, uint32_t* ___numWaiters1, TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 ___timeout2, bool ___isWriteWaiter3, const RuntimeMethod* method)
{
bool V_0 = false;
Exception_t * __last_unhandled_exception = 0;
NO_UNUSED_WARNING (__last_unhandled_exception);
Exception_t * __exception_local = 0;
NO_UNUSED_WARNING (__exception_local);
void* __leave_targets_storage = alloca(sizeof(int32_t) * 1);
il2cpp::utils::LeaveTargetStack __leave_targets(__leave_targets_storage);
NO_UNUSED_WARNING (__leave_targets);
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_0 = ___waitEvent0;
NullCheck(L_0);
EventWaitHandle_Reset_m59EBCEA32BC9C67B4E432BEA5FF0A42ED0CC8A6F(L_0, /*hidden argument*/NULL);
uint32_t* L_1 = ___numWaiters1;
uint32_t* L_2 = ___numWaiters1;
int32_t L_3 = *((uint32_t*)L_2);
*((int32_t*)L_1) = (int32_t)((int32_t)il2cpp_codegen_add((int32_t)L_3, (int32_t)1));
__this->set_fNoWaiters_6((bool)0);
uint32_t L_4 = __this->get_numWriteWaiters_2();
if ((!(((uint32_t)L_4) == ((uint32_t)1))))
{
goto IL_0023;
}
}
{
ReaderWriterLockSlim_SetWritersWaiting_m0DBD0499833C2CEFF3E1EC14503FB3B729D15DCD(__this, /*hidden argument*/NULL);
}
IL_0023:
{
uint32_t L_5 = __this->get_numWriteUpgradeWaiters_4();
if ((!(((uint32_t)L_5) == ((uint32_t)1))))
{
goto IL_0032;
}
}
{
ReaderWriterLockSlim_SetUpgraderWaiting_m90CBDB7726E59B974200EADFC3B9ADB2504E8B90(__this, /*hidden argument*/NULL);
}
IL_0032:
{
V_0 = (bool)0;
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
}
IL_003a:
try
{ // begin try (depth: 1)
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_6 = ___waitEvent0;
int32_t L_7 = TimeoutTracker_get_RemainingMilliseconds_mAF2F88DCCD1A056E00EF12AA334C9561D962A17C((TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 *)(&___timeout2), /*hidden argument*/NULL);
NullCheck(L_6);
bool L_8 = VirtFuncInvoker1< bool, int32_t >::Invoke(11 /* System.Boolean System.Threading.WaitHandle::WaitOne(System.Int32) */, L_6, L_7);
V_0 = L_8;
IL2CPP_LEAVE(0xAF, FINALLY_004a);
} // end try (depth: 1)
catch(Il2CppExceptionWrapper& e)
{
__last_unhandled_exception = (Exception_t *)e.ex;
goto FINALLY_004a;
}
FINALLY_004a:
{ // begin finally (depth: 1)
{
ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline(__this, /*hidden argument*/NULL);
uint32_t* L_9 = ___numWaiters1;
uint32_t* L_10 = ___numWaiters1;
int32_t L_11 = *((uint32_t*)L_10);
*((int32_t*)L_9) = (int32_t)((int32_t)il2cpp_codegen_subtract((int32_t)L_11, (int32_t)1));
uint32_t L_12 = __this->get_numWriteWaiters_2();
if (L_12)
{
goto IL_007d;
}
}
IL_005e:
{
uint32_t L_13 = __this->get_numWriteUpgradeWaiters_4();
if (L_13)
{
goto IL_007d;
}
}
IL_0066:
{
uint32_t L_14 = __this->get_numUpgradeWaiters_5();
if (L_14)
{
goto IL_007d;
}
}
IL_006e:
{
uint32_t L_15 = __this->get_numReadWaiters_3();
if (L_15)
{
goto IL_007d;
}
}
IL_0076:
{
__this->set_fNoWaiters_6((bool)1);
}
IL_007d:
{
uint32_t L_16 = __this->get_numWriteWaiters_2();
if (L_16)
{
goto IL_008b;
}
}
IL_0085:
{
ReaderWriterLockSlim_ClearWritersWaiting_m2BE83552E3E49933AB3CB472B166655D456B8184(__this, /*hidden argument*/NULL);
}
IL_008b:
{
uint32_t L_17 = __this->get_numWriteUpgradeWaiters_4();
if (L_17)
{
goto IL_0099;
}
}
IL_0093:
{
ReaderWriterLockSlim_ClearUpgraderWaiting_m1AC4F6CCAA86849911DFCC0A8907FDA9FBA2EFBD(__this, /*hidden argument*/NULL);
}
IL_0099:
{
bool L_18 = V_0;
if (L_18)
{
goto IL_00ae;
}
}
IL_009c:
{
bool L_19 = ___isWriteWaiter3;
if (!L_19)
{
goto IL_00a8;
}
}
IL_00a0:
{
ReaderWriterLockSlim_ExitAndWakeUpAppropriateReadWaiters_m3010FADED458384F9E926BF6CF27AF16ACD7987A(__this, /*hidden argument*/NULL);
goto IL_00ae;
}
IL_00a8:
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
}
IL_00ae:
{
IL2CPP_END_FINALLY(74)
}
} // end finally (depth: 1)
IL2CPP_CLEANUP(74)
{
IL2CPP_JUMP_TBL(0xAF, IL_00af)
IL2CPP_RETHROW_IF_UNHANDLED(Exception_t *)
}
IL_00af:
{
bool L_20 = V_0;
return L_20;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::ExitAndWakeUpAppropriateWaiters()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ExitAndWakeUpAppropriateWaiters_mBE16B41DDB40A7F5016EA873CD9F9CA0A42D9386 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
bool L_0 = __this->get_fNoWaiters_6();
if (!L_0)
{
goto IL_000f;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
return;
}
IL_000f:
{
ReaderWriterLockSlim_ExitAndWakeUpAppropriateWaitersPreferringWriters_mB76632D7385923BA08EDEE6854A65311FC323DFC(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::ExitAndWakeUpAppropriateWaitersPreferringWriters()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ExitAndWakeUpAppropriateWaitersPreferringWriters_mB76632D7385923BA08EDEE6854A65311FC323DFC (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
uint32_t V_0 = 0;
{
uint32_t L_0 = ReaderWriterLockSlim_GetNumReaders_m677B71BAF98B757FB32C4F0EB7D6E240E6D1A2B1(__this, /*hidden argument*/NULL);
V_0 = L_0;
bool L_1 = __this->get_fIsReentrant_0();
if (!L_1)
{
goto IL_0037;
}
}
{
uint32_t L_2 = __this->get_numWriteUpgradeWaiters_4();
if ((!(((uint32_t)L_2) > ((uint32_t)0))))
{
goto IL_0037;
}
}
{
bool L_3 = __this->get_fUpgradeThreadHoldingRead_16();
if (!L_3)
{
goto IL_0037;
}
}
{
uint32_t L_4 = V_0;
if ((!(((uint32_t)L_4) == ((uint32_t)2))))
{
goto IL_0037;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_5 = __this->get_waitUpgradeEvent_12();
NullCheck(L_5);
EventWaitHandle_Set_m7959A86A39735296FC949EC86FDA42A6CFAAB94C(L_5, /*hidden argument*/NULL);
return;
}
IL_0037:
{
uint32_t L_6 = V_0;
if ((!(((uint32_t)L_6) == ((uint32_t)1))))
{
goto IL_0057;
}
}
{
uint32_t L_7 = __this->get_numWriteUpgradeWaiters_4();
if ((!(((uint32_t)L_7) > ((uint32_t)0))))
{
goto IL_0057;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_8 = __this->get_waitUpgradeEvent_12();
NullCheck(L_8);
EventWaitHandle_Set_m7959A86A39735296FC949EC86FDA42A6CFAAB94C(L_8, /*hidden argument*/NULL);
return;
}
IL_0057:
{
uint32_t L_9 = V_0;
if (L_9)
{
goto IL_0076;
}
}
{
uint32_t L_10 = __this->get_numWriteWaiters_2();
if ((!(((uint32_t)L_10) > ((uint32_t)0))))
{
goto IL_0076;
}
}
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_11 = __this->get_writeEvent_9();
NullCheck(L_11);
EventWaitHandle_Set_m7959A86A39735296FC949EC86FDA42A6CFAAB94C(L_11, /*hidden argument*/NULL);
return;
}
IL_0076:
{
ReaderWriterLockSlim_ExitAndWakeUpAppropriateReadWaiters_m3010FADED458384F9E926BF6CF27AF16ACD7987A(__this, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::ExitAndWakeUpAppropriateReadWaiters()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ExitAndWakeUpAppropriateReadWaiters_m3010FADED458384F9E926BF6CF27AF16ACD7987A (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
bool V_0 = false;
int32_t G_B7_0 = 0;
int32_t G_B9_0 = 0;
int32_t G_B8_0 = 0;
{
uint32_t L_0 = __this->get_numWriteWaiters_2();
if (L_0)
{
goto IL_0018;
}
}
{
uint32_t L_1 = __this->get_numWriteUpgradeWaiters_4();
if (L_1)
{
goto IL_0018;
}
}
{
bool L_2 = __this->get_fNoWaiters_6();
if (!L_2)
{
goto IL_001f;
}
}
IL_0018:
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
return;
}
IL_001f:
{
uint32_t L_3 = __this->get_numReadWaiters_3();
V_0 = (bool)((!(((uint32_t)L_3) <= ((uint32_t)0)))? 1 : 0);
uint32_t L_4 = __this->get_numUpgradeWaiters_5();
if (!L_4)
{
goto IL_003c;
}
}
{
int32_t L_5 = __this->get_upgradeLockOwnerId_7();
G_B7_0 = ((((int32_t)L_5) == ((int32_t)(-1)))? 1 : 0);
goto IL_003d;
}
IL_003c:
{
G_B7_0 = 0;
}
IL_003d:
{
ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB(__this, /*hidden argument*/NULL);
bool L_6 = V_0;
G_B8_0 = G_B7_0;
if (!L_6)
{
G_B9_0 = G_B7_0;
goto IL_0052;
}
}
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_7 = __this->get_readEvent_10();
NullCheck(L_7);
EventWaitHandle_Set_m7959A86A39735296FC949EC86FDA42A6CFAAB94C(L_7, /*hidden argument*/NULL);
G_B9_0 = G_B8_0;
}
IL_0052:
{
if (!G_B9_0)
{
goto IL_0060;
}
}
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_8 = __this->get_upgradeEvent_11();
NullCheck(L_8);
EventWaitHandle_Set_m7959A86A39735296FC949EC86FDA42A6CFAAB94C(L_8, /*hidden argument*/NULL);
}
IL_0060:
{
return;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::IsWriterAcquired()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_IsWriterAcquired_m0FC58A2B2697A2911D5C76D4D51E758ED006E3DD (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = __this->get_owners_17();
return (bool)((((int32_t)((int32_t)((int32_t)L_0&(int32_t)((int32_t)-1073741825)))) == ((int32_t)0))? 1 : 0);
}
}
// System.Void System.Threading.ReaderWriterLockSlim::SetWriterAcquired()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_SetWriterAcquired_mA707D12FB8981C8B7BA215DC0E912EF063CB215B (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = __this->get_owners_17();
__this->set_owners_17(((int32_t)((int32_t)L_0|(int32_t)((int32_t)-2147483648LL))));
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::ClearWriterAcquired()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ClearWriterAcquired_m7D23840004AFD1C1C3A23C608590807D84844038 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = __this->get_owners_17();
__this->set_owners_17(((int32_t)((int32_t)L_0&(int32_t)((int32_t)2147483647LL))));
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::SetWritersWaiting()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_SetWritersWaiting_m0DBD0499833C2CEFF3E1EC14503FB3B729D15DCD (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = __this->get_owners_17();
__this->set_owners_17(((int32_t)((int32_t)L_0|(int32_t)((int32_t)1073741824))));
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::ClearWritersWaiting()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ClearWritersWaiting_m2BE83552E3E49933AB3CB472B166655D456B8184 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = __this->get_owners_17();
__this->set_owners_17(((int32_t)((int32_t)L_0&(int32_t)((int32_t)-1073741825))));
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::SetUpgraderWaiting()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_SetUpgraderWaiting_m90CBDB7726E59B974200EADFC3B9ADB2504E8B90 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = __this->get_owners_17();
__this->set_owners_17(((int32_t)((int32_t)L_0|(int32_t)((int32_t)536870912))));
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::ClearUpgraderWaiting()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ClearUpgraderWaiting_m1AC4F6CCAA86849911DFCC0A8907FDA9FBA2EFBD (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = __this->get_owners_17();
__this->set_owners_17(((int32_t)((int32_t)L_0&(int32_t)((int32_t)-536870913))));
return;
}
}
// System.UInt32 System.Threading.ReaderWriterLockSlim::GetNumReaders()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t ReaderWriterLockSlim_GetNumReaders_m677B71BAF98B757FB32C4F0EB7D6E240E6D1A2B1 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = __this->get_owners_17();
return ((int32_t)((int32_t)L_0&(int32_t)((int32_t)268435455)));
}
}
// System.Void System.Threading.ReaderWriterLockSlim::EnterMyLock()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
int32_t* L_0 = __this->get_address_of_myLock_1();
int32_t L_1 = Interlocked_CompareExchange_mD830160E95D6C589AD31EE9DC8D19BD4A8DCDC03((int32_t*)L_0, 1, 0, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_0015;
}
}
{
ReaderWriterLockSlim_EnterMyLockSpin_m6799FA31434367D4A953F8E65ACE11E6FBD2994D(__this, /*hidden argument*/NULL);
}
IL_0015:
{
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::EnterMyLockSpin()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_EnterMyLockSpin_m6799FA31434367D4A953F8E65ACE11E6FBD2994D (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
int32_t V_1 = 0;
{
int32_t L_0 = Environment_get_ProcessorCount_m086119F1D40B7319BFC37F4501C6A73517E9B8CD(/*hidden argument*/NULL);
V_0 = L_0;
V_1 = 0;
}
IL_0008:
{
int32_t L_1 = V_1;
if ((((int32_t)L_1) >= ((int32_t)((int32_t)10))))
{
goto IL_001e;
}
}
{
int32_t L_2 = V_0;
if ((((int32_t)L_2) <= ((int32_t)1)))
{
goto IL_001e;
}
}
{
int32_t L_3 = V_1;
Thread_SpinWait_m78B41D34DB11B07C0E7776FD3150DFB10AC63BB4(((int32_t)il2cpp_codegen_multiply((int32_t)((int32_t)20), (int32_t)((int32_t)il2cpp_codegen_add((int32_t)L_3, (int32_t)1)))), /*hidden argument*/NULL);
goto IL_0031;
}
IL_001e:
{
int32_t L_4 = V_1;
if ((((int32_t)L_4) >= ((int32_t)((int32_t)15))))
{
goto IL_002b;
}
}
{
Thread_Sleep_m2CD320EAB7BE02CC1F395EAFE9970D53A5F9EAEF(0, /*hidden argument*/NULL);
goto IL_0031;
}
IL_002b:
{
Thread_Sleep_m2CD320EAB7BE02CC1F395EAFE9970D53A5F9EAEF(1, /*hidden argument*/NULL);
}
IL_0031:
{
int32_t L_5 = __this->get_myLock_1();
if (L_5)
{
goto IL_0049;
}
}
{
int32_t* L_6 = __this->get_address_of_myLock_1();
int32_t L_7 = Interlocked_CompareExchange_mD830160E95D6C589AD31EE9DC8D19BD4A8DCDC03((int32_t*)L_6, 1, 0, /*hidden argument*/NULL);
if (L_7)
{
goto IL_0049;
}
}
{
return;
}
IL_0049:
{
int32_t L_8 = V_1;
V_1 = ((int32_t)il2cpp_codegen_add((int32_t)L_8, (int32_t)1));
goto IL_0008;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::ExitMyLock()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_ExitMyLock_mE4313FE0D855FF69C84BB9BC4DCBB42ACF61B3EB (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
int32_t* L_0 = __this->get_address_of_myLock_1();
VolatileWrite((int32_t*)L_0, 0);
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::SpinWait(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_SpinWait_m326D5ADB06292AEB146FCB7D577AA19E63C8A9EA (int32_t ___SpinCount0, const RuntimeMethod* method)
{
{
int32_t L_0 = ___SpinCount0;
if ((((int32_t)L_0) >= ((int32_t)5)))
{
goto IL_0016;
}
}
{
int32_t L_1 = Environment_get_ProcessorCount_m086119F1D40B7319BFC37F4501C6A73517E9B8CD(/*hidden argument*/NULL);
if ((((int32_t)L_1) <= ((int32_t)1)))
{
goto IL_0016;
}
}
{
int32_t L_2 = ___SpinCount0;
Thread_SpinWait_m78B41D34DB11B07C0E7776FD3150DFB10AC63BB4(((int32_t)il2cpp_codegen_multiply((int32_t)((int32_t)20), (int32_t)L_2)), /*hidden argument*/NULL);
return;
}
IL_0016:
{
int32_t L_3 = ___SpinCount0;
if ((((int32_t)L_3) >= ((int32_t)((int32_t)17))))
{
goto IL_0022;
}
}
{
Thread_Sleep_m2CD320EAB7BE02CC1F395EAFE9970D53A5F9EAEF(0, /*hidden argument*/NULL);
return;
}
IL_0022:
{
Thread_Sleep_m2CD320EAB7BE02CC1F395EAFE9970D53A5F9EAEF(1, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::Dispose()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_Dispose_m174D87039E0638A5766AED6677E975693C17D278 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
ReaderWriterLockSlim_Dispose_m227307FAFA9FC458348241A75B6FCEF94CC63A29(__this, (bool)1, /*hidden argument*/NULL);
return;
}
}
// System.Void System.Threading.ReaderWriterLockSlim::Dispose(System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_Dispose_m227307FAFA9FC458348241A75B6FCEF94CC63A29 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, bool ___disposing0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ReaderWriterLockSlim_Dispose_m227307FAFA9FC458348241A75B6FCEF94CC63A29_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
bool L_0 = ___disposing0;
if (!L_0)
{
goto IL_00d3;
}
}
{
bool L_1 = __this->get_fDisposed_18();
if (L_1)
{
goto IL_00d3;
}
}
{
int32_t L_2 = ReaderWriterLockSlim_get_WaitingReadCount_mA544945C581A791EAC1AC80C3BA1CCEFC2CF7113_inline(__this, /*hidden argument*/NULL);
if ((((int32_t)L_2) > ((int32_t)0)))
{
goto IL_002c;
}
}
{
int32_t L_3 = ReaderWriterLockSlim_get_WaitingUpgradeCount_mDA59AE0658A70FCC5A3F0A7CC2BFC065C2A6BAD2_inline(__this, /*hidden argument*/NULL);
if ((((int32_t)L_3) > ((int32_t)0)))
{
goto IL_002c;
}
}
{
int32_t L_4 = ReaderWriterLockSlim_get_WaitingWriteCount_m7233838329221BC82DB7E52D6F510BE82B6DC0AD_inline(__this, /*hidden argument*/NULL);
if ((((int32_t)L_4) <= ((int32_t)0)))
{
goto IL_003c;
}
}
IL_002c:
{
String_t* L_5 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteral5F28FB22DC8DFDC53D50B181C7DCB2A4029CE2ED, /*hidden argument*/NULL);
SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 * L_6 = (SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 *)il2cpp_codegen_object_new(SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4_il2cpp_TypeInfo_var);
SynchronizationLockException__ctor_m2D56EA848D40CF87417BFD4BE6426C39C6873FE9(L_6, L_5, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_6, NULL, ReaderWriterLockSlim_Dispose_m227307FAFA9FC458348241A75B6FCEF94CC63A29_RuntimeMethod_var);
}
IL_003c:
{
bool L_7 = ReaderWriterLockSlim_get_IsReadLockHeld_m1831FFFB370170F6C65F2294A7F134DADB9C5296(__this, /*hidden argument*/NULL);
if (L_7)
{
goto IL_0054;
}
}
{
bool L_8 = ReaderWriterLockSlim_get_IsUpgradeableReadLockHeld_m9AFAD1A28F90A22D9DD55D1F7C0AE4D7901F01DD(__this, /*hidden argument*/NULL);
if (L_8)
{
goto IL_0054;
}
}
{
bool L_9 = ReaderWriterLockSlim_get_IsWriteLockHeld_m799A737B0616EE50CB3EF51D02F64945E1EE8E6A(__this, /*hidden argument*/NULL);
if (!L_9)
{
goto IL_0064;
}
}
IL_0054:
{
String_t* L_10 = SR_GetString_m0D34A4798D653D11FFC8F27A24C741A83A3DA90B(_stringLiteral5F28FB22DC8DFDC53D50B181C7DCB2A4029CE2ED, /*hidden argument*/NULL);
SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 * L_11 = (SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4 *)il2cpp_codegen_object_new(SynchronizationLockException_tF7171C6D19DE436F50DC40B3F453EFC83CB116D4_il2cpp_TypeInfo_var);
SynchronizationLockException__ctor_m2D56EA848D40CF87417BFD4BE6426C39C6873FE9(L_11, L_10, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_11, NULL, ReaderWriterLockSlim_Dispose_m227307FAFA9FC458348241A75B6FCEF94CC63A29_RuntimeMethod_var);
}
IL_0064:
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_12 = __this->get_writeEvent_9();
if (!L_12)
{
goto IL_007e;
}
}
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_13 = __this->get_writeEvent_9();
NullCheck(L_13);
VirtActionInvoker0::Invoke(13 /* System.Void System.Threading.WaitHandle::Close() */, L_13);
__this->set_writeEvent_9((EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 *)NULL);
}
IL_007e:
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_14 = __this->get_readEvent_10();
if (!L_14)
{
goto IL_0098;
}
}
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_15 = __this->get_readEvent_10();
NullCheck(L_15);
VirtActionInvoker0::Invoke(13 /* System.Void System.Threading.WaitHandle::Close() */, L_15);
__this->set_readEvent_10((EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 *)NULL);
}
IL_0098:
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_16 = __this->get_upgradeEvent_11();
if (!L_16)
{
goto IL_00b2;
}
}
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_17 = __this->get_upgradeEvent_11();
NullCheck(L_17);
VirtActionInvoker0::Invoke(13 /* System.Void System.Threading.WaitHandle::Close() */, L_17);
__this->set_upgradeEvent_11((EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 *)NULL);
}
IL_00b2:
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_18 = __this->get_waitUpgradeEvent_12();
if (!L_18)
{
goto IL_00cc;
}
}
{
EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 * L_19 = __this->get_waitUpgradeEvent_12();
NullCheck(L_19);
VirtActionInvoker0::Invoke(13 /* System.Void System.Threading.WaitHandle::Close() */, L_19);
__this->set_waitUpgradeEvent_12((EventWaitHandle_t7603BF1D3D30FE42DD07A450C8D09E2684DC4D98 *)NULL);
}
IL_00cc:
{
__this->set_fDisposed_18((bool)1);
}
IL_00d3:
{
return;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::get_IsReadLockHeld()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_get_IsReadLockHeld_m1831FFFB370170F6C65F2294A7F134DADB9C5296 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = ReaderWriterLockSlim_get_RecursiveReadCount_mE6BA1143A18149878ED16D6BB21118F741A73AE9(__this, /*hidden argument*/NULL);
if ((((int32_t)L_0) <= ((int32_t)0)))
{
goto IL_000b;
}
}
{
return (bool)1;
}
IL_000b:
{
return (bool)0;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::get_IsUpgradeableReadLockHeld()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_get_IsUpgradeableReadLockHeld_m9AFAD1A28F90A22D9DD55D1F7C0AE4D7901F01DD (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = ReaderWriterLockSlim_get_RecursiveUpgradeCount_m65397E248826F5D1D67C056F7DC428FF13BB0801(__this, /*hidden argument*/NULL);
if ((((int32_t)L_0) <= ((int32_t)0)))
{
goto IL_000b;
}
}
{
return (bool)1;
}
IL_000b:
{
return (bool)0;
}
}
// System.Boolean System.Threading.ReaderWriterLockSlim::get_IsWriteLockHeld()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_get_IsWriteLockHeld_m799A737B0616EE50CB3EF51D02F64945E1EE8E6A (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = ReaderWriterLockSlim_get_RecursiveWriteCount_m3EB437BB407DA44B1B5932E5AD958101F4FBC1E3(__this, /*hidden argument*/NULL);
if ((((int32_t)L_0) <= ((int32_t)0)))
{
goto IL_000b;
}
}
{
return (bool)1;
}
IL_000b:
{
return (bool)0;
}
}
// System.Int32 System.Threading.ReaderWriterLockSlim::get_RecursiveReadCount()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_RecursiveReadCount_mE6BA1143A18149878ED16D6BB21118F741A73AE9 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * V_1 = NULL;
{
V_0 = 0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_0 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)1, /*hidden argument*/NULL);
V_1 = L_0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_1 = V_1;
if (!L_1)
{
goto IL_0014;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_2 = V_1;
NullCheck(L_2);
int32_t L_3 = L_2->get_readercount_1();
V_0 = L_3;
}
IL_0014:
{
int32_t L_4 = V_0;
return L_4;
}
}
// System.Int32 System.Threading.ReaderWriterLockSlim::get_RecursiveUpgradeCount()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_RecursiveUpgradeCount_m65397E248826F5D1D67C056F7DC428FF13BB0801 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * V_1 = NULL;
{
bool L_0 = __this->get_fIsReentrant_0();
if (!L_0)
{
goto IL_001e;
}
}
{
V_0 = 0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_1 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)1, /*hidden argument*/NULL);
V_1 = L_1;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_2 = V_1;
if (!L_2)
{
goto IL_001c;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_3 = V_1;
NullCheck(L_3);
int32_t L_4 = L_3->get_upgradecount_3();
V_0 = L_4;
}
IL_001c:
{
int32_t L_5 = V_0;
return L_5;
}
IL_001e:
{
Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * L_6 = Thread_get_CurrentThread_mB7A83CAE2B9A74CEA053196DFD1AF1E7AB30A70E(/*hidden argument*/NULL);
NullCheck(L_6);
int32_t L_7 = Thread_get_ManagedThreadId_m7FA85162CB00713B94EF5708B19120F791D3AAD1(L_6, /*hidden argument*/NULL);
int32_t L_8 = __this->get_upgradeLockOwnerId_7();
if ((!(((uint32_t)L_7) == ((uint32_t)L_8))))
{
goto IL_0032;
}
}
{
return 1;
}
IL_0032:
{
return 0;
}
}
// System.Int32 System.Threading.ReaderWriterLockSlim::get_RecursiveWriteCount()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_RecursiveWriteCount_m3EB437BB407DA44B1B5932E5AD958101F4FBC1E3 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * V_1 = NULL;
{
bool L_0 = __this->get_fIsReentrant_0();
if (!L_0)
{
goto IL_001e;
}
}
{
V_0 = 0;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_1 = ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline(__this, (bool)1, /*hidden argument*/NULL);
V_1 = L_1;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_2 = V_1;
if (!L_2)
{
goto IL_001c;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_3 = V_1;
NullCheck(L_3);
int32_t L_4 = L_3->get_writercount_2();
V_0 = L_4;
}
IL_001c:
{
int32_t L_5 = V_0;
return L_5;
}
IL_001e:
{
Thread_tF60E0A146CD3B5480CB65FF9B6016E84C5460CC7 * L_6 = Thread_get_CurrentThread_mB7A83CAE2B9A74CEA053196DFD1AF1E7AB30A70E(/*hidden argument*/NULL);
NullCheck(L_6);
int32_t L_7 = Thread_get_ManagedThreadId_m7FA85162CB00713B94EF5708B19120F791D3AAD1(L_6, /*hidden argument*/NULL);
int32_t L_8 = __this->get_writeLockOwnerId_8();
if ((!(((uint32_t)L_7) == ((uint32_t)L_8))))
{
goto IL_0032;
}
}
{
return 1;
}
IL_0032:
{
return 0;
}
}
// System.Int32 System.Threading.ReaderWriterLockSlim::get_WaitingReadCount()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_WaitingReadCount_mA544945C581A791EAC1AC80C3BA1CCEFC2CF7113 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = __this->get_numReadWaiters_3();
return L_0;
}
}
// System.Int32 System.Threading.ReaderWriterLockSlim::get_WaitingUpgradeCount()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_WaitingUpgradeCount_mDA59AE0658A70FCC5A3F0A7CC2BFC065C2A6BAD2 (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = __this->get_numUpgradeWaiters_5();
return L_0;
}
}
// System.Int32 System.Threading.ReaderWriterLockSlim::get_WaitingWriteCount()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_WaitingWriteCount_m7233838329221BC82DB7E52D6F510BE82B6DC0AD (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = __this->get_numWriteWaiters_2();
return L_0;
}
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Void System.Threading.ReaderWriterLockSlim_TimeoutTracker::.ctor(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TimeoutTracker__ctor_m2238A5B6D938E911C2F7742E5A90E1E670F570F9 (TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 * __this, int32_t ___millisecondsTimeout0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (TimeoutTracker__ctor_m2238A5B6D938E911C2F7742E5A90E1E670F570F9_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
{
int32_t L_0 = ___millisecondsTimeout0;
if ((((int32_t)L_0) >= ((int32_t)(-1))))
{
goto IL_000f;
}
}
{
ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA * L_1 = (ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA *)il2cpp_codegen_object_new(ArgumentOutOfRangeException_t94D19DF918A54511AEDF4784C9A08741BAD1DEDA_il2cpp_TypeInfo_var);
ArgumentOutOfRangeException__ctor_m6B36E60C989DC798A8B44556DB35960282B133A6(L_1, _stringLiteral9D9BED981884AC3D4D16BF22ED725A5686CEF15B, /*hidden argument*/NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, NULL, TimeoutTracker__ctor_m2238A5B6D938E911C2F7742E5A90E1E670F570F9_RuntimeMethod_var);
}
IL_000f:
{
int32_t L_2 = ___millisecondsTimeout0;
__this->set_m_total_0(L_2);
int32_t L_3 = __this->get_m_total_0();
if ((((int32_t)L_3) == ((int32_t)(-1))))
{
goto IL_0033;
}
}
{
int32_t L_4 = __this->get_m_total_0();
if (!L_4)
{
goto IL_0033;
}
}
{
int32_t L_5 = Environment_get_TickCount_m0A119BE4354EA90C82CC48E559588C987A79FE0C(/*hidden argument*/NULL);
__this->set_m_start_1(L_5);
return;
}
IL_0033:
{
__this->set_m_start_1(0);
return;
}
}
IL2CPP_EXTERN_C void TimeoutTracker__ctor_m2238A5B6D938E911C2F7742E5A90E1E670F570F9_AdjustorThunk (RuntimeObject * __this, int32_t ___millisecondsTimeout0, const RuntimeMethod* method)
{
TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 * _thisAdjusted = reinterpret_cast<TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 *>(__this + 1);
TimeoutTracker__ctor_m2238A5B6D938E911C2F7742E5A90E1E670F570F9(_thisAdjusted, ___millisecondsTimeout0, method);
}
// System.Int32 System.Threading.ReaderWriterLockSlim_TimeoutTracker::get_RemainingMilliseconds()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t TimeoutTracker_get_RemainingMilliseconds_mAF2F88DCCD1A056E00EF12AA334C9561D962A17C (TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 * __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0 = __this->get_m_total_0();
if ((((int32_t)L_0) == ((int32_t)(-1))))
{
goto IL_0011;
}
}
{
int32_t L_1 = __this->get_m_total_0();
if (L_1)
{
goto IL_0018;
}
}
IL_0011:
{
int32_t L_2 = __this->get_m_total_0();
return L_2;
}
IL_0018:
{
int32_t L_3 = Environment_get_TickCount_m0A119BE4354EA90C82CC48E559588C987A79FE0C(/*hidden argument*/NULL);
int32_t L_4 = __this->get_m_start_1();
V_0 = ((int32_t)il2cpp_codegen_subtract((int32_t)L_3, (int32_t)L_4));
int32_t L_5 = V_0;
if ((((int32_t)L_5) < ((int32_t)0)))
{
goto IL_0032;
}
}
{
int32_t L_6 = V_0;
int32_t L_7 = __this->get_m_total_0();
if ((((int32_t)L_6) < ((int32_t)L_7)))
{
goto IL_0034;
}
}
IL_0032:
{
return 0;
}
IL_0034:
{
int32_t L_8 = __this->get_m_total_0();
int32_t L_9 = V_0;
return ((int32_t)il2cpp_codegen_subtract((int32_t)L_8, (int32_t)L_9));
}
}
IL2CPP_EXTERN_C int32_t TimeoutTracker_get_RemainingMilliseconds_mAF2F88DCCD1A056E00EF12AA334C9561D962A17C_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 * _thisAdjusted = reinterpret_cast<TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 *>(__this + 1);
return TimeoutTracker_get_RemainingMilliseconds_mAF2F88DCCD1A056E00EF12AA334C9561D962A17C(_thisAdjusted, method);
}
// System.Boolean System.Threading.ReaderWriterLockSlim_TimeoutTracker::get_IsExpired()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool TimeoutTracker_get_IsExpired_m3A2BF7A380901450677142E2863EB14A28B3EE85 (TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = TimeoutTracker_get_RemainingMilliseconds_mAF2F88DCCD1A056E00EF12AA334C9561D962A17C((TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 *)__this, /*hidden argument*/NULL);
return (bool)((((int32_t)L_0) == ((int32_t)0))? 1 : 0);
}
}
IL2CPP_EXTERN_C bool TimeoutTracker_get_IsExpired_m3A2BF7A380901450677142E2863EB14A28B3EE85_AdjustorThunk (RuntimeObject * __this, const RuntimeMethod* method)
{
TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 * _thisAdjusted = reinterpret_cast<TimeoutTracker_tCA78DF023D40CEBEECD0E2E4281B2D2F8FFBF757 *>(__this + 1);
return TimeoutTracker_get_IsExpired_m3A2BF7A380901450677142E2863EB14A28B3EE85(_thisAdjusted, method);
}
#ifdef __clang__
#pragma clang diagnostic pop
#endif
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR int32_t SymmetricAlgorithm_get_KeySize_m416638119C768C838536FDC5FAD652478F3EC18E_inline (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get_KeySizeValue_6();
return L_0;
}
}
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR int32_t SymmetricAlgorithm_get_FeedbackSize_mD2DEAC30A2684A4CC725A592D7301265EE979FE0_inline (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get_FeedbackSizeValue_1();
return L_0;
}
}
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR int32_t SymmetricAlgorithm_get_Mode_m782D8A5FAC8271F3FAF6689DDDD4E9B1D15A685D_inline (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get_ModeValue_7();
return L_0;
}
}
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR int32_t SymmetricAlgorithm_get_Padding_mD308D61BEA3783A6BC49FBF5E4A8A3C6F9BB61F8_inline (SymmetricAlgorithm_t0A2EC7E7AD8B8976832B4F0AC432B691F862E789 * __this, const RuntimeMethod* method)
{
{
int32_t L_0 = __this->get_PaddingValue_8();
return L_0;
}
}
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR bool ReaderWriterLockSlim_IsRWEntryEmpty_m81FB0780C065C2D3ADF7662E8C89938FF86596B9_inline (ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * ___rwc0, const RuntimeMethod* method)
{
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_0 = ___rwc0;
NullCheck(L_0);
int64_t L_1 = L_0->get_lockID_0();
if (L_1)
{
goto IL_000a;
}
}
{
return (bool)1;
}
IL_000a:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_2 = ___rwc0;
NullCheck(L_2);
int32_t L_3 = L_2->get_readercount_1();
if (L_3)
{
goto IL_0024;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_4 = ___rwc0;
NullCheck(L_4);
int32_t L_5 = L_4->get_writercount_2();
if (L_5)
{
goto IL_0024;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_6 = ___rwc0;
NullCheck(L_6);
int32_t L_7 = L_6->get_upgradecount_3();
if (L_7)
{
goto IL_0024;
}
}
{
return (bool)1;
}
IL_0024:
{
return (bool)0;
}
}
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR void ReaderWriterLockSlim_EnterMyLock_mB0B89B1A47E4420D5AA4E6C066CE16E8ACD6F2B9_inline (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
int32_t* L_0 = __this->get_address_of_myLock_1();
int32_t L_1 = Interlocked_CompareExchange_mD830160E95D6C589AD31EE9DC8D19BD4A8DCDC03((int32_t*)L_0, 1, 0, /*hidden argument*/NULL);
if (!L_1)
{
goto IL_0015;
}
}
{
ReaderWriterLockSlim_EnterMyLockSpin_m6799FA31434367D4A953F8E65ACE11E6FBD2994D(__this, /*hidden argument*/NULL);
}
IL_0015:
{
return;
}
}
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAF_inline (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, bool ___dontAllocate0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_method (ReaderWriterLockSlim_GetThreadRWCount_m2D3B63C0FE14EC28C34081A8115D8094D0FD3AAFSystem_Core_MetadataUsageId);
s_Il2CppMethodInitialized = true;
}
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * V_0 = NULL;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * V_1 = NULL;
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_0 = ((ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_ThreadStaticFields*)il2cpp_codegen_get_thread_static_data(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_il2cpp_TypeInfo_var))->get_t_rwc_15();
V_0 = L_0;
V_1 = (ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 *)NULL;
goto IL_0031;
}
IL_000a:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_1 = V_0;
NullCheck(L_1);
int64_t L_2 = L_1->get_lockID_0();
int64_t L_3 = __this->get_lockID_14();
if ((!(((uint64_t)L_2) == ((uint64_t)L_3))))
{
goto IL_001a;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_4 = V_0;
return L_4;
}
IL_001a:
{
bool L_5 = ___dontAllocate0;
if (L_5)
{
goto IL_002a;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_6 = V_1;
if (L_6)
{
goto IL_002a;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_7 = V_0;
bool L_8 = ReaderWriterLockSlim_IsRWEntryEmpty_m81FB0780C065C2D3ADF7662E8C89938FF86596B9_inline(L_7, /*hidden argument*/NULL);
if (!L_8)
{
goto IL_002a;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_9 = V_0;
V_1 = L_9;
}
IL_002a:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_10 = V_0;
NullCheck(L_10);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_11 = L_10->get_next_4();
V_0 = L_11;
}
IL_0031:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_12 = V_0;
if (L_12)
{
goto IL_000a;
}
}
{
bool L_13 = ___dontAllocate0;
if (!L_13)
{
goto IL_0039;
}
}
{
return (ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 *)NULL;
}
IL_0039:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_14 = V_1;
if (L_14)
{
goto IL_0053;
}
}
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_15 = (ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 *)il2cpp_codegen_object_new(ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900_il2cpp_TypeInfo_var);
ReaderWriterCount__ctor_m1BBD3EB1DFD5837AE05A5B72DB01657C1546C0EF(L_15, /*hidden argument*/NULL);
V_1 = L_15;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_16 = V_1;
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_17 = ((ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_ThreadStaticFields*)il2cpp_codegen_get_thread_static_data(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_il2cpp_TypeInfo_var))->get_t_rwc_15();
NullCheck(L_16);
L_16->set_next_4(L_17);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_18 = V_1;
((ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_ThreadStaticFields*)il2cpp_codegen_get_thread_static_data(ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315_il2cpp_TypeInfo_var))->set_t_rwc_15(L_18);
}
IL_0053:
{
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_19 = V_1;
int64_t L_20 = __this->get_lockID_14();
NullCheck(L_19);
L_19->set_lockID_0(L_20);
ReaderWriterCount_t92B1A4E2431BE1A833DACA5E9781B04A56D97900 * L_21 = V_1;
return L_21;
}
}
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_WaitingReadCount_mA544945C581A791EAC1AC80C3BA1CCEFC2CF7113_inline (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = __this->get_numReadWaiters_3();
return L_0;
}
}
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_WaitingUpgradeCount_mDA59AE0658A70FCC5A3F0A7CC2BFC065C2A6BAD2_inline (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = __this->get_numUpgradeWaiters_5();
return L_0;
}
}
IL2CPP_EXTERN_C inline IL2CPP_METHOD_ATTR int32_t ReaderWriterLockSlim_get_WaitingWriteCount_m7233838329221BC82DB7E52D6F510BE82B6DC0AD_inline (ReaderWriterLockSlim_tD820AC67812C645B2F8C16ABB4DE694A19D6A315 * __this, const RuntimeMethod* method)
{
{
uint32_t L_0 = __this->get_numWriteWaiters_2();
return L_0;
}
}
| [
"Jamesc890116@gmail.com"
] | Jamesc890116@gmail.com |
6394097fcdc63a642563eab0e800313f1fc08cb5 | 45ad4c55007bf7d94f60e14a636fe3d8eca5e5d0 | /operation.cc | 9445b018418461cf1322b232e93644fd6e42acd6 | [
"LicenseRef-scancode-public-domain"
] | permissive | rg3/cifras | 1504a8482b9dadaf7550036aa44f98ea6e4dc05b | b967696a71e9f9c2f9f130367269892f7f2d9261 | refs/heads/master | 2023-07-07T11:16:34.554743 | 2009-09-28T20:47:59 | 2009-09-28T20:47:59 | 173,350 | 8 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 343 | cc | /*
* Author: Ricardo Garcia Gonzalez
* License: Public domain code
*/
#include <iostream>
#include <limits>
#include "operation.h"
using std::ostream;
// Output a given operation.
ostream &operator<<(ostream &out, const Operation &op)
{
return out << op.left() << ' ' << op.opchar() << ' ' << op.right()
<< " = " << op.result();
}
| [
"rg3@deckard.bladerunner"
] | rg3@deckard.bladerunner |
66efb9d0203216e26e4321b3c399eebec572553b | 152f13462437d042efab568e514d4ab6c1e182ee | /DirectUI/Control/UILabel.cpp | da1c216ad791168ac0f5a737fb6756d2e827db46 | [] | no_license | ZhouchaoAlbert/MiniQQ | fc900290482e700dd2908529b37cd44f2e28ed1d | 387540f24ec7467c3908cadd6445acf91365e97b | refs/heads/master | 2020-09-16T22:03:40.879243 | 2018-02-25T09:46:43 | 2018-02-25T09:46:43 | 66,358,640 | 4 | 1 | null | null | null | null | GB18030 | C++ | false | false | 17,296 | cpp | #include "StdAfx.h"
#include "UILabel.h"
#include <atlconv.h>
namespace DuiLib
{
//Color _MakeRGB(int a, Color cl)
//{
// return Color(a, cl.GetR(), cl.GetG(), cl.GetB());
//}
//Color _MakeRGB(int r, int g, int b)
//{
// return Color(255, r, g, b);
//}
CLabelUI::CLabelUI() : m_uTextStyle(DT_VCENTER | DT_SINGLELINE), m_dwTextColor(0),
m_dwDisabledTextColor(0),
m_iFont(-1),
m_bShowHtml(false),
m_EnableEffect(false),
m_gdiplusToken(0),
//m_TextRenderingHintAntiAlias(TextRenderingHintSystemDefault),
m_TransShadow(60),
m_TransText(168),
m_TransShadow1(60),
m_TransText1(168),
m_hAlign(DT_LEFT),
m_vAlign(DT_CENTER),
m_dwTextColor1(-1),
m_dwTextShadowColorA(0xff000000),
m_dwTextShadowColorB(-1),
m_GradientAngle(0),
m_EnabledStroke(false),
m_TransStroke(255),
m_dwStrokeColor(0),
m_bAutoCalcWidth(false),
m_EnabledShadow(false),
m_GradientLength(0)
{
//m_ShadowOffset.X = 0.0f;
//m_ShadowOffset.Y = 0.0f;
//m_ShadowOffset.Width = 0.0f;
//m_ShadowOffset.Height = 0.0f;
//GdiplusStartup( &m_gdiplusToken,&m_gdiplusStartupInput, NULL);
::ZeroMemory(&m_rcTextPadding, sizeof(m_rcTextPadding));
}
CLabelUI::~CLabelUI()
{
// GdiplusShutdown( m_gdiplusToken );
}
LPCTSTR CLabelUI::GetClass() const
{
return _T("LabelUI");
}
LPVOID CLabelUI::GetInterface(LPCTSTR pstrName)
{
if( _tcscmp(pstrName, _T("Label")) == 0 ) return static_cast<CLabelUI*>(this);
return CControlUI::GetInterface(pstrName);
}
void CLabelUI::SetTextStyle(UINT uStyle)
{
m_uTextStyle = uStyle;
Invalidate();
}
UINT CLabelUI::GetTextStyle() const
{
return m_uTextStyle;
}
void CLabelUI::SetTextColor(DWORD dwTextColor)
{
m_dwTextColor = dwTextColor;
Invalidate();
}
DWORD CLabelUI::GetTextColor() const
{
return m_dwTextColor;
}
void CLabelUI::SetDisabledTextColor(DWORD dwTextColor)
{
m_dwDisabledTextColor = dwTextColor;
Invalidate();
}
DWORD CLabelUI::GetDisabledTextColor() const
{
return m_dwDisabledTextColor;
}
void CLabelUI::SetFont(int index)
{
m_iFont = index;
Invalidate();
}
int CLabelUI::GetFont() const
{
return m_iFont;
}
RECT CLabelUI::GetTextPadding() const
{
return m_rcTextPadding;
}
void CLabelUI::SetTextPadding(RECT rc)
{
m_rcTextPadding = rc;
Invalidate();
}
bool CLabelUI::IsShowHtml()
{
return m_bShowHtml;
}
void CLabelUI::SetShowHtml(bool bShowHtml)
{
if( m_bShowHtml == bShowHtml ) return;
m_bShowHtml = bShowHtml;
Invalidate();
}
SIZE CLabelUI::EstimateSize(SIZE szAvailable)
{
if (m_bAutoCalcWidth)
{
RECT rcText = {0};
CRenderEngine::DrawText(m_pManager->GetPaintDC(), m_pManager, rcText, m_sText, m_dwTextColor, m_iFont, DT_CALCRECT | m_uTextStyle);
m_cxyFixed.cx = rcText.right - rcText.left + m_rcTextPadding.left + m_rcTextPadding.right;
}
if( m_cxyFixed.cy == 0 ) return CSize(m_cxyFixed.cx, m_pManager->GetFontInfo(GetFont())->tm.tmHeight + 4);
return CControlUI::EstimateSize(szAvailable);
}
void CLabelUI::DoEvent(TEventUI& event)
{
if( event.Type == UIEVENT_SETFOCUS )
{
m_bFocused = true;
return;
}
if( event.Type == UIEVENT_KILLFOCUS )
{
m_bFocused = false;
return;
}
if( event.Type == UIEVENT_MOUSEENTER )
{
// return;
}
if( event.Type == UIEVENT_MOUSELEAVE )
{
// return;
}
CControlUI::DoEvent(event);
}
void CLabelUI::SetAttribute(LPCTSTR pstrName, LPCTSTR pstrValue)
{
if( _tcscmp(pstrName, _T("align")) == 0 ) {
if( _tcsstr(pstrValue, _T("left")) != NULL ) {
m_uTextStyle &= ~(DT_CENTER | DT_RIGHT | DT_SINGLELINE);
m_uTextStyle |= DT_LEFT;
}
if( _tcsstr(pstrValue, _T("center")) != NULL ) {
m_uTextStyle &= ~(DT_LEFT | DT_RIGHT );
m_uTextStyle |= DT_CENTER;
}
if( _tcsstr(pstrValue, _T("right")) != NULL ) {
m_uTextStyle &= ~(DT_LEFT | DT_CENTER | DT_SINGLELINE);
m_uTextStyle |= DT_RIGHT;
}
}
else if( _tcscmp(pstrName, _T("valign")) == 0 ) {
if( _tcsstr(pstrValue, _T("top")) != NULL ) {
m_uTextStyle &= ~(DT_BOTTOM | DT_VCENTER);
m_uTextStyle |= (DT_TOP | DT_SINGLELINE);
}
if( _tcsstr(pstrValue, _T("vcenter")) != NULL ) {
m_uTextStyle &= ~(DT_TOP | DT_BOTTOM );
m_uTextStyle |= (DT_VCENTER | DT_SINGLELINE);
}
if( _tcsstr(pstrValue, _T("bottom")) != NULL ) {
m_uTextStyle &= ~(DT_TOP | DT_VCENTER);
m_uTextStyle |= (DT_BOTTOM | DT_SINGLELINE);
}
}
else if( _tcscmp(pstrName, _T("endellipsis")) == 0 ) {
if( _tcscmp(pstrValue, _T("true")) == 0 ) m_uTextStyle |= DT_END_ELLIPSIS;
else m_uTextStyle &= ~DT_END_ELLIPSIS;
}
else if( _tcscmp(pstrName, _T("wordbreak")) == 0 ) {
if( _tcscmp(pstrValue, _T("true")) == 0 ) {
m_uTextStyle &= ~DT_SINGLELINE;
m_uTextStyle |= DT_WORDBREAK | DT_EDITCONTROL;
}
else {
m_uTextStyle &= ~DT_WORDBREAK & ~DT_EDITCONTROL;
m_uTextStyle |= DT_SINGLELINE;
}
}
else if( _tcscmp(pstrName, _T("font")) == 0 ) SetFont(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("textcolor")) == 0 ) {
if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
LPTSTR pstr = NULL;
DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
SetTextColor(clrColor);
}
else if( _tcscmp(pstrName, _T("disabledtextcolor")) == 0 ) {
if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
LPTSTR pstr = NULL;
DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
SetDisabledTextColor(clrColor);
}
else if( _tcscmp(pstrName, _T("textpadding")) == 0 ) {
RECT rcTextPadding = { 0 };
LPTSTR pstr = NULL;
rcTextPadding.left = _tcstol(pstrValue, &pstr, 10); ASSERT(pstr);
rcTextPadding.top = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
rcTextPadding.right = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
rcTextPadding.bottom = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
SetTextPadding(rcTextPadding);
}
else if( _tcscmp(pstrName, _T("showhtml")) == 0 ) SetShowHtml(_tcscmp(pstrValue, _T("true")) == 0);
else if( _tcscmp(pstrName, _T("enabledeffect")) == 0 ) SetEnabledEffect(_tcscmp(pstrValue, _T("true")) == 0);
//else if( _tcscmp(pstrName, _T("rhaa")) == 0 ) SetTextRenderingHintAntiAlias(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("transshadow")) == 0 ) SetTransShadow(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("transtext")) == 0 ) SetTransText(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("transshadow1")) == 0 ) SetTransShadow1(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("transtext1")) == 0 ) SetTransText1(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("gradientangle")) == 0 ) SetGradientAngle(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("enabledstroke")) == 0 ) SetEnabledStroke(_tcscmp(pstrValue, _T("true")) == 0);
else if( _tcscmp(pstrName, _T("enabledshadow")) == 0 ) SetEnabledShadow(_tcscmp(pstrValue, _T("true")) == 0);
else if( _tcscmp(pstrName, _T("transstroke")) == 0 ) SetTransStroke(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("gradientlength")) == 0 ) SetGradientLength(_ttoi(pstrValue));
else if( _tcscmp(pstrName, _T("shadowoffset")) == 0 ){
LPTSTR pstr = NULL;
int offsetx = _tcstol(pstrValue, &pstr, 10); ASSERT(pstr);
int offsety = _tcstol(pstr + 1, &pstr, 10); ASSERT(pstr);
SetShadowOffset(offsetx,offsety);
}
else if( _tcscmp(pstrName, _T("textcolor1")) == 0 ) {
if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
LPTSTR pstr = NULL;
DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
SetTextColor1(clrColor);
}
else if( _tcscmp(pstrName, _T("textshadowcolora")) == 0 ) {
if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
LPTSTR pstr = NULL;
DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
SetTextShadowColorA(clrColor);
}
else if( _tcscmp(pstrName, _T("textshadowcolorb")) == 0 ) {
if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
LPTSTR pstr = NULL;
DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
SetTextShadowColorB(clrColor);
}
else if( _tcscmp(pstrName, _T("strokecolor")) == 0 ) {
if( *pstrValue == _T('#')) pstrValue = ::CharNext(pstrValue);
LPTSTR pstr = NULL;
DWORD clrColor = _tcstoul(pstrValue, &pstr, 16);
SetStrokeColor(clrColor);
}
else if( _tcscmp(pstrName, _T("autocalcwidth")) == 0 ) {
SetAutoCalcWidth(_tcscmp(pstrValue, _T("true")) == 0);
}
else CControlUI::SetAttribute(pstrName, pstrValue);
}
void CLabelUI::PaintText(HDC hDC)
{
if( m_dwTextColor == 0 ) m_dwTextColor = m_pManager->GetDefaultFontColor();
if( m_dwDisabledTextColor == 0 ) m_dwDisabledTextColor = m_pManager->GetDefaultDisabledColor();
RECT rc = m_rcItem;
rc.left += m_rcTextPadding.left;
rc.right -= m_rcTextPadding.right;
rc.top += m_rcTextPadding.top;
rc.bottom -= m_rcTextPadding.bottom;
if(!GetEnabledEffect())
{
if( m_sText.IsEmpty() ) return;
int nLinks = 0;
if( IsEnabled() ) {
if( m_bShowHtml )
CRenderEngine::DrawHtmlText(hDC, m_pManager, rc, m_sText, m_dwTextColor, \
NULL, NULL, nLinks, DT_SINGLELINE | m_uTextStyle);
else
CRenderEngine::DrawText(hDC, m_pManager, rc, m_sText, m_dwTextColor, \
m_iFont, DT_SINGLELINE | m_uTextStyle);
}
else {
if( m_bShowHtml )
CRenderEngine::DrawHtmlText(hDC, m_pManager, rc, m_sText, m_dwDisabledTextColor, \
NULL, NULL, nLinks, DT_SINGLELINE | m_uTextStyle);
else
CRenderEngine::DrawText(hDC, m_pManager, rc, m_sText, m_dwDisabledTextColor, \
m_iFont, DT_SINGLELINE | m_uTextStyle);
}
}
else
{
//不使用GDI+，不使用特效
ASSERT(FALSE);
}
// else
// {
// Font nFont(hDC,m_pManager->GetFont(GetFont()));
//
// Graphics nGraphics(hDC);
// nGraphics.SetTextRenderingHint(m_TextRenderingHintAntiAlias);
//
// StringFormat format;
// format.SetAlignment((StringAlignment)m_hAlign);
// format.SetLineAlignment((StringAlignment)m_vAlign);
//
// RectF nRc((float)rc.left,(float)rc.top,(float)rc.right-rc.left,(float)rc.bottom-rc.top);
// RectF nShadowRc = nRc;
// nShadowRc.X += m_ShadowOffset.X;
// nShadowRc.Y += m_ShadowOffset.Y;
//
// int nGradientLength = GetGradientLength();
//
// if(nGradientLength == 0)
// nGradientLength = (rc.bottom-rc.top);
//
// LinearGradientBrush nLineGrBrushA(Point(GetGradientAngle(), 0),Point(0,nGradientLength),_MakeRGB(GetTransShadow(),GetTextShadowColorA()),_MakeRGB(GetTransShadow1(),GetTextShadowColorB() == -1?GetTextShadowColorA():GetTextShadowColorB()));
// LinearGradientBrush nLineGrBrushB(Point(GetGradientAngle(), 0),Point(0,nGradientLength),_MakeRGB(GetTransText(),GetTextColor()),_MakeRGB(GetTransText1(),GetTextColor1() == -1?GetTextColor():GetTextColor1()));
//
// if(GetEnabledStroke() && GetStrokeColor() > 0)
// {
// LinearGradientBrush nLineGrBrushStroke(Point(GetGradientAngle(),0),Point(0,rc.bottom-rc.top+2),_MakeRGB(GetTransStroke(),GetStrokeColor()),_MakeRGB(GetTransStroke(),GetStrokeColor()));
//
//#ifdef _UNICODE
// nRc.Offset(-1,0);
// nGraphics.DrawString(m_TextValue,m_TextValue.GetLength(),&nFont,nRc,&format,&nLineGrBrushStroke);
// nRc.Offset(2,0);
// nGraphics.DrawString(m_TextValue,m_TextValue.GetLength(),&nFont,nRc,&format,&nLineGrBrushStroke);
// nRc.Offset(-1,-1);
// nGraphics.DrawString(m_TextValue,m_TextValue.GetLength(),&nFont,nRc,&format,&nLineGrBrushStroke);
// nRc.Offset(0,2);
// nGraphics.DrawString(m_TextValue,m_TextValue.GetLength(),&nFont,nRc,&format,&nLineGrBrushStroke);
// nRc.Offset(0,-1);
//#else
// USES_CONVERSION;
// wstring mTextValue = A2W(m_TextValue.GetData());
//
// nRc.Offset(-1,0);
// nGraphics.DrawString(mTextValue.c_str(),mTextValue.length(),&nFont,nRc,&format,&nLineGrBrushStroke);
// nRc.Offset(2,0);
// nGraphics.DrawString(mTextValue.c_str(),mTextValue.length(),&nFont,nRc,&format,&nLineGrBrushStroke);
// nRc.Offset(-1,-1);
// nGraphics.DrawString(mTextValue.c_str(),mTextValue.length(),&nFont,nRc,&format,&nLineGrBrushStroke);
// nRc.Offset(0,2);
// nGraphics.DrawString(mTextValue.c_str(),mTextValue.length(),&nFont,nRc,&format,&nLineGrBrushStroke);
// nRc.Offset(0,-1);
//#endif
//
// }
//#ifdef _UNICODE
// if(GetEnabledShadow() && (GetTextShadowColorA() > 0 || GetTextShadowColorB() > 0))
// nGraphics.DrawString(m_TextValue,m_TextValue.GetLength(),&nFont,nShadowRc,&format,&nLineGrBrushA);
//
// nGraphics.DrawString(m_TextValue,m_TextValue.GetLength(),&nFont,nRc,&format,&nLineGrBrushB);
//#else
// USES_CONVERSION;
// wstring mTextValue = A2W(m_TextValue.GetData());
//
// if(GetEnabledShadow() && (GetTextShadowColorA() > 0 || GetTextShadowColorB() > 0))
// nGraphics.DrawString(mTextValue.c_str(),mTextValue.length(),&nFont,nShadowRc,&format,&nLineGrBrushA);
//
// nGraphics.DrawString(mTextValue.c_str(),mTextValue.length(),&nFont,nRc,&format,&nLineGrBrushB);
//#endif
//
// }
}
bool CLabelUI::GetAutoCalcWidth() const
{
return m_bAutoCalcWidth;
}
void CLabelUI::SetAutoCalcWidth(bool bAutoCalcWidth)
{
m_bAutoCalcWidth = bAutoCalcWidth;
}
void CLabelUI::SetTransShadow( int _TransShadow )
{
m_TransShadow = _TransShadow;
}
int CLabelUI::GetTransShadow()
{
return m_TransShadow;
}
//void CLabelUI::SetTextRenderingHintAntiAlias( int _TextRenderingHintAntiAlias )
//{
// if(_TextRenderingHintAntiAlias < 0 || _TextRenderingHintAntiAlias > 5)
// _TextRenderingHintAntiAlias = 0;
// m_TextRenderingHintAntiAlias = (TextRenderingHint)_TextRenderingHintAntiAlias;
//}
//int CLabelUI::GetTextRenderingHintAntiAlias()
//{
// return m_TextRenderingHintAntiAlias;
//}
void CLabelUI::SetShadowOffset( int _offset,int _angle )
{
if(_angle > 180 || _angle < -180)
return;
RECT rc = m_rcItem;
if(_angle >= 0 && _angle <= 180)
rc.top -= _offset;
else if(_angle > -180 && _angle < 0)
rc.top += _offset;
if(_angle > -90 && _angle <= 90)
rc.left -= _offset;
else if( _angle > 90 || _angle < -90)
rc.left += _offset;
//m_ShadowOffset.X = (float)rc.top;
//m_ShadowOffset.Y = (float)rc.left;
}
//RectF CLabelUI::GetShadowOffset()
//{
// return m_ShadowOffset;
//}
void CLabelUI::SetText( LPCTSTR pstrText )
{
if(!GetEnabledEffect())
return CControlUI::SetText(pstrText);
m_TextValue = pstrText;
}
CDuiString CLabelUI::GetText() const
{
if(!m_EnableEffect)
return CControlUI::GetText();
return m_TextValue;
}
void CLabelUI::SetEnabledEffect( bool _EnabledEffect )
{
m_EnableEffect = _EnabledEffect;
}
bool CLabelUI::GetEnabledEffect()
{
return m_EnableEffect;
}
void CLabelUI::SetTextColor1( DWORD _TextColor1 )
{
m_dwTextColor1 = _TextColor1;
}
DWORD CLabelUI::GetTextColor1()
{
return m_dwTextColor1;
}
void CLabelUI::SetTextShadowColorA( DWORD _TextShadowColorA )
{
m_dwTextShadowColorA = _TextShadowColorA;
}
DWORD CLabelUI::GetTextShadowColorA()
{
return m_dwTextShadowColorA;
}
void CLabelUI::SetTextShadowColorB( DWORD _TextShadowColorB )
{
m_dwTextShadowColorB = _TextShadowColorB;
}
DWORD CLabelUI::GetTextShadowColorB()
{
return m_dwTextShadowColorB;
}
void CLabelUI::SetTransText( int _TransText )
{
m_TransText = _TransText;
}
int CLabelUI::GetTransText()
{
return m_TransText;
}
void CLabelUI::SetTransShadow1( int _TransShadow )
{
m_TransShadow1 = _TransShadow;
}
int CLabelUI::GetTransShadow1()
{
return m_TransShadow1;
}
void CLabelUI::SetTransText1( int _TransText )
{
m_TransText1 = _TransText;
}
int CLabelUI::GetTransText1()
{
return m_TransText1;
}
void CLabelUI::SetGradientAngle( int _SetGradientAngle )
{
m_GradientAngle = _SetGradientAngle;
}
int CLabelUI::GetGradientAngle()
{
return m_GradientAngle;
}
void CLabelUI::SetEnabledStroke( bool _EnabledStroke )
{
m_EnabledStroke = _EnabledStroke;
}
bool CLabelUI::GetEnabledStroke()
{
return m_EnabledStroke;
}
void CLabelUI::SetTransStroke( int _TransStroke )
{
m_TransStroke = _TransStroke;
}
int CLabelUI::GetTransStroke()
{
return m_TransStroke;
}
void CLabelUI::SetStrokeColor( DWORD _StrokeColor )
{
m_dwStrokeColor = _StrokeColor;
}
DWORD CLabelUI::GetStrokeColor()
{
return m_dwStrokeColor;
}
void CLabelUI::SetEnabledShadow( bool _EnabledShadowe )
{
m_EnabledShadow = _EnabledShadowe;
}
bool CLabelUI::GetEnabledShadow()
{
return m_EnabledShadow;
}
void CLabelUI::SetGradientLength( int _GradientLength )
{
m_GradientLength = _GradientLength;
}
int CLabelUI::GetGradientLength()
{
return m_GradientLength;
}
} | [
"838944042@qq.com"
] | 838944042@qq.com |
b4db0c49233eba1d1a992415c24d138cfb782f03 | f43543ac545c96daf74ee763e7fb1497f7ddf309 | /Chapter10/ass4_sale.h | 931874c36bfd62b2c42cbfc4479dd92cdd7b84f9 | [] | no_license | Cyrus07/Cpp_pp | bb272e5fbdb100ade2aba4c268c0abd6072e4601 | 89450593a63bdc70ec9bf648e3a250e9e0e0f71c | refs/heads/master | 2021-01-10T17:38:26.006926 | 2016-01-07T14:36:24 | 2016-01-07T14:36:24 | 48,879,960 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 321 | h | #ifndef SALES_H_
#define SALES_H_
namespace SALES
{
class Sales
{
private:
enum {QUARTERS = 4};
double sales[QUARTERS];
double average;
double max;
double min;
public:
Sales(const double ar[], int n);
Sales();
double Average();
double Max();
double Min();
void Show();
};
}
#endif
| [
"teamworkhlc@gmail.com"
] | teamworkhlc@gmail.com |
918d6866f46508d0337dc0398f87618b20e66d09 | d2789aadcbc3197696618a1603fb10963cc4a01c | /guerrero.cpp | efd568f15774c26346665c4fbd9ba13dd8b4af0d | [] | no_license | x4nemi/act20 | 24397899377dfe5a6b4d0f2621db2de08cb4a505 | 63859002e60068adb7c5519663b8adb846388da7 | refs/heads/main | 2023-01-20T10:37:20.668512 | 2020-12-04T06:55:44 | 2020-12-04T06:55:44 | 318,420,207 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,202 | cpp | #include "guerrero.h"
#include <stdlib.h>
using namespace std;
Guerrero::Guerrero() { } //float r2 = static_cast <float> (rand()) / (static_cast <float> (RAND_MAX/X));
Guerrero::Guerrero(const string& id){
this->id = id;
salud = static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 100.0));
fuerza = static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 60.0));
defensa = static_cast <float> (rand()) / (static_cast <float> (RAND_MAX / 30.0));
string tipos[] = {"Lancero", "Arquero", "Paladin", "Mago"};
tipoGuerrero = tipos[rand() % 4];
}
void Guerrero::setID(const string& id){
this->id = id;
}
void Guerrero::setSalud(const int& salud){
this->salud = salud;
}
void Guerrero::setFuerza(const float& fuerza){
this->fuerza = fuerza;
}
void Guerrero::setDefensa(const float& defensa){
this->defensa = defensa;
}
void Guerrero::setTipo(const string& tipo){
tipoGuerrero = tipo;
}
string Guerrero::getID(){
return id;
}
int Guerrero::getSalud(){
return salud;
}
float Guerrero::getFuerza(){
return fuerza;
}
float Guerrero::getDefensa(){
return defensa;
}
string Guerrero::getTipo(){
return tipoGuerrero;
} | [
"ximena.garcia7482@alumnos.udg.mx"
] | ximena.garcia7482@alumnos.udg.mx |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.