blob_id
stringlengths 40
40
| directory_id
stringlengths 40
40
| path
stringlengths 3
264
| content_id
stringlengths 40
40
| detected_licenses
sequencelengths 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
sequencelengths 1
1
| author_id
stringlengths 0
158
|
|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|---|
d610b5a5b77b327931ef2cc56fbc2aeaecab8646 | 519c64b3f1a8d8c12121141f9f950db8c31d3ac9 | /Poj/1061.cpp | ee47116759bd440dcdc461276b097eb6b677b91f | [] | no_license | Ronnoc/Training | 7c7db931865dd5a7ba222b3c1c384a43459737f0 | 75d16ac8f33dfe0cf47548bf75d35a8b51967184 | refs/heads/master | 2022-11-11T19:57:53.845777 | 2022-11-06T02:54:34 | 2022-11-06T02:54:34 | 13,489,501 | 17 | 5 | null | null | null | null | GB18030 | C++ | false | false | 1,233 | cpp | #include <cstdio>
#include <algorithm>
#include <iostream>
using namespace std;
#define _LL long long
//扩展Euclid求解gcd(a,b)=ax+by
_LL ext_gcd(_LL a,_LL b,_LL &x,_LL &y){
_LL t,ret;
if(!b){x=1;y=0;return a;}
ret=ext_gcd(b,a%b,x,y);
t=x;x=y;y=t-a/b*y;
return ret;
}
//计算m^a
_LL exponent(_LL m,_LL a){
_LL ret=1;
while(a){
if(a&1)ret*=m;
a>>=1;
m*=m;
}
return ret;
}
//计算m^a%mod
_LL mod_exponent(_LL m,_LL a,_LL mod){
_LL ret=1;
m%=mod;
while(a){
if(a&1)ret*=m;
a>>=1;
m*=m;
m%=mod;
ret%=mod;
}
return ret;
}
//求解模线性方程ax=b (% mod)
//返回解的个数,解保存在sol[]中
//要求n>0,解的范围0..n-1
_LL mod_linear(_LL a,_LL b,_LL mod,_LL *sol){
_LL d,e,x,y,i;
d=ext_gcd(a,mod,x,y);
if (b%d)
return 0;
e=(x*(b/d)%mod+mod)%mod;
// for (i=0;i<d;i++)
// sol[i]=(e+i*(mod/d))%mod;
sol[0]=e%mod;
return d;
}
int main() {
_LL x,y,m,n,L;
while(cin>>x>>y>>m>>n>>L){
_LL dis=(y-x+L)%L;
_LL der=(m-n+L)%L;
_LL sol[10];
_LL res=mod_linear(der,dis,L,sol);
if(res)cout<<sol[0]<<endl;
else cout<<"Impossible\n";
}
return 0;}
| [
"[email protected]"
] | |
490bfc7598b9f724980833a9e4dd56fbdfffaf84 | 41499f73e807ac9fee5e2ff96a8894d08d967293 | /FORKS/C++/OpenPGP/tree/Subpackets/Tag2Sub24.cpp | eea9207c39f7a531a2de614f3952fed66c17eef6 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference",
"WTFPL",
"LicenseRef-scancode-warranty-disclaimer"
] | permissive | lordnynex/CLEANUP | c9f3058ec96674696339e7e936170a8645ddc09b | 77e8e3cad25ce740fefb42859d9945cc482e009a | refs/heads/master | 2021-01-10T07:35:08.071207 | 2016-04-10T22:02:57 | 2016-04-10T22:02:57 | 55,870,021 | 5 | 1 | WTFPL | 2023-03-20T11:55:51 | 2016-04-09T22:36:23 | C++ | UTF-8 | C++ | false | false | 766 | cpp | #include "Tag2Sub24.h"
Tag2Sub24::Tag2Sub24():
Tag2Subpacket(24),
pks()
{}
Tag2Sub24::Tag2Sub24(std::string & data):
Tag2Sub24()
{
read(data);
}
void Tag2Sub24::read(std::string & data){
pks = data;
size = data.size();
}
std::string Tag2Sub24::show(const uint8_t indents, const uint8_t indent_size) const{
unsigned int tab = indents * indent_size;
return std::string(tab, ' ') + show_title() + "\n" + std::string(tab, ' ') + " URI - " + pks;
}
std::string Tag2Sub24::raw() const{
return pks;
}
std::string Tag2Sub24::get_pks() const{
return pks;
}
void Tag2Sub24::set_pks(const std::string & p){
pks = p;
}
Tag2Subpacket::Ptr Tag2Sub24::clone() const{
return std::make_shared <Tag2Sub24> (*this);
}
| [
"[email protected]"
] | |
a9010c6516e09d2a0f7c0ddfc8fb0cfa6efc66c5 | 64cb681c4430d699035e24bdc6e29019c72b0f94 | /renderdoc/driver/vulkan/vk_shader_feedback.cpp | fedde73013399b121c4025a1bcaa7bb3f4c213ef | [
"LicenseRef-scancode-unknown-license-reference",
"MIT"
] | permissive | new-TonyWang/renderdoc | ebd7d0e338b0e56164930915ebce4c0f411f2977 | ac9c37e2e9ba4b9ab6740c020e65681eceba45dd | refs/heads/v1.x | 2023-07-09T17:03:11.345913 | 2021-08-18T02:54:41 | 2021-08-18T02:54:41 | 379,597,382 | 0 | 0 | MIT | 2021-08-18T03:15:31 | 2021-06-23T12:35:00 | C++ | UTF-8 | C++ | false | false | 67,411 | cpp | /******************************************************************************
* The MIT License (MIT)
*
* Copyright (c) 2019-2021 Baldur Karlsson
*
* Permission is hereby granted, free of charge, to any person obtaining a copy
* of this software and associated documentation files (the "Software"), to deal
* in the Software without restriction, including without limitation the rights
* to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
* copies of the Software, and to permit persons to whom the Software is
* furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
* AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
* OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
* THE SOFTWARE.
******************************************************************************/
#include <ctype.h>
#include <float.h>
#include "common/formatting.h"
#include "core/settings.h"
#include "driver/shaders/spirv/spirv_editor.h"
#include "driver/shaders/spirv/spirv_op_helpers.h"
#include "vk_core.h"
#include "vk_debug.h"
#include "vk_replay.h"
#include "vk_shader_cache.h"
RDOC_CONFIG(rdcstr, Vulkan_Debug_FeedbackDumpDirPath, "",
"Path to dump bindless feedback annotation generated SPIR-V files.");
RDOC_CONFIG(
bool, Vulkan_BindlessFeedback, true,
"Enable fetching from GPU which descriptors were dynamically used in descriptor arrays.");
RDOC_CONFIG(bool, Vulkan_PrintfFetch, true, "Enable fetching printf messages from GPU.");
RDOC_CONFIG(uint32_t, Vulkan_Debug_PrintfBufferSize, 64 * 1024,
"How many bytes to reserve for a printf output buffer.");
RDOC_EXTERN_CONFIG(bool, Vulkan_Debug_DisableBufferDeviceAddress);
static const uint32_t ShaderStageHeaderBitShift = 28U;
struct feedbackData
{
uint64_t offset;
uint32_t numEntries;
};
struct PrintfData
{
rdcstr format;
// vectors are expanded so there's one for each component (as printf will expect)
rdcarray<rdcspv::Scalar> argTypes;
size_t payloadWords;
};
struct ShaderPrintfArgs : public StringFormat::Args
{
public:
ShaderPrintfArgs(const uint32_t *payload, const PrintfData &formats)
: m_Start(payload), m_Cur(payload), m_Idx(0), m_Formats(formats)
{
}
void reset() override
{
m_Cur = m_Start;
m_Idx = 0;
}
int get_int() override
{
int32_t ret = *(int32_t *)m_Cur;
m_Idx++;
m_Cur++;
return ret;
}
unsigned int get_uint() override
{
uint32_t ret = *(uint32_t *)m_Cur;
m_Idx++;
m_Cur++;
return ret;
}
double get_double() override
{
// here we need to know if a real double was stored or not. It probably isn't but we handle it
if(m_Idx < m_Formats.argTypes.size())
{
if(m_Formats.argTypes[m_Idx].width == 64)
{
double ret = *(double *)m_Cur;
m_Idx++;
m_Cur += 2;
return ret;
}
else
{
float ret = *(float *)m_Cur;
m_Idx++;
m_Cur++;
return ret;
}
}
else
{
return 0.0;
}
}
void *get_ptr() override
{
m_Idx++;
return NULL;
}
uint64_t get_uint64() override
{
uint64_t ret = *(uint64_t *)m_Cur;
m_Idx++;
m_Cur += 2;
return ret;
}
size_t get_size() override { return sizeof(size_t) == 8 ? (size_t)get_uint64() : get_uint(); }
private:
const uint32_t *m_Cur;
const uint32_t *m_Start;
size_t m_Idx;
const PrintfData &m_Formats;
};
rdcstr PatchFormatString(rdcstr format)
{
// we don't support things like %XX.YYv2f so look for vector formatters and expand them to
// %XX.YYf, %XX.YYf
// Also annoyingly the printf specification for 64-bit integers is printed as %ul instead of %llu,
// so we need to patch that up too
for(size_t i = 0; i < format.size(); i++)
{
if(format[i] == '%')
{
size_t start = i;
i++;
if(format[i] == '%')
continue;
// skip to first letter
while(i < format.size() && !isalpha(format[i]))
i++;
// malformed string, abort
if(!isalpha(format[i]))
{
RDCERR("Malformed format string '%s'", format.c_str());
break;
}
// if the first letter is v, this is a vector format
if(format[i] == 'v' || format[i] == 'V')
{
size_t vecStart = i;
int vecsize = int(format[i + 1]) - int('0');
if(vecsize < 2 || vecsize > 4)
{
RDCERR("Malformed format string '%s'", format.c_str());
break;
}
// skip the v and the [234]
i += 2;
if(i >= format.size())
{
RDCERR("Malformed format string '%s'", format.c_str());
break;
}
bool int64 = false;
// if the final letter is u, we need to peek ahead to see if there's a l following
if(format[i] == 'u' && i + 1 < format.size() && format[i + 1] == 'l')
{
i++;
int64 = true;
}
rdcstr componentFormat = format.substr(start, i - start + 1);
// remove the vX from the component format
componentFormat.erase(vecStart - start, 2);
// if it's a 64-bit ul, transform to llu
if(int64)
{
componentFormat.pop_back();
componentFormat.pop_back();
componentFormat += "llu";
}
rdcstr vectorExpandedFormat;
for(int v = 0; v < vecsize; v++)
{
vectorExpandedFormat += componentFormat;
if(v + 1 < vecsize)
vectorExpandedFormat += ", ";
}
// remove the vector formatter
format.erase(start, i - start + 1);
format.insert(start, vectorExpandedFormat);
continue;
}
// if the letter is u, see if the next is l. If so we translate ul to llu
if(format[i] == 'u' && i + 1 < format.size() && format[i + 1] == 'l')
{
format[i] = 'l';
format[i + 1] = 'u';
format.insert(i, 'l');
}
}
}
return format;
}
void AnnotateShader(const ShaderReflection &refl, const SPIRVPatchData &patchData,
ShaderStage stage, const char *entryName,
const std::map<rdcspv::Binding, feedbackData> &offsetMap, uint32_t maxSlot,
bool usePrimitiveID, VkDeviceAddress addr, bool bufferAddressKHR,
rdcarray<uint32_t> &modSpirv, std::map<uint32_t, PrintfData> &printfData)
{
// calculate offsets for IDs on the original unmodified SPIR-V. The editor may insert some nops,
// so we do it manually here
std::map<rdcspv::Id, uint32_t> idToOffset;
for(rdcspv::Iter it(modSpirv, rdcspv::FirstRealWord); it; it++)
idToOffset[rdcspv::OpDecoder(it).result] = (uint32_t)it.offs();
rdcspv::Editor editor(modSpirv);
editor.Prepare();
RDCASSERTMSG("SPIR-V module is too large to encode instruction ID!", modSpirv.size() < 0xfffffffU);
const bool useBufferAddress = (addr != 0);
const uint32_t targetIndexWidth = useBufferAddress ? 64 : 32;
// store the maximum slot we can use, for clamping outputs to avoid writing out of bounds
rdcspv::Id maxSlotID = useBufferAddress ? editor.AddConstantImmediate<uint64_t>(maxSlot)
: editor.AddConstantImmediate<uint32_t>(maxSlot);
rdcspv::Id maxPrintfWordOffset =
editor.AddConstantImmediate<uint32_t>(Vulkan_Debug_PrintfBufferSize() / sizeof(uint32_t));
rdcspv::Id uint32Type = editor.DeclareType(rdcspv::scalar<uint32_t>());
rdcspv::Id int32Type = editor.DeclareType(rdcspv::scalar<int32_t>());
rdcspv::Id f32Type = editor.DeclareType(rdcspv::scalar<float>());
rdcspv::Id uint64Type, int64Type;
rdcspv::Id uint32StructID;
rdcspv::Id funcParamType;
if(useBufferAddress)
{
// declare the int64 types we'll need
uint64Type = editor.DeclareType(rdcspv::scalar<uint64_t>());
int64Type = editor.DeclareType(rdcspv::scalar<int64_t>());
uint32StructID = editor.AddType(rdcspv::OpTypeStruct(editor.MakeId(), {uint32Type}));
// any function parameters we add are uint64 byte offsets
funcParamType = uint64Type;
}
else
{
rdcspv::Id runtimeArrayID =
editor.AddType(rdcspv::OpTypeRuntimeArray(editor.MakeId(), uint32Type));
editor.AddDecoration(rdcspv::OpDecorate(
runtimeArrayID, rdcspv::DecorationParam<rdcspv::Decoration::ArrayStride>(sizeof(uint32_t))));
uint32StructID = editor.AddType(rdcspv::OpTypeStruct(editor.MakeId(), {runtimeArrayID}));
// any function parameters we add are uint32 indices
funcParamType = uint32Type;
// if the module declares int64 capability, ensure uint64/int64 are declared in case we need to
// transform them for printf arguments
if(editor.HasCapability(rdcspv::Capability::Int64))
{
uint64Type = editor.DeclareType(rdcspv::scalar<uint64_t>());
int64Type = editor.DeclareType(rdcspv::scalar<int64_t>());
}
}
editor.SetName(uint32StructID, "__rd_feedbackStruct");
editor.AddDecoration(rdcspv::OpMemberDecorate(
uint32StructID, 0, rdcspv::DecorationParam<rdcspv::Decoration::Offset>(0)));
// map from variable ID to watch, to variable ID to get offset from (as a SPIR-V constant,
// or as either uint64 byte offset for buffer addressing or uint32 ssbo index otherwise)
std::map<rdcspv::Id, rdcspv::Id> varLookup;
// iterate over all variables. We do this here because in the absence of the buffer address
// extension we might declare our own below and patch bindings - so we need to look these up now
for(const rdcspv::Variable &var : editor.GetGlobals())
{
// skip variables without one of these storage classes, as they are not descriptors
if(var.storage != rdcspv::StorageClass::UniformConstant &&
var.storage != rdcspv::StorageClass::Uniform &&
var.storage != rdcspv::StorageClass::StorageBuffer)
continue;
// get this variable's binding info
rdcspv::Binding bind = editor.GetBinding(var.id);
// if this is one of the bindings we care about
auto it = offsetMap.find(bind);
if(it != offsetMap.end())
{
// store the offset for this variable so we watch for access chains and know where to store to
if(useBufferAddress)
{
rdcspv::Id id = varLookup[var.id] = editor.AddConstantImmediate<uint64_t>(it->second.offset);
editor.SetName(id, StringFormat::Fmt("__feedbackOffset_set%u_bind%u", it->first.set,
it->first.binding));
}
else
{
// check that the offset fits in 32-bit word, convert byte offset to uint32 index
uint64_t index = it->second.offset / 4;
RDCASSERT(index < 0xFFFFFFFFULL, bind.set, bind.binding, it->second.offset);
rdcspv::Id id = varLookup[var.id] = editor.AddConstantImmediate<uint32_t>(uint32_t(index));
editor.SetName(
id, StringFormat::Fmt("__feedbackIndex_set%u_bind%u", it->first.set, it->first.binding));
}
}
}
rdcspv::Id bufferAddressConst, ssboVar, uint32ptrtype;
if(usePrimitiveID && stage == ShaderStage::Fragment && Vulkan_PrintfFetch())
{
editor.AddCapability(rdcspv::Capability::Geometry);
}
rdcarray<rdcspv::Id> newGlobals;
if(useBufferAddress)
{
// add the extension
editor.AddExtension(bufferAddressKHR ? "SPV_KHR_physical_storage_buffer"
: "SPV_EXT_physical_storage_buffer");
// change the memory model to physical storage buffer 64
rdcspv::Iter it = editor.Begin(rdcspv::Section::MemoryModel);
rdcspv::OpMemoryModel model(it);
model.addressingModel = rdcspv::AddressingModel::PhysicalStorageBuffer64;
it = model;
// add capabilities
editor.AddCapability(rdcspv::Capability::PhysicalStorageBufferAddresses);
editor.AddCapability(rdcspv::Capability::Int64);
// declare the address constants and make our pointers physical storage buffer pointers
bufferAddressConst = editor.AddConstantImmediate<uint64_t>(addr);
uint32ptrtype =
editor.DeclareType(rdcspv::Pointer(uint32Type, rdcspv::StorageClass::PhysicalStorageBuffer));
editor.SetName(bufferAddressConst, "__rd_feedbackAddress");
// struct is block decorated
editor.AddDecoration(rdcspv::OpDecorate(uint32StructID, rdcspv::Decoration::Block));
}
else
{
rdcspv::StorageClass ssboClass = editor.StorageBufferClass();
// the pointers are SSBO pointers
rdcspv::Id bufptrtype = editor.DeclareType(rdcspv::Pointer(uint32StructID, ssboClass));
uint32ptrtype = editor.DeclareType(rdcspv::Pointer(uint32Type, ssboClass));
// patch all bindings up by 1
for(rdcspv::Iter it = editor.Begin(rdcspv::Section::Annotations),
end = editor.End(rdcspv::Section::Annotations);
it < end; ++it)
{
// we will use descriptor set 0 for our own purposes if we don't have a buffer address.
//
// Since bindings are arbitrary, we just increase all user bindings to make room, and we'll
// redeclare the descriptor set layouts and pipeline layout. This is inevitable in the case
// where all descriptor sets are already used. In theory we only have to do this with set 0,
// but that requires knowing which variables are in set 0 and it's simpler to increase all
// bindings.
if(it.opcode() == rdcspv::Op::Decorate)
{
rdcspv::OpDecorate dec(it);
if(dec.decoration == rdcspv::Decoration::Binding)
{
RDCASSERT(dec.decoration.binding != 0xffffffff);
dec.decoration.binding += 1;
it = dec;
}
}
}
// add our SSBO variable, at set 0 binding 0
ssboVar = editor.MakeId();
editor.AddVariable(rdcspv::OpVariable(bufptrtype, ssboVar, ssboClass));
editor.AddDecoration(
rdcspv::OpDecorate(ssboVar, rdcspv::DecorationParam<rdcspv::Decoration::DescriptorSet>(0)));
editor.AddDecoration(
rdcspv::OpDecorate(ssboVar, rdcspv::DecorationParam<rdcspv::Decoration::Binding>(0)));
if(editor.EntryPointAllGlobals())
newGlobals.push_back(ssboVar);
editor.SetName(ssboVar, "__rd_feedbackBuffer");
editor.DecorateStorageBufferStruct(uint32StructID);
}
rdcspv::Id rtarrayOffset = editor.AddConstantImmediate<uint32_t>(0U);
rdcspv::Id printfArrayOffset = rtarrayOffset;
rdcspv::Id zero = rtarrayOffset;
rdcspv::Id usedValue = editor.AddConstantImmediate<uint32_t>(0xFFFFFFFFU);
rdcspv::Id scope = editor.AddConstantImmediate<uint32_t>((uint32_t)rdcspv::Scope::Invocation);
rdcspv::Id semantics = editor.AddConstantImmediate<uint32_t>(0U);
rdcspv::Id uint32shift = editor.AddConstantImmediate<uint32_t>(2U);
rdcspv::MemoryAccessAndParamDatas memoryAccess;
memoryAccess.setAligned(sizeof(uint32_t));
rdcspv::Id printfIncrement;
if(useBufferAddress)
{
printfIncrement = editor.AddConstantImmediate<uint64_t>(sizeof(uint32_t));
}
else
{
printfIncrement = editor.AddConstantImmediate<uint32_t>(1U);
}
rdcspv::Id glsl450 = editor.ImportExtInst("GLSL.std.450");
std::map<rdcspv::Id, rdcspv::Scalar> intTypeLookup;
for(auto scalarType : editor.GetTypeInfo<rdcspv::Scalar>())
if(scalarType.first.type == rdcspv::Op::TypeInt)
intTypeLookup[scalarType.second] = scalarType.first;
rdcspv::Id entryID;
for(const rdcspv::EntryPoint &entry : editor.GetEntries())
{
if(entry.name == entryName && MakeShaderStage(entry.executionModel) == stage)
{
entryID = entry.id;
break;
}
}
rdcspv::Id uvec2Type = editor.DeclareType(rdcspv::Vector(rdcspv::scalar<uint32_t>(), 2));
rdcspv::Id uvec3Type = editor.DeclareType(rdcspv::Vector(rdcspv::scalar<uint32_t>(), 3));
rdcspv::Id uvec4Type = editor.DeclareType(rdcspv::Vector(rdcspv::scalar<uint32_t>(), 4));
// we'll initialise this at the start of the entry point, and use it globally to get the location
// for printf statements
rdcspv::Id printfLocationVar = editor.MakeId();
if(Vulkan_PrintfFetch())
{
editor.AddVariable(rdcspv::OpVariable(
editor.DeclareType(rdcspv::Pointer(uvec3Type, rdcspv::StorageClass::Private)),
printfLocationVar, rdcspv::StorageClass::Private));
if(editor.EntryPointAllGlobals())
newGlobals.push_back(printfLocationVar);
}
rdcspv::Id shaderStageConstant =
editor.AddConstantImmediate<uint32_t>(uint32_t(stage) << ShaderStageHeaderBitShift);
rdcspv::Id int64wordshift = editor.AddConstantImmediate<uint32_t>(32U);
// build up operations to pull in the location from globals - either existing or ones we add
rdcspv::OperationList locationGather;
if(Vulkan_PrintfFetch())
{
rdcarray<rdcspv::Id> idxs;
auto fetchOrAddGlobalInput = [&editor, &idxs, &refl, &patchData, &locationGather, &newGlobals](
const char *name, ShaderBuiltin builtin, rdcspv::BuiltIn spvBuiltin, rdcspv::Id varType) {
rdcspv::Id ret;
rdcspv::Id ptrType = editor.DeclareType(rdcspv::Pointer(varType, rdcspv::StorageClass::Input));
for(size_t i = 0; i < refl.inputSignature.size(); i++)
{
if(refl.inputSignature[i].systemValue == builtin)
{
rdcspv::Id loadType = varType;
if(refl.inputSignature[i].varType == VarType::SInt)
{
if(refl.inputSignature[i].compCount == 1)
loadType = editor.DeclareType(rdcspv::scalar<int32_t>());
else
loadType = editor.DeclareType(
rdcspv::Vector(rdcspv::scalar<int32_t>(), refl.inputSignature[i].compCount));
}
if(patchData.inputs[i].accessChain.empty())
{
ret =
locationGather.add(rdcspv::OpLoad(loadType, editor.MakeId(), patchData.inputs[i].ID));
}
else
{
rdcarray<rdcspv::Id> chain;
for(uint32_t accessIdx : patchData.inputs[i].accessChain)
{
idxs.resize_for_index(accessIdx);
if(idxs[accessIdx] == 0)
idxs[accessIdx] = editor.AddConstantImmediate<uint32_t>(accessIdx);
chain.push_back(idxs[accessIdx]);
}
rdcspv::Id subElement = locationGather.add(
rdcspv::OpAccessChain(ptrType, editor.MakeId(), patchData.inputs[i].ID, chain));
ret =
locationGather.add(rdcspv::OpLoad(loadType, editor.MakeId(), patchData.inputs[i].ID));
}
if(loadType != varType)
ret = locationGather.add(rdcspv::OpBitcast(varType, editor.MakeId(), ret));
}
}
if(ret == rdcspv::Id())
{
rdcspv::Id rdocGlobalVar = editor.AddVariable(
rdcspv::OpVariable(ptrType, editor.MakeId(), rdcspv::StorageClass::Input));
editor.AddDecoration(rdcspv::OpDecorate(
rdocGlobalVar, rdcspv::DecorationParam<rdcspv::Decoration::BuiltIn>(spvBuiltin)));
newGlobals.push_back(rdocGlobalVar);
editor.SetName(rdocGlobalVar, name);
ret = locationGather.add(rdcspv::OpLoad(varType, editor.MakeId(), rdocGlobalVar));
}
return ret;
};
rdcspv::Id location;
// the location encoding varies by stage
if(stage == ShaderStage::Compute)
{
// the location for compute is easy, it's just the global invocation
location = fetchOrAddGlobalInput("rdoc_invocation", ShaderBuiltin::DispatchThreadIndex,
rdcspv::BuiltIn::GlobalInvocationId, uvec3Type);
}
else if(stage == ShaderStage::Vertex)
{
rdcspv::Id vtx = fetchOrAddGlobalInput("rdoc_vertexIndex", ShaderBuiltin::VertexIndex,
rdcspv::BuiltIn::VertexIndex, uint32Type);
rdcspv::Id inst = fetchOrAddGlobalInput("rdoc_instanceIndex", ShaderBuiltin::InstanceIndex,
rdcspv::BuiltIn::InstanceIndex, uint32Type);
rdcspv::Id view;
// only search for the view index is the multiview capability is declared, otherwise it's
// invalid and we just set 0
if(editor.HasCapability(rdcspv::Capability::MultiView))
{
view = fetchOrAddGlobalInput("rdoc_viewIndex", ShaderBuiltin::ViewportIndex,
rdcspv::BuiltIn::ViewIndex, uint32Type);
}
else
{
view = editor.AddConstantImmediate<uint32_t>(0U);
}
location = locationGather.add(
rdcspv::OpCompositeConstruct(uvec3Type, editor.MakeId(), {vtx, inst, view}));
}
else if(stage == ShaderStage::Pixel)
{
rdcspv::Id float2Type = editor.DeclareType(rdcspv::Vector(rdcspv::scalar<float>(), 2));
rdcspv::Id float4Type = editor.DeclareType(rdcspv::Vector(rdcspv::scalar<float>(), 4));
rdcspv::Id coord = fetchOrAddGlobalInput("rdoc_fragCoord", ShaderBuiltin::Position,
rdcspv::BuiltIn::FragCoord, float4Type);
// grab just the xy
coord = locationGather.add(
rdcspv::OpVectorShuffle(float2Type, editor.MakeId(), coord, coord, {0, 1}));
// convert to int
coord = locationGather.add(rdcspv::OpConvertFToU(uvec2Type, editor.MakeId(), coord));
rdcspv::Id x =
locationGather.add(rdcspv::OpCompositeExtract(uint32Type, editor.MakeId(), coord, {0}));
rdcspv::Id y =
locationGather.add(rdcspv::OpCompositeExtract(uint32Type, editor.MakeId(), coord, {1}));
// shift x up into top 16-bits
x = locationGather.add(rdcspv::OpShiftLeftLogical(
uint32Type, editor.MakeId(), x, editor.AddConstantImmediate<uint32_t>(16U)));
// OR together
coord = locationGather.add(rdcspv::OpBitwiseOr(uint32Type, editor.MakeId(), x, y));
rdcspv::Id samp;
// only grab the sample ID if sample shading is already enabled
for(size_t i = 0; i < refl.inputSignature.size(); i++)
{
if(refl.inputSignature[i].systemValue == ShaderBuiltin::MSAASampleIndex ||
refl.inputSignature[i].systemValue == ShaderBuiltin::MSAASamplePosition)
{
samp = fetchOrAddGlobalInput("rdoc_sampleIndex", ShaderBuiltin::MSAASampleIndex,
rdcspv::BuiltIn::SampleId, uint32Type);
}
}
if(samp == rdcspv::Id())
{
samp = editor.AddConstantImmediate<uint32_t>(~0U);
}
rdcspv::Id prim;
if(usePrimitiveID)
{
prim = fetchOrAddGlobalInput("rdoc_primitiveIndex", ShaderBuiltin::PrimitiveIndex,
rdcspv::BuiltIn::PrimitiveId, uint32Type);
}
else
{
prim = editor.AddConstantImmediate<uint32_t>(~0U);
}
location = locationGather.add(
rdcspv::OpCompositeConstruct(uvec3Type, editor.MakeId(), {coord, samp, prim}));
}
else
{
RDCWARN("No identifier stored for %s stage", ToStr(stage).c_str());
location = locationGather.add(
rdcspv::OpCompositeConstruct(uvec3Type, editor.MakeId(), {zero, zero, zero}));
}
locationGather.add(rdcspv::OpStore(printfLocationVar, location));
}
if(!newGlobals.empty())
{
rdcspv::Iter it = editor.GetEntry(entryID);
RDCASSERT(it.opcode() == rdcspv::Op::EntryPoint);
rdcspv::OpEntryPoint entry(it);
editor.Remove(it);
entry.iface.append(newGlobals);
editor.AddOperation(it, entry);
}
rdcspv::Id debugPrintfSet = editor.HasExtInst("NonSemantic.DebugPrintf");
rdcspv::TypeToIds<rdcspv::FunctionType> funcTypes = editor.GetTypes<rdcspv::FunctionType>();
// functions that have been patched with annotation & extra function parameters if needed
std::set<rdcspv::Id> patchedFunctions;
// functions we need to patch, with the indices of which parameters have bindings coming along
// with
std::map<rdcspv::Id, rdcarray<size_t>> functionPatchQueue;
// start with the entry point, with no parameters to patch
functionPatchQueue[entryID] = {};
// now keep patching functions until we have no more to patch
while(!functionPatchQueue.empty())
{
rdcspv::Id funcId;
rdcarray<size_t> patchArgIndices;
{
auto it = functionPatchQueue.begin();
funcId = functionPatchQueue.begin()->first;
patchArgIndices = functionPatchQueue.begin()->second;
functionPatchQueue.erase(it);
patchedFunctions.insert(funcId);
}
rdcspv::Iter it = editor.GetID(funcId);
RDCASSERT(it.opcode() == rdcspv::Op::Function);
if(!patchArgIndices.empty())
{
rdcspv::OpFunction func(it);
// find the function's type declaration, add the necessary arguments, redeclare and patch it
for(const rdcspv::TypeToId<rdcspv::FunctionType> &funcType : funcTypes)
{
if(funcType.second == func.functionType)
{
rdcspv::FunctionType patchedFuncType = funcType.first;
for(size_t i = 0; i < patchArgIndices.size(); i++)
patchedFuncType.argumentIds.push_back(funcParamType);
rdcspv::Id newFuncTypeID = editor.DeclareType(patchedFuncType);
// re-fetch the iterator as it might have moved with the type declaration
it = editor.GetID(funcId);
// change the declared function type
func.functionType = newFuncTypeID;
editor.PreModify(it);
it = func;
editor.PostModify(it);
break;
}
}
}
++it;
// onto the OpFunctionParameters. First allocate IDs for all our new function parameters
rdcarray<rdcspv::Id> patchedParamIDs;
for(size_t i = 0; i < patchArgIndices.size(); i++)
patchedParamIDs.push_back(editor.MakeId());
size_t argIndex = 0;
size_t watchIndex = 0;
while(it.opcode() == rdcspv::Op::FunctionParameter)
{
rdcspv::OpFunctionParameter param(it);
// if this is a parameter we're patching, add it into varLookup
if(watchIndex < patchArgIndices.size() && patchArgIndices[watchIndex] == argIndex)
{
// when we see use of this parameter, patch it using the added parameter
varLookup[param.result] = patchedParamIDs[watchIndex];
// watch for the next argument
watchIndex++;
}
argIndex++;
++it;
}
// we're past the existing function parameters, now declare our new ones
for(size_t i = 0; i < patchedParamIDs.size(); i++)
{
editor.AddOperation(it, rdcspv::OpFunctionParameter(funcParamType, patchedParamIDs[i]));
++it;
}
// continue to the first label so we can insert things at the start of the entry point
for(; it; ++it)
{
if(it.opcode() == rdcspv::Op::Label)
{
++it;
break;
}
}
// skip past any local variables
while(it.opcode() == rdcspv::Op::Variable)
++it;
if(funcId == entryID)
{
for(const rdcspv::Operation &op : locationGather)
{
editor.AddOperation(it, op);
++it;
}
}
// now patch accesses in the function body
for(; it; ++it)
{
// finish when we hit the end of the function
if(it.opcode() == rdcspv::Op::FunctionEnd)
break;
// if we see an OpCopyObject, just add it to the map pointing to the same value
if(it.opcode() == rdcspv::Op::CopyObject)
{
rdcspv::OpCopyObject copy(it);
// is this a var we want to snoop?
auto varIt = varLookup.find(copy.operand);
if(varIt != varLookup.end())
{
varLookup[copy.result] = varIt->second;
}
}
if(it.opcode() == rdcspv::Op::FunctionCall)
{
rdcspv::OpFunctionCall call(it);
// check if any of the variables being passed are ones we care about. Accumulate the added
// parameters
rdcarray<uint32_t> funccall;
rdcarray<size_t> patchArgs;
// examine each argument to see if it's one we care about
for(size_t i = 0; i < call.arguments.size(); i++)
{
// if this param we're snooping then pass our offset - whether it's a constant or a
// function
// argument itself - into the function call
auto varIt = varLookup.find(call.arguments[i]);
if(varIt != varLookup.end())
{
funccall.push_back(varIt->second.value());
patchArgs.push_back(i);
}
}
// if we have parameters to patch, replace the function call
if(!funccall.empty())
{
// prepend all the existing words
for(size_t i = 1; i < it.size(); i++)
funccall.insert(i - 1, it.word(i));
rdcspv::Iter oldCall = it;
// add our patched call afterwards
it++;
editor.AddOperation(it, rdcspv::Operation(rdcspv::Op::FunctionCall, funccall));
// remove the old call
editor.Remove(oldCall);
}
// if this function isn't marked for patching yet, and isn't patched, queue it
if(functionPatchQueue[call.function].empty() &&
patchedFunctions.find(call.function) == patchedFunctions.end())
functionPatchQueue[call.function] = patchArgs;
}
if(it.opcode() == rdcspv::Op::ExtInst && Vulkan_PrintfFetch())
{
rdcspv::OpExtInst extinst(it);
// is this a printf extinst?
if(extinst.set == debugPrintfSet)
{
uint32_t printfID = idToOffset[extinst.result];
rdcspv::Id resultConstant = editor.AddConstantDeferred<uint32_t>(printfID);
PrintfData &format = printfData[printfID];
{
rdcspv::OpString str(editor.GetID(rdcspv::Id::fromWord(extinst.params[0])));
format.format = PatchFormatString(str.string);
}
rdcarray<rdcspv::Id> packetWords;
// pack all the parameters into uint32s
for(size_t i = 1; i < extinst.params.size(); i++)
{
rdcspv::Id printfparam = rdcspv::Id::fromWord(extinst.params[i]);
rdcspv::Id type = editor.GetIDType(printfparam);
rdcspv::Iter typeIt = editor.GetID(type);
// handle vectors, but no other composites
uint32_t vecDim = 0;
if(typeIt.opcode() == rdcspv::Op::TypeVector)
{
rdcspv::OpTypeVector vec(typeIt);
vecDim = vec.componentCount;
type = vec.componentType;
typeIt = editor.GetID(type);
}
rdcspv::Scalar scalarType(typeIt);
for(uint32_t comp = 0; comp < RDCMAX(1U, vecDim); comp++)
{
rdcspv::Id input = printfparam;
format.argTypes.push_back(scalarType);
// if the input is a vector, extract the component we're working on
if(vecDim > 0)
{
input = editor.AddOperation(
it, rdcspv::OpCompositeExtract(type, editor.MakeId(), input, {comp}));
it++;
}
// handle ints and floats
if(typeIt.opcode() == rdcspv::Op::TypeInt)
{
rdcspv::OpTypeInt intType(typeIt);
rdcspv::Id param = input;
if(intType.signedness)
{
// extend to 32-bit if needed then bitcast to unsigned
if(intType.width < 32)
{
param = editor.AddOperation(
it, rdcspv::OpSConvert(int32Type, editor.MakeId(), param));
it++;
}
param = editor.AddOperation(
it, rdcspv::OpBitcast(intType.width == 64 ? uint64Type : uint32Type,
editor.MakeId(), param));
it++;
}
else
{
// just extend to 32-bit if needed
if(intType.width < 32)
{
param = editor.AddOperation(
it, rdcspv::OpSConvert(uint32Type, editor.MakeId(), param));
it++;
}
}
// 64-bit integers we now need to split up the words and add them. Otherwise we have
// a 32-bit uint to add
if(intType.width == 64)
{
rdcspv::Id lo = editor.AddOperation(
it, rdcspv::OpUConvert(uint32Type, editor.MakeId(), param));
it++;
rdcspv::Id shifted = editor.AddOperation(
it, rdcspv::OpShiftRightLogical(uint64Type, editor.MakeId(), param,
int64wordshift));
it++;
rdcspv::Id hi = editor.AddOperation(
it, rdcspv::OpUConvert(uint32Type, editor.MakeId(), shifted));
it++;
packetWords.push_back(lo);
packetWords.push_back(hi);
}
else
{
packetWords.push_back(param);
}
}
else if(typeIt.opcode() == rdcspv::Op::TypeFloat)
{
rdcspv::OpTypeFloat floatType(typeIt);
rdcspv::Id param = input;
// if it's not at least a float, upconvert. We don't convert to doubles since that
// would require double capability
if(floatType.width < 32)
{
param =
editor.AddOperation(it, rdcspv::OpFConvert(f32Type, editor.MakeId(), param));
it++;
}
if(floatType.width == 64)
{
// for doubles we use the GLSL unpack operation
rdcspv::Id unpacked = editor.AddOperation(
it, rdcspv::OpGLSL450(uvec2Type, editor.MakeId(), glsl450,
rdcspv::GLSLstd450::UnpackDouble2x32, {param}));
// then extract the components
rdcspv::Id lo = editor.AddOperation(
it, rdcspv::OpCompositeExtract(uint32Type, editor.MakeId(), unpacked, {0}));
it++;
rdcspv::Id hi = editor.AddOperation(
it, rdcspv::OpCompositeExtract(uint32Type, editor.MakeId(), unpacked, {1}));
it++;
packetWords.push_back(lo);
packetWords.push_back(hi);
}
else
{
// otherwise we bitcast to uint32
param =
editor.AddOperation(it, rdcspv::OpBitcast(uint32Type, editor.MakeId(), param));
it++;
packetWords.push_back(param);
}
}
else
{
RDCERR("Unexpected type of operand to printf %s, ignoring",
ToStr(typeIt.opcode()).c_str());
}
}
}
format.payloadWords = packetWords.size();
// pack header uint32
rdcspv::Id header =
editor.AddOperation(it, rdcspv::OpBitwiseOr(uint32Type, editor.MakeId(),
shaderStageConstant, resultConstant));
it++;
packetWords.insert(0, header);
// load the location out of the global where we put it
rdcspv::Id location =
editor.AddOperation(it, rdcspv::OpLoad(uvec3Type, editor.MakeId(), printfLocationVar));
it++;
// extract each component and add it as a new word after the header
packetWords.insert(
1, editor.AddOperation(
it, rdcspv::OpCompositeExtract(uint32Type, editor.MakeId(), location, {0})));
it++;
packetWords.insert(
2, editor.AddOperation(
it, rdcspv::OpCompositeExtract(uint32Type, editor.MakeId(), location, {1})));
it++;
packetWords.insert(
3, editor.AddOperation(
it, rdcspv::OpCompositeExtract(uint32Type, editor.MakeId(), location, {2})));
it++;
rdcspv::Id counterptr;
if(useBufferAddress)
{
// make a pointer out of the buffer address
// uint32_t *bufptr = (uint32_t *)offsetaddr
counterptr = editor.AddOperation(
it, rdcspv::OpConvertUToPtr(uint32ptrtype, editor.MakeId(), bufferAddressConst));
it++;
}
else
{
// accesschain to get the pointer we'll atomic into.
// accesschain is 0 to access rtarray (first member) then zero for the first array index
// uint32_t *bufptr = (uint32_t *)&buf.printfWords[ssboindex];
counterptr =
editor.AddOperation(it, rdcspv::OpAccessChain(uint32ptrtype, editor.MakeId(),
ssboVar, {printfArrayOffset, zero}));
it++;
}
rdcspv::Id packetSize = editor.AddConstantDeferred<uint32_t>((uint32_t)packetWords.size());
// atomically reserve enough space
rdcspv::Id idx =
editor.AddOperation(it, rdcspv::OpAtomicIAdd(uint32Type, editor.MakeId(), counterptr,
scope, semantics, packetSize));
it++;
// clamp to the buffer size so we don't overflow
idx = editor.AddOperation(
it, rdcspv::OpGLSL450(uint32Type, editor.MakeId(), glsl450, rdcspv::GLSLstd450::UMin,
{idx, maxPrintfWordOffset}));
it++;
if(useBufferAddress)
{
// convert to a 64-bit value
idx = editor.AddOperation(it, rdcspv::OpUConvert(uint64Type, editor.MakeId(), idx));
it++;
// the index is in words, so multiply by the increment to get a byte offset
rdcspv::Id byteOffset = editor.AddOperation(
it, rdcspv::OpIMul(uint64Type, editor.MakeId(), idx, printfIncrement));
it++;
// add the offset to the base address
rdcspv::Id bufAddr = editor.AddOperation(
it, rdcspv::OpIAdd(uint64Type, editor.MakeId(), bufferAddressConst, byteOffset));
it++;
for(rdcspv::Id word : packetWords)
{
// we pre-increment idx because it starts from 0 but we want to write into words
// starting from [1] to leave the counter itself alone.
bufAddr = editor.AddOperation(
it, rdcspv::OpIAdd(uint64Type, editor.MakeId(), bufAddr, printfIncrement));
it++;
rdcspv::Id ptr = editor.AddOperation(
it, rdcspv::OpConvertUToPtr(uint32ptrtype, editor.MakeId(), bufAddr));
it++;
editor.AddOperation(it, rdcspv::OpStore(ptr, word, memoryAccess));
it++;
}
}
else
{
for(rdcspv::Id word : packetWords)
{
// we pre-increment idx because it starts from 0 but we want to write into words
// starting from [1] to leave the counter itself alone.
idx = editor.AddOperation(
it, rdcspv::OpIAdd(uint32Type, editor.MakeId(), idx, printfIncrement));
it++;
rdcspv::Id ptr =
editor.AddOperation(it, rdcspv::OpAccessChain(uint32ptrtype, editor.MakeId(),
ssboVar, {printfArrayOffset, idx}));
it++;
editor.AddOperation(it, rdcspv::OpStore(ptr, word));
it++;
}
}
// no it++ here, it will happen implicitly on loop continue
}
}
// if we see an access chain of a variable we're snooping, save out the result
if(it.opcode() == rdcspv::Op::AccessChain || it.opcode() == rdcspv::Op::InBoundsAccessChain)
{
rdcspv::OpAccessChain chain(it);
chain.op = it.opcode();
// is this a var we want to snoop?
auto varIt = varLookup.find(chain.base);
if(varIt != varLookup.end())
{
// multi-dimensional arrays of descriptors is not allowed - however an access chain could
// be longer than 5 words (1 index). Think of the case of a uniform buffer where the first
// index goes into the descriptor array, and further indices go inside the uniform buffer
// members.
RDCASSERT(chain.indexes.size() >= 1, chain.indexes.size());
rdcspv::Id index = chain.indexes[0];
// patch after the access chain
it++;
// upcast the index to uint32 or uint64 depending on which path we're taking
{
rdcspv::Id indexType = editor.GetIDType(index);
if(indexType == rdcspv::Id())
{
RDCERR("Unknown type for ID %u, defaulting to uint32_t", index.value());
indexType = uint32Type;
}
rdcspv::Scalar indexTypeData = rdcspv::scalar<uint32_t>();
auto indexTypeIt = intTypeLookup.find(indexType);
if(indexTypeIt != intTypeLookup.end())
{
indexTypeData = indexTypeIt->second;
}
else
{
RDCERR("Unknown index type ID %u, defaulting to uint32_t", indexType.value());
}
// if it's signed, bitcast it to unsigned
if(indexTypeData.signedness)
{
indexTypeData.signedness = false;
index = editor.AddOperation(
it, rdcspv::OpBitcast(editor.DeclareType(indexTypeData), editor.MakeId(), index));
it++;
}
// if it's not wide enough, uconvert expand it
if(indexTypeData.width != targetIndexWidth)
{
rdcspv::Id extendedtype =
editor.DeclareType(rdcspv::Scalar(rdcspv::Op::TypeInt, targetIndexWidth, false));
index =
editor.AddOperation(it, rdcspv::OpUConvert(extendedtype, editor.MakeId(), index));
it++;
}
}
// clamp the index to the maximum slot. If the user is reading out of bounds, don't write
// out of bounds.
{
rdcspv::Id clampedtype =
editor.DeclareType(rdcspv::Scalar(rdcspv::Op::TypeInt, targetIndexWidth, false));
index = editor.AddOperation(
it, rdcspv::OpGLSL450(clampedtype, editor.MakeId(), glsl450,
rdcspv::GLSLstd450::UMin, {index, maxSlotID}));
it++;
}
rdcspv::Id bufptr;
if(useBufferAddress)
{
// convert the constant embedded device address to a pointer
// get our output slot address by adding an offset to the base pointer
// baseaddr = bufferAddressConst + bindingOffset
rdcspv::Id baseaddr = editor.AddOperation(
it, rdcspv::OpIAdd(uint64Type, editor.MakeId(), bufferAddressConst, varIt->second));
it++;
// shift the index since this is a byte offset
// shiftedindex = index << uint32shift
rdcspv::Id shiftedindex = editor.AddOperation(
it, rdcspv::OpShiftLeftLogical(uint64Type, editor.MakeId(), index, uint32shift));
it++;
// add the index on top of that
// offsetaddr = baseaddr + shiftedindex
rdcspv::Id offsetaddr = editor.AddOperation(
it, rdcspv::OpIAdd(uint64Type, editor.MakeId(), baseaddr, shiftedindex));
it++;
// make a pointer out of it
// uint32_t *bufptr = (uint32_t *)offsetaddr
bufptr = editor.AddOperation(
it, rdcspv::OpConvertUToPtr(uint32ptrtype, editor.MakeId(), offsetaddr));
it++;
}
else
{
// accesschain into the SSBO, by adding the base offset for this var onto the index
// add the index to this binding's base index
// ssboindex = bindingOffset + index
rdcspv::Id ssboindex = editor.AddOperation(
it, rdcspv::OpIAdd(uint32Type, editor.MakeId(), index, varIt->second));
it++;
// accesschain to get the pointer we'll atomic into.
// accesschain is 0 to access rtarray (first member) then ssboindex for array index
// uint32_t *bufptr = (uint32_t *)&buf.rtarray[ssboindex];
bufptr =
editor.AddOperation(it, rdcspv::OpAccessChain(uint32ptrtype, editor.MakeId(),
ssboVar, {rtarrayOffset, ssboindex}));
it++;
}
// atomically set the uint32 that's pointed to
editor.AddOperation(it, rdcspv::OpAtomicUMax(uint32Type, editor.MakeId(), bufptr, scope,
semantics, usedValue));
// no it++ here, it will happen implicitly on loop continue
}
}
}
}
}
void VulkanReplay::ClearFeedbackCache()
{
m_BindlessFeedback.Usage.clear();
}
void VulkanReplay::FetchShaderFeedback(uint32_t eventId)
{
if(m_BindlessFeedback.Usage.find(eventId) != m_BindlessFeedback.Usage.end())
return;
if(!Vulkan_BindlessFeedback())
return;
// create it here so we won't re-run any code if the event is re-selected. We'll mark it as valid
// if it actually has any data in it later.
DynamicShaderFeedback &result = m_BindlessFeedback.Usage[eventId];
bool useBufferAddress = (m_pDriver->GetExtensions(NULL).ext_KHR_buffer_device_address ||
m_pDriver->GetExtensions(NULL).ext_EXT_buffer_device_address) &&
m_pDriver->GetDeviceEnabledFeatures().shaderInt64;
if(Vulkan_Debug_DisableBufferDeviceAddress() ||
m_pDriver->GetDriverInfo().BufferDeviceAddressBrokenDriver())
useBufferAddress = false;
bool useBufferAddressKHR = m_pDriver->GetExtensions(NULL).ext_KHR_buffer_device_address;
const VulkanRenderState &state = m_pDriver->m_RenderState;
VulkanCreationInfo &creationInfo = m_pDriver->m_CreationInfo;
const DrawcallDescription *drawcall = m_pDriver->GetDrawcall(eventId);
if(drawcall == NULL || !(drawcall->flags & (DrawFlags::Dispatch | DrawFlags::Drawcall)))
return;
result.compute = bool(drawcall->flags & DrawFlags::Dispatch);
const VulkanStatePipeline &pipe = result.compute ? state.compute : state.graphics;
if(pipe.pipeline == ResourceId())
return;
const VulkanCreationInfo::Pipeline &pipeInfo = creationInfo.m_Pipeline[pipe.pipeline];
VkDeviceSize feedbackStorageSize = 0;
std::map<rdcspv::Binding, feedbackData> offsetMap;
bool usesPrintf = false;
VkGraphicsPipelineCreateInfo graphicsInfo = {};
VkComputePipelineCreateInfo computeInfo = {};
// get pipeline create info
if(result.compute)
{
m_pDriver->GetShaderCache()->MakeComputePipelineInfo(computeInfo, state.compute.pipeline);
}
else
{
m_pDriver->GetShaderCache()->MakeGraphicsPipelineInfo(graphicsInfo, state.graphics.pipeline);
graphicsInfo.renderPass =
creationInfo.m_RenderPass[GetResID(graphicsInfo.renderPass)].loadRPs[graphicsInfo.subpass];
graphicsInfo.subpass = 0;
}
if(result.compute)
{
usesPrintf = pipeInfo.shaders[5].patchData->usesPrintf;
}
else
{
for(uint32_t i = 0; i < graphicsInfo.stageCount; i++)
{
VkPipelineShaderStageCreateInfo &stage =
(VkPipelineShaderStageCreateInfo &)graphicsInfo.pStages[i];
int idx = StageIndex(stage.stage);
usesPrintf |= pipeInfo.shaders[idx].patchData->usesPrintf;
}
}
if(usesPrintf)
{
// reserve some space at the start for an atomic offset counter then the buffer size, and an
// overflow section for any clamped messages
feedbackStorageSize += 16 + Vulkan_Debug_PrintfBufferSize() + 1024;
}
{
const rdcarray<ResourceId> &descSetLayoutIds =
creationInfo.m_PipelineLayout[pipeInfo.layout].descSetLayouts;
rdcspv::Binding key;
for(size_t set = 0; set < descSetLayoutIds.size(); set++)
{
key.set = (uint32_t)set;
const DescSetLayout &layout = creationInfo.m_DescSetLayout[descSetLayoutIds[set]];
for(size_t binding = 0; binding < layout.bindings.size(); binding++)
{
const DescSetLayout::Binding &bindData = layout.bindings[binding];
// skip empty bindings
if(bindData.descriptorType == VK_DESCRIPTOR_TYPE_MAX_ENUM)
continue;
// only process array bindings
if(bindData.descriptorCount > 1 &&
bindData.descriptorType != VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT)
{
key.binding = (uint32_t)binding;
offsetMap[key] = {feedbackStorageSize, bindData.descriptorCount};
feedbackStorageSize += bindData.descriptorCount * sizeof(uint32_t);
}
}
}
}
uint32_t maxSlot = uint32_t(feedbackStorageSize / sizeof(uint32_t));
// add some extra padding just in case of out-of-bounds writes
feedbackStorageSize += 128;
// if we don't have any array descriptors or printf's to feedback then just return now
if(offsetMap.empty() && !usesPrintf)
return;
if(!result.compute)
{
// if we don't have any stores supported at all, we can't do feedback on the graphics pipeline
if(!m_pDriver->GetDeviceEnabledFeatures().vertexPipelineStoresAndAtomics &&
!m_pDriver->GetDeviceEnabledFeatures().fragmentStoresAndAtomics)
{
return;
}
}
// we go through the driver for all these creations since they need to be properly
// registered in order to be put in the partial replay state
VkResult vkr = VK_SUCCESS;
VkDevice dev = m_Device;
if(feedbackStorageSize > m_BindlessFeedback.FeedbackBuffer.sz)
{
uint32_t flags = GPUBuffer::eGPUBufferGPULocal | GPUBuffer::eGPUBufferSSBO;
if(useBufferAddress)
flags |= GPUBuffer::eGPUBufferAddressable;
m_BindlessFeedback.FeedbackBuffer.Destroy();
m_BindlessFeedback.FeedbackBuffer.Create(m_pDriver, dev, feedbackStorageSize, 1, flags);
}
VkDeviceAddress bufferAddress = 0;
VkDescriptorPool descpool = VK_NULL_HANDLE;
rdcarray<VkDescriptorSetLayout> setLayouts;
rdcarray<VkDescriptorSet> descSets;
VkPipelineLayout pipeLayout = VK_NULL_HANDLE;
if(useBufferAddress)
{
RDCCOMPILE_ASSERT(VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO ==
VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO_EXT,
"KHR and EXT buffer_device_address should be interchangeable here.");
VkBufferDeviceAddressInfo getAddressInfo = {VK_STRUCTURE_TYPE_BUFFER_DEVICE_ADDRESS_INFO};
getAddressInfo.buffer = m_BindlessFeedback.FeedbackBuffer.buf;
if(useBufferAddressKHR)
bufferAddress = m_pDriver->vkGetBufferDeviceAddress(dev, &getAddressInfo);
else
bufferAddress = m_pDriver->vkGetBufferDeviceAddressEXT(dev, &getAddressInfo);
}
else
{
VkDescriptorSetLayoutBinding newBindings[] = {
// output buffer
{
0, VK_DESCRIPTOR_TYPE_STORAGE_BUFFER, 1,
VkShaderStageFlags(result.compute ? VK_SHADER_STAGE_COMPUTE_BIT
: VK_SHADER_STAGE_ALL_GRAPHICS),
NULL,
},
};
RDCCOMPILE_ASSERT(ARRAY_COUNT(newBindings) == 1,
"Should only be one new descriptor for bindless feedback");
// create a duplicate set of descriptor sets, all visible to compute, with bindings shifted to
// account for new ones we need. This also copies the existing bindings into the new sets
PatchReservedDescriptors(pipe, descpool, setLayouts, descSets, VkShaderStageFlagBits(),
newBindings, ARRAY_COUNT(newBindings));
// if the pool failed due to limits, it will be NULL so bail now
if(descpool == VK_NULL_HANDLE)
return;
// create pipeline layout with new descriptor set layouts
{
const rdcarray<VkPushConstantRange> &push =
creationInfo.m_PipelineLayout[pipeInfo.layout].pushRanges;
VkPipelineLayoutCreateInfo pipeLayoutInfo = {
VK_STRUCTURE_TYPE_PIPELINE_LAYOUT_CREATE_INFO,
NULL,
0,
(uint32_t)setLayouts.size(),
setLayouts.data(),
(uint32_t)push.size(),
push.data(),
};
vkr = m_pDriver->vkCreatePipelineLayout(dev, &pipeLayoutInfo, NULL, &pipeLayout);
RDCASSERTEQUAL(vkr, VK_SUCCESS);
// we'll only use one, set both structs to keep things simple
computeInfo.layout = pipeLayout;
graphicsInfo.layout = pipeLayout;
}
// vkUpdateDescriptorSet desc set to point to buffer
VkDescriptorBufferInfo desc = {0};
m_BindlessFeedback.FeedbackBuffer.FillDescriptor(desc);
VkWriteDescriptorSet write = {
VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET,
NULL,
Unwrap(descSets[0]),
0,
0,
1,
VK_DESCRIPTOR_TYPE_STORAGE_BUFFER,
NULL,
&desc,
NULL,
};
ObjDisp(dev)->UpdateDescriptorSets(Unwrap(dev), 1, &write, 0, NULL);
}
// create vertex shader with modified code
VkShaderModuleCreateInfo moduleCreateInfo = {VK_STRUCTURE_TYPE_SHADER_MODULE_CREATE_INFO};
VkShaderModule modules[6] = {};
const rdcstr filename[6] = {
"bindless_vertex.spv", "bindless_hull.spv", "bindless_domain.spv",
"bindless_geometry.spv", "bindless_pixel.spv", "bindless_compute.spv",
};
std::map<uint32_t, PrintfData> printfData[6];
if(result.compute)
{
VkPipelineShaderStageCreateInfo &stage = computeInfo.stage;
const VulkanCreationInfo::ShaderModule &moduleInfo =
creationInfo.m_ShaderModule[pipeInfo.shaders[5].module];
rdcarray<uint32_t> modSpirv = moduleInfo.spirv.GetSPIRV();
if(!Vulkan_Debug_FeedbackDumpDirPath().empty())
FileIO::WriteAll(Vulkan_Debug_FeedbackDumpDirPath() + "/before_" + filename[5], modSpirv);
AnnotateShader(*pipeInfo.shaders[5].refl, *pipeInfo.shaders[5].patchData,
ShaderStage(StageIndex(stage.stage)), stage.pName, offsetMap, maxSlot, false,
bufferAddress, useBufferAddressKHR, modSpirv, printfData[5]);
if(!Vulkan_Debug_FeedbackDumpDirPath().empty())
FileIO::WriteAll(Vulkan_Debug_FeedbackDumpDirPath() + "/after_" + filename[5], modSpirv);
moduleCreateInfo.pCode = modSpirv.data();
moduleCreateInfo.codeSize = modSpirv.size() * sizeof(uint32_t);
vkr = m_pDriver->vkCreateShaderModule(dev, &moduleCreateInfo, NULL, &modules[0]);
RDCASSERTEQUAL(vkr, VK_SUCCESS);
stage.module = modules[0];
}
else
{
bool hasGeom = false;
for(uint32_t i = 0; i < graphicsInfo.stageCount; i++)
{
VkPipelineShaderStageCreateInfo &stage =
(VkPipelineShaderStageCreateInfo &)graphicsInfo.pStages[i];
if((stage.stage & VK_SHADER_STAGE_GEOMETRY_BIT) != 0)
{
hasGeom = true;
break;
}
}
bool usePrimitiveID =
!hasGeom && m_pDriver->GetDeviceEnabledFeatures().geometryShader != VK_FALSE;
for(uint32_t i = 0; i < graphicsInfo.stageCount; i++)
{
VkPipelineShaderStageCreateInfo &stage =
(VkPipelineShaderStageCreateInfo &)graphicsInfo.pStages[i];
if(stage.stage & VK_SHADER_STAGE_FRAGMENT_BIT)
{
if(!m_pDriver->GetDeviceEnabledFeatures().fragmentStoresAndAtomics)
continue;
}
else
{
if(!m_pDriver->GetDeviceEnabledFeatures().vertexPipelineStoresAndAtomics)
continue;
}
int idx = StageIndex(stage.stage);
const VulkanCreationInfo::ShaderModule &moduleInfo =
creationInfo.m_ShaderModule[pipeInfo.shaders[idx].module];
rdcarray<uint32_t> modSpirv = moduleInfo.spirv.GetSPIRV();
if(!Vulkan_Debug_FeedbackDumpDirPath().empty())
FileIO::WriteAll(Vulkan_Debug_FeedbackDumpDirPath() + "/before_" + filename[idx], modSpirv);
AnnotateShader(*pipeInfo.shaders[idx].refl, *pipeInfo.shaders[idx].patchData,
ShaderStage(StageIndex(stage.stage)), stage.pName, offsetMap, maxSlot,
usePrimitiveID, bufferAddress, useBufferAddressKHR, modSpirv, printfData[idx]);
if(!Vulkan_Debug_FeedbackDumpDirPath().empty())
FileIO::WriteAll(Vulkan_Debug_FeedbackDumpDirPath() + "/after_" + filename[idx], modSpirv);
moduleCreateInfo.pCode = modSpirv.data();
moduleCreateInfo.codeSize = modSpirv.size() * sizeof(uint32_t);
vkr = m_pDriver->vkCreateShaderModule(dev, &moduleCreateInfo, NULL, &modules[i]);
RDCASSERTEQUAL(vkr, VK_SUCCESS);
stage.module = modules[i];
}
}
VkPipeline feedbackPipe;
if(result.compute)
{
vkr = m_pDriver->vkCreateComputePipelines(m_Device, VK_NULL_HANDLE, 1, &computeInfo, NULL,
&feedbackPipe);
RDCASSERTEQUAL(vkr, VK_SUCCESS);
}
else
{
vkr = m_pDriver->vkCreateGraphicsPipelines(m_Device, VK_NULL_HANDLE, 1, &graphicsInfo, NULL,
&feedbackPipe);
RDCASSERTEQUAL(vkr, VK_SUCCESS);
}
// make copy of state to draw from
VulkanRenderState modifiedstate = state;
VulkanStatePipeline &modifiedpipe = result.compute ? modifiedstate.compute : modifiedstate.graphics;
// bind created pipeline to partial replay state
modifiedpipe.pipeline = GetResID(feedbackPipe);
if(!useBufferAddress)
{
// replace descriptor set IDs with our temporary sets. The offsets we keep the same. If the
// original draw had no sets, we ensure there's room (with no offsets needed)
if(modifiedpipe.descSets.empty())
modifiedpipe.descSets.resize(1);
for(size_t i = 0; i < descSets.size(); i++)
{
modifiedpipe.descSets[i].pipeLayout = GetResID(pipeLayout);
modifiedpipe.descSets[i].descSet = GetResID(descSets[i]);
}
}
{
VkCommandBuffer cmd = m_pDriver->GetNextCmd();
VkCommandBufferBeginInfo beginInfo = {VK_STRUCTURE_TYPE_COMMAND_BUFFER_BEGIN_INFO, NULL,
VK_COMMAND_BUFFER_USAGE_ONE_TIME_SUBMIT_BIT};
vkr = ObjDisp(dev)->BeginCommandBuffer(Unwrap(cmd), &beginInfo);
RDCASSERTEQUAL(vkr, VK_SUCCESS);
// fill destination buffer with 0s to ensure a baseline to then feedback against
ObjDisp(dev)->CmdFillBuffer(Unwrap(cmd), Unwrap(m_BindlessFeedback.FeedbackBuffer.buf), 0,
feedbackStorageSize, 0);
VkBufferMemoryBarrier feedbackbufBarrier = {
VK_STRUCTURE_TYPE_BUFFER_MEMORY_BARRIER,
NULL,
VK_ACCESS_TRANSFER_WRITE_BIT,
VK_ACCESS_SHADER_WRITE_BIT,
VK_QUEUE_FAMILY_IGNORED,
VK_QUEUE_FAMILY_IGNORED,
Unwrap(m_BindlessFeedback.FeedbackBuffer.buf),
0,
feedbackStorageSize,
};
// wait for the above fill to finish.
DoPipelineBarrier(cmd, 1, &feedbackbufBarrier);
if(result.compute)
{
modifiedstate.BindPipeline(m_pDriver, cmd, VulkanRenderState::BindCompute, true);
ObjDisp(cmd)->CmdDispatch(Unwrap(cmd), drawcall->dispatchDimension[0],
drawcall->dispatchDimension[1], drawcall->dispatchDimension[2]);
}
else
{
modifiedstate.BeginRenderPassAndApplyState(m_pDriver, cmd, VulkanRenderState::BindGraphics);
m_pDriver->ReplayDraw(cmd, *drawcall);
modifiedstate.EndRenderPass(cmd);
}
vkr = ObjDisp(dev)->EndCommandBuffer(Unwrap(cmd));
RDCASSERTEQUAL(vkr, VK_SUCCESS);
m_pDriver->SubmitCmds();
m_pDriver->FlushQ();
}
bytebuf data;
GetBufferData(GetResID(m_BindlessFeedback.FeedbackBuffer.buf), 0, 0, data);
for(auto it = offsetMap.begin(); it != offsetMap.end(); ++it)
{
uint32_t *feedbackData = (uint32_t *)(data.data() + it->second.offset);
BindpointIndex used;
used.bindset = it->first.set;
used.bind = it->first.binding;
for(uint32_t i = 0; i < it->second.numEntries; i++)
{
if(feedbackData[i])
{
used.arrayIndex = i;
result.used.push_back(used);
}
}
}
result.valid = true;
uint32_t *printfBuf = (uint32_t *)data.data();
uint32_t *printfBufEnd = (uint32_t *)(data.data() + Vulkan_Debug_PrintfBufferSize());
if(usesPrintf && *printfBuf > 0)
{
uint32_t wordsNeeded = *printfBuf;
if(wordsNeeded > Vulkan_Debug_PrintfBufferSize())
{
RDCLOG("printf buffer overflowed, needed %u bytes but printf buffer is only %u bytes",
wordsNeeded * 4, Vulkan_Debug_PrintfBufferSize());
}
printfBuf++;
while(*printfBuf && printfBuf < printfBufEnd)
{
ShaderStage stage = ShaderStage((*printfBuf) >> ShaderStageHeaderBitShift);
uint32_t printfID = *printfBuf & 0xfffffffU;
printfBuf++;
if(stage < ShaderStage::Count)
{
auto it = printfData[(uint32_t)stage].find(printfID);
if(it == printfData[(uint32_t)stage].end())
{
RDCERR("Error parsing DebugPrintf buffer, unexpected printf ID %x from header %x",
printfID, *printfBuf);
break;
}
uint32_t *location = printfBuf;
printfBuf += 3;
const PrintfData &fmt = it->second;
ShaderPrintfArgs args(printfBuf, fmt);
printfBuf += fmt.payloadWords;
// this message overflowed, don't process it
if(printfBuf >= printfBufEnd)
break;
ShaderMessage msg;
msg.stage = stage;
const VulkanCreationInfo::Pipeline::Shader &sh = pipeInfo.shaders[(uint32_t)stage];
{
VulkanCreationInfo::ShaderModule &mod = creationInfo.m_ShaderModule[sh.module];
VulkanCreationInfo::ShaderModuleReflection &modrefl =
mod.GetReflection(sh.entryPoint, pipe.pipeline);
modrefl.PopulateDisassembly(mod.spirv);
const std::map<size_t, uint32_t> instructionLines = modrefl.instructionLines;
auto instit = instructionLines.find(printfID);
if(instit != instructionLines.end())
msg.disassemblyLine = (int32_t)instit->second;
else
msg.disassemblyLine = -1;
}
if(stage == ShaderStage::Compute)
{
for(int x = 0; x < 3; x++)
{
uint32_t threadDimX = sh.refl->dispatchThreadsDimension[x];
msg.location.compute.workgroup[x] = location[x] / threadDimX;
msg.location.compute.thread[x] = location[x] % threadDimX;
}
}
else if(stage == ShaderStage::Vertex)
{
msg.location.vertex.vertexIndex = location[0];
if(!(drawcall->flags & DrawFlags::Indexed))
{
// for non-indexed draws get back to 0-based index
msg.location.vertex.vertexIndex -= drawcall->vertexOffset;
}
// go back to a 0-based instance index
msg.location.vertex.instance = location[1] - drawcall->instanceOffset;
msg.location.vertex.view = location[2];
}
else
{
msg.location.pixel.x = location[0] >> 16U;
msg.location.pixel.y = location[0] & 0xffff;
msg.location.pixel.sample = location[1];
msg.location.pixel.primitive = location[2];
RDCLOG("pixel %u, %u", msg.location.pixel.x, msg.location.pixel.y);
}
msg.message = StringFormat::FmtArgs(fmt.format.c_str(), args);
result.messages.push_back(msg);
}
else
{
RDCERR("Error parsing DebugPrintf buffer, unexpected stage %x from header %x", stage,
*printfBuf);
break;
}
}
}
if(descpool != VK_NULL_HANDLE)
{
// delete descriptors. Technically we don't have to free the descriptor sets, but our tracking
// on
// replay doesn't handle destroying children of pooled objects so we do it explicitly anyway.
m_pDriver->vkFreeDescriptorSets(dev, descpool, (uint32_t)descSets.size(), descSets.data());
m_pDriver->vkDestroyDescriptorPool(dev, descpool, NULL);
}
for(VkDescriptorSetLayout layout : setLayouts)
m_pDriver->vkDestroyDescriptorSetLayout(dev, layout, NULL);
// delete pipeline layout
m_pDriver->vkDestroyPipelineLayout(dev, pipeLayout, NULL);
// delete pipeline
m_pDriver->vkDestroyPipeline(dev, feedbackPipe, NULL);
// delete shader/shader module
for(size_t i = 0; i < ARRAY_COUNT(modules); i++)
if(modules[i] != VK_NULL_HANDLE)
m_pDriver->vkDestroyShaderModule(dev, modules[i], NULL);
// replay from the start as we may have corrupted state while fetching the above feedback.
m_pDriver->ReplayLog(0, eventId, eReplay_Full);
}
#if ENABLED(ENABLE_UNIT_TESTS)
#undef Always
#undef None
#include "catch/catch.hpp"
TEST_CASE("Test printf format string mangling", "[vulkan]")
{
SECTION("Vector format expansion")
{
CHECK(PatchFormatString("hello %f normal %i string") == "hello %f normal %i string");
CHECK(PatchFormatString("hello %% normal %2i string") == "hello %% normal %2i string");
CHECK(PatchFormatString("hello %fv normal %iv string") == "hello %fv normal %iv string");
CHECK(PatchFormatString("hello %02.3fv normal % 2.fiv string") ==
"hello %02.3fv normal % 2.fiv string");
CHECK(PatchFormatString("vector string: %v2f | %v3i") == "vector string: %f, %f | %i, %i, %i");
CHECK(PatchFormatString("vector with precision: %04.3v4f !") ==
"vector with precision: %04.3f, %04.3f, %04.3f, %04.3f !");
CHECK(PatchFormatString("vector at end %v2f") == "vector at end %f, %f");
CHECK(PatchFormatString("%v3f vector at start") == "%f, %f, %f vector at start");
CHECK(PatchFormatString("%v2f") == "%f, %f");
CHECK(PatchFormatString("%v2u") == "%u, %u");
};
SECTION("64-bit format twiddling")
{
CHECK(PatchFormatString("hello %ul") == "hello %llu");
CHECK(PatchFormatString("%ul hello") == "%llu hello");
CHECK(PatchFormatString("%ul") == "%llu");
CHECK(PatchFormatString("hello %04ul there") == "hello %04llu there");
CHECK(PatchFormatString("hello %v2ul there") == "hello %llu, %llu there");
CHECK(PatchFormatString("hello %u l there") == "hello %u l there");
CHECK(PatchFormatString("%v2u") == "%u, %u");
CHECK(PatchFormatString("%v2ul") == "%llu, %llu");
};
};
#endif // ENABLED(ENABLE_UNIT_TESTS)
| [
"[email protected]"
] | |
c6dc8a4eeb4c4ef011fb620b35a87f4cc45f8753 | cb24f64c0eee77f80ef07538e845a6278b224214 | /ui/ofxSIPalettePicker.cpp | e8244a110d613eadeda2d33e030639d3888642aa | [] | no_license | martial/ofxSuperInterface | 34c076ec2a522543da159010ff925c121337354a | c1f8e638a9a7d3374d580195cc2d12ae9fc5415d | refs/heads/master | 2021-01-01T20:48:54.464267 | 2012-04-04T13:47:54 | 2012-04-04T13:47:54 | 2,333,060 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,995 | cpp | /*
* ofxSIPalettePicker.cpp
* MODULAR_SHIP
*
* Created by Martial on 12/09/2011.
*
*
*/
#include "ofxSIPalettePicker.h"
ofxSIPalettePicker::ofxSIPalettePicker() {
}
void ofxSIPalettePicker:: setup(ofxSuperInterface * mom, ofColor * currentColor, string label, int xGridPos, int yGridPos , int wGridSize , int hGridSize ) {
this->gridPos.set(xGridPos, yGridPos);
this->wGridSize = wGridSize;
this->hGridSize = hGridSize;
this->settings->label = label;
this->currentColor = currentColor;
ofxSIComponent::setup(mom, label);
txtLabel.setup(mom, pos.x, pos.y + height, label);
}
void ofxSIPalettePicker::addColor(ofColor color) {
colors.push_back(color);
}
void ofxSIPalettePicker::setColor(ofColor color){
currentColor->r = color.r;
currentColor->g = color.g;
currentColor->b = color.b;
}
void ofxSIPalettePicker::update() {
ofxSIComponent::update();
if (tweens[0].isRunning()){
currentColor->set(tweens[0].update(), tweens[1].update(),tweens[2].update());
eventsArgs.floatVals.clear();
float r = currentColor->r;
float g = currentColor->g;
float b = currentColor->b;
eventsArgs.floatVals.push_back(&r);
eventsArgs.floatVals.push_back(&g);
eventsArgs.floatVals.push_back(&b);
ofNotifyEvent(eventUpdateValues, eventsArgs, this);
}
if ( isMouseDown ) {
int mouseX = ofGetMouseX() - pos.x;
int size = colors.size();
float rectDim = float(width) / float(size);
rollOverCurrentID = floor ( mouseX / rectDim);
currentID = rollOverCurrentID;
for ( int i=0; i<4; i++) {
tweens[i].setParameters(quint,ofxTween::easeOut,currentColor->v[i],colors[currentID].v[i],3000,0);
}
//int dumber = 0;
ofNotifyEvent(onClickEvent,this->settings->label,this);
}
else {
rollOverCurrentID = -1;
}
}
void ofxSIPalettePicker::setRandomColor () {
int rdmVal = floor(ofRandom(0, colors.size()-1));
for ( int i=0; i<4; i++) {
tweens[i].setParameters(quint,ofxTween::easeOut,currentColor->v[i],colors[rdmVal].v[i],3000,0);
}
}
void ofxSIPalettePicker::draw() {
ofxSIComponent::draw();
glPushMatrix();
glTranslatef(pos.x, pos.y,0);
int size = colors.size();
float rectDim = float(width) / float(size);
float xPos = 0;
int previewHeight = 10;
ofEnableAlphaBlending();
for ( int i=0; i < size; i++) {
float alpha = ( i==currentID || i==rollOverCurrentID ) ? 255 : 125;
ofSetColor(colors[i].r, colors[i].g, colors[i].b, alpha);
ofRect(xPos, 0, rectDim-1, height-previewHeight );
xPos+=rectDim;
}
ofDisableAlphaBlending();
ofSetColor(currentColor->r, currentColor->g, currentColor->b);
ofRect(0, height-previewHeight, width, previewHeight);
glPopMatrix();
txtLabel.pos.x = pos.x + 3;
txtLabel.pos.y = pos.y + height + txtLabel.getBoundingBox().height +3;
txtLabel.draw();
} | [
"[email protected]"
] | |
bcf8061c196285c572c1beb2bd8219a95bdd2ff6 | 1ad3103df1738d34d98417f4f2bfdbfdf467893c | /Danmaku Engine/Danmaku/Player.cpp | dd807708f2b693c1cdf3b2b170488e5de7590994 | [] | no_license | venfabio/Games-Development-Architecture | 20a3003068aef86ae0332696dfad5f1474dbc06f | 2cf17c14593707a76729a2226733c8adb1171163 | refs/heads/master | 2020-08-30T22:33:27.593253 | 2019-10-30T11:10:20 | 2019-10-30T11:10:20 | 218,508,699 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,685 | cpp | #include "Player.h"
const float Player::ACCELERATION = 40.0f;
const float Player::MAX_SPEED = 4.0f;
/******************************************************************************************************************/
Player::Player()
{
}
/******************************************************************************************************************/
Player::~Player()
{
}
/******************************************************************************************************************/
void Player::Accelerate(float amt)
{
Vector4 thrust(0, amt);
_velocity += thrust;
}
/******************************************************************************************************************/
void Player::Update(double deltaTime)
{
Vector4 vel = _velocity;
vel *= (float)deltaTime;
_position += vel;
// Boundaries on X and Y axes
if (_position.x() < -1)
_position.x(-1);
else if (_position.x() > 1)
_position.x(1);
if (_position.y() < -1)
_position.y(-1);
else if (_position.y() > 1)
_position.y(1);
// Cap speed
_velocity.limitTo(MAX_SPEED);
}
/******************************************************************************************************************/
void Player::GoLeft(float amt)
{
Vector4 thrust(-amt, 0);
_velocity += thrust;
}
/******************************************************************************************************************/
void Player::GoRight(float amt)
{
Vector4 thrust(amt, 0);
_velocity += thrust;
}
/******************************************************************************************************************/
void Player::Reverse(float amt)
{
Vector4 thrust(0, -amt);
_velocity += thrust;
} | [
"[email protected]"
] | |
aa8f65c0b087728e0e5cfdc7359901ce3b4b47ef | 5009c39b5ae28dc019998f8b0a467dbd05c4612c | /include/particleSplittingOperation.hh | f0b2c9e46708ef3fba1cc9882e55f7bb25edf8b6 | [] | no_license | yacubus-bishcus/ZKBrem | 4df527cc7855e088e092c43db39c36c249014c97 | 79c29421fb77ce627e53a2845a8e22a8cad82add | refs/heads/master | 2023-03-08T19:14:22.656948 | 2021-02-25T02:09:05 | 2021-02-25T02:09:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,180 | hh | #ifndef particleSplittingOperation_hh
#define particleSplittingOperation_hh 1
#include "G4VBiasingOperation.hh"
#include "G4ParticleChange.hh"
#include "G4ParticleChangeForNothing.hh"
class G4LogicalVolume;
class particleSplittingOperation : public G4VBiasingOperation
{
public:
particleSplittingOperation(G4String name);
virtual ~particleSplittingOperation();
virtual G4double DistanceToApplyOperation(const G4Track*, G4double, G4ForceCondition* condition);
virtual G4VParticleChange *GenerateBiasingFinalState(const G4Track*, const G4Step*);
inline void SetSplittingFactor(G4int splittingFactor) {fSplittingFactor = splittingFactor;};
inline G4int GetSplittingFactor() {return fSplittingFactor;};
// unused but required virtual methods
virtual const G4VBiasingInteractionLaw *ProvideOccurenceBiasingInteractionLaw(const G4BiasingProcessInterface* /*, G4ForceCondition&*/) {return 0;};
virtual G4VParticleChange *ApplyFinalStateBiasing(const G4BiasingProcessInterface*, const G4Track*, const G4Step* /*, G4bool&*/) {return 0;};
private:
G4ParticleChange fParticleChange;
G4ParticleChangeForNothing fParticleChangeForNothing;
G4int fSplittingFactor;
};
#endif
| [
"[email protected]"
] | |
3c03e50753ab2532e2ab4046d61eba8abfe1b377 | 460f981dfe1a05f14d2a4cdc6cc71e9ad798b785 | /3/amd64/envs/navigator/include/qt/QtDataVisualization/5.9.7/QtDataVisualization/private/qabstract3dseries_p.h | 0762386f45f4e128c91724f3cb4fc480b220736e | [
"LicenseRef-scancode-proprietary-license",
"BSD-3-Clause",
"Intel",
"LicenseRef-scancode-unknown-license-reference",
"GPL-2.0-only",
"GPL-1.0-or-later",
"LGPL-2.0-or-later",
"LicenseRef-scancode-mit-old-style",
"dtoa",
"LicenseRef-scancode-public-domain-disclaimer",
"Zlib",
"LicenseRef-scancode-public-domain",
"MIT",
"BSD-2-Clause"
] | permissive | DFO-Ocean-Navigator/navigator-toolchain | d8c7351b477e66d674b50da54ec6ddc0f3a325ee | 930d26886fdf8591b51da9d53e2aca743bf128ba | refs/heads/master | 2022-11-05T18:57:30.938372 | 2021-04-22T02:02:45 | 2021-04-22T02:02:45 | 234,445,230 | 0 | 1 | BSD-3-Clause | 2022-10-25T06:46:23 | 2020-01-17T01:26:49 | C++ | UTF-8 | C++ | false | false | 6,230 | h | /****************************************************************************
**
** Copyright (C) 2016 The Qt Company Ltd.
** Contact: https://www.qt.io/licensing/
**
** This file is part of the Qt Data Visualization module of the Qt Toolkit.
**
** $QT_BEGIN_LICENSE:GPL$
** Commercial License Usage
** Licensees holding valid commercial Qt licenses may use this file in
** accordance with the commercial license agreement provided with the
** Software or, alternatively, in accordance with the terms contained in
** a written agreement between you and The Qt Company. For licensing terms
** and conditions see https://www.qt.io/terms-conditions. For further
** information use the contact form at https://www.qt.io/contact-us.
**
** GNU General Public License Usage
** Alternatively, this file may be used under the terms of the GNU
** General Public License version 3 or (at your option) any later version
** approved by the KDE Free Qt Foundation. The licenses are as published by
** the Free Software Foundation and appearing in the file LICENSE.GPL3
** included in the packaging of this file. Please review the following
** information to ensure the GNU General Public License requirements will
** be met: https://www.gnu.org/licenses/gpl-3.0.html.
**
** $QT_END_LICENSE$
**
****************************************************************************/
//
// W A R N I N G
// -------------
//
// This file is not part of the QtDataVisualization API. It exists purely as an
// implementation detail. This header file may change from version to
// version without notice, or even be removed.
//
// We mean it.
#ifndef QABSTRACT3DSERIES_P_H
#define QABSTRACT3DSERIES_P_H
#include "datavisualizationglobal_p.h"
#include "qabstract3dseries.h"
QT_BEGIN_NAMESPACE_DATAVISUALIZATION
class QAbstractDataProxy;
class Abstract3DController;
struct QAbstract3DSeriesChangeBitField {
bool meshChanged : 1;
bool meshSmoothChanged : 1;
bool meshRotationChanged : 1;
bool userDefinedMeshChanged : 1;
bool colorStyleChanged : 1;
bool baseColorChanged : 1;
bool baseGradientChanged : 1;
bool singleHighlightColorChanged : 1;
bool singleHighlightGradientChanged : 1;
bool multiHighlightColorChanged : 1;
bool multiHighlightGradientChanged : 1;
bool nameChanged : 1;
bool itemLabelChanged : 1;
bool itemLabelVisibilityChanged : 1;
bool visibilityChanged : 1;
QAbstract3DSeriesChangeBitField()
: meshChanged(true),
meshSmoothChanged(true),
meshRotationChanged(true),
userDefinedMeshChanged(true),
colorStyleChanged(true),
baseColorChanged(true),
baseGradientChanged(true),
singleHighlightColorChanged(true),
singleHighlightGradientChanged(true),
multiHighlightColorChanged(true),
multiHighlightGradientChanged(true),
nameChanged(true),
itemLabelChanged(true),
itemLabelVisibilityChanged(true),
visibilityChanged(true)
{
}
};
struct QAbstract3DSeriesThemeOverrideBitField {
bool colorStyleOverride : 1;
bool baseColorOverride : 1;
bool baseGradientOverride : 1;
bool singleHighlightColorOverride : 1;
bool singleHighlightGradientOverride : 1;
bool multiHighlightColorOverride : 1;
bool multiHighlightGradientOverride : 1;
QAbstract3DSeriesThemeOverrideBitField()
: colorStyleOverride(false),
baseColorOverride(false),
baseGradientOverride(false),
singleHighlightColorOverride(false),
singleHighlightGradientOverride(false),
multiHighlightColorOverride(false),
multiHighlightGradientOverride(false)
{
}
};
class QAbstract3DSeriesPrivate : public QObject
{
Q_OBJECT
public:
QAbstract3DSeriesPrivate(QAbstract3DSeries *q, QAbstract3DSeries::SeriesType type);
virtual ~QAbstract3DSeriesPrivate();
QAbstractDataProxy *dataProxy() const;
virtual void setDataProxy(QAbstractDataProxy *proxy);
virtual void setController(Abstract3DController *controller);
virtual void connectControllerAndProxy(Abstract3DController *newController) = 0;
virtual void createItemLabel() = 0;
void setItemLabelFormat(const QString &format);
void setVisible(bool visible);
void setMesh(QAbstract3DSeries::Mesh mesh);
void setMeshSmooth(bool enable);
void setMeshRotation(const QQuaternion &rotation);
void setUserDefinedMesh(const QString &meshFile);
void setColorStyle(Q3DTheme::ColorStyle style);
void setBaseColor(const QColor &color);
void setBaseGradient(const QLinearGradient &gradient);
void setSingleHighlightColor(const QColor &color);
void setSingleHighlightGradient(const QLinearGradient &gradient);
void setMultiHighlightColor(const QColor &color);
void setMultiHighlightGradient(const QLinearGradient &gradient);
void setName(const QString &name);
void resetToTheme(const Q3DTheme &theme, int seriesIndex, bool force);
QString itemLabel();
void markItemLabelDirty();
inline bool itemLabelDirty() const { return m_itemLabelDirty; }
void setItemLabelVisible(bool visible);
QAbstract3DSeriesChangeBitField m_changeTracker;
QAbstract3DSeriesThemeOverrideBitField m_themeTracker;
QAbstract3DSeries *q_ptr;
QAbstract3DSeries::SeriesType m_type;
QString m_itemLabelFormat;
QAbstractDataProxy *m_dataProxy;
bool m_visible;
Abstract3DController *m_controller;
QAbstract3DSeries::Mesh m_mesh;
bool m_meshSmooth;
QQuaternion m_meshRotation;
QString m_userDefinedMesh;
Q3DTheme::ColorStyle m_colorStyle;
QColor m_baseColor;
QLinearGradient m_baseGradient;
QColor m_singleHighlightColor;
QLinearGradient m_singleHighlightGradient;
QColor m_multiHighlightColor;
QLinearGradient m_multiHighlightGradient;
QString m_name;
QString m_itemLabel;
bool m_itemLabelDirty;
bool m_itemLabelVisible;
};
QT_END_NAMESPACE_DATAVISUALIZATION
#endif
| [
"[email protected]"
] | |
e9b139f429b545f358d14e5c3c2cb9e03c6508c1 | 66688136c619b655dc35f3f69b6c33dd218da65b | /code/Common_engine/voe/common_audio/resampler/push_resampler.cc | 1a8d24e5356bbc5971125b1df1246c8d92470b85 | [] | no_license | forssil/GCCPT | 6ddc0f5707d314fddeeb8be831ad06250b686791 | 0249f5a115b96e7741c0292b5fc3a4e61a53c43c | refs/heads/master | 2021-06-19T00:12:58.608196 | 2015-10-08T01:17:35 | 2015-10-08T01:17:35 | 32,770,766 | 0 | 0 | null | 2015-04-15T07:21:05 | 2015-03-24T02:16:19 | null | UTF-8 | C++ | false | false | 3,843 | cc | /*
* Copyright (c) 2013 The WebRTC project authors. All Rights Reserved.
*
* Use of this source code is governed by a BSD-style license
* that can be found in the LICENSE file in the root of the source
* tree. An additional intellectual property rights grant can be found
* in the file PATENTS. All contributing project authors may
* be found in the AUTHORS file in the root of the source tree.
*/
#include "voe/common_audio/resampler/include/push_resampler.h"
#include <cstring>
#include "voe/common_audio/include/audio_util.h"
#include "voe/common_audio/resampler/include/resampler.h"
#include "voe/common_audio/resampler/push_sinc_resampler.h"
namespace webrtc {
PushResampler::PushResampler()
: sinc_resampler_(NULL),
sinc_resampler_right_(NULL),
src_sample_rate_hz_(0),
dst_sample_rate_hz_(0),
num_channels_(0),
src_left_(NULL),
src_right_(NULL),
dst_left_(NULL),
dst_right_(NULL) {
}
PushResampler::~PushResampler() {
}
int PushResampler::InitializeIfNeeded(int src_sample_rate_hz,
int dst_sample_rate_hz,
int num_channels) {
if (src_sample_rate_hz == src_sample_rate_hz_ &&
dst_sample_rate_hz == dst_sample_rate_hz_ &&
num_channels == num_channels_) {
// No-op if settings haven't changed.
return 0;
}
if (src_sample_rate_hz <= 0 || dst_sample_rate_hz <= 0 ||
num_channels <= 0 || num_channels > 2) {
return -1;
}
src_sample_rate_hz_ = src_sample_rate_hz;
dst_sample_rate_hz_ = dst_sample_rate_hz;
num_channels_ = num_channels;
const int src_size_10ms_mono = src_sample_rate_hz / 100;
const int dst_size_10ms_mono = dst_sample_rate_hz / 100;
sinc_resampler_.reset(new PushSincResampler(src_size_10ms_mono,
dst_size_10ms_mono));
if (num_channels_ == 2) {
src_left_.reset(new int16_t[src_size_10ms_mono]);
src_right_.reset(new int16_t[src_size_10ms_mono]);
dst_left_.reset(new int16_t[dst_size_10ms_mono]);
dst_right_.reset(new int16_t[dst_size_10ms_mono]);
sinc_resampler_right_.reset(new PushSincResampler(src_size_10ms_mono,
dst_size_10ms_mono));
}
return 0;
}
int PushResampler::Resample(const int16_t* src, int src_length,
int16_t* dst, int dst_capacity) {
const int src_size_10ms = src_sample_rate_hz_ * num_channels_ / 100;
const int dst_size_10ms = dst_sample_rate_hz_ * num_channels_ / 100;
if (src_length != src_size_10ms || dst_capacity < dst_size_10ms) {
return -1;
}
if (src_sample_rate_hz_ == dst_sample_rate_hz_) {
// The old resampler provides this memcpy facility in the case of matching
// sample rates, so reproduce it here for the sinc resampler.
memcpy(dst, src, src_length * sizeof(int16_t));
return src_length;
}
if (num_channels_ == 2) {
const int src_length_mono = src_length / num_channels_;
const int dst_capacity_mono = dst_capacity / num_channels_;
int16_t* deinterleaved[] = {src_left_.get(), src_right_.get()};
Deinterleave(src, src_length_mono, num_channels_, deinterleaved);
int dst_length_mono =
sinc_resampler_->Resample(src_left_.get(), src_length_mono,
dst_left_.get(), dst_capacity_mono);
sinc_resampler_right_->Resample(src_right_.get(), src_length_mono,
dst_right_.get(), dst_capacity_mono);
deinterleaved[0] = dst_left_.get();
deinterleaved[1] = dst_right_.get();
Interleave(deinterleaved, dst_length_mono, num_channels_, dst);
return dst_length_mono * num_channels_;
} else {
return sinc_resampler_->Resample(src, src_length, dst, dst_capacity);
}
}
} // namespace webrtc
| [
"[email protected]"
] | |
b1240af052c326e72167ec150e22fc2ae1ab0e91 | 56a2235810d493bf17c5b684334685deddacd946 | /test/emulator/src/ros_wrapper.cpp | c4f980eeac0ccd950461ef0319eb18713d84cc0c | [
"Apache-2.0"
] | permissive | SICKAG/sick_scan | ddfd7bb1d7981dc4ae3de35bbe77c8d886612469 | b44cd27a3d385e04bc098725d441fb6c42067eb9 | refs/heads/master | 2023-01-25T01:36:36.670218 | 2022-09-05T10:25:24 | 2022-09-05T10:25:24 | 113,834,423 | 137 | 122 | Apache-2.0 | 2023-01-17T09:43:08 | 2017-12-11T08:46:30 | C++ | UTF-8 | C++ | false | false | 8,309 | cpp | /*
* @brief ros_wrapper encapsulates the ROS API and switches ROS specific implementation
* between ROS 1 and ROS 2.
*
* Copyright (C) 2020 Ing.-Buero Dr. Michael Lehning, Hildesheim
* Copyright (C) 2020 SICK AG, Waldkirch
*
* 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.
*
* 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 SICK AG nor the names of its
* contributors may be used to endorse or promote products derived from
* this software without specific prior written permission
* * Neither the name of Ing.-Buero Dr. Michael Lehning 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.
*
* Authors:
* Michael Lehning <[email protected]>
*
* Copyright 2020 SICK AG
* Copyright 2020 Ing.-Buero Dr. Michael Lehning
*
*/
#include <thread>
#include "sick_scan/ros_wrapper.h"
#if defined __ROS_VERSION && __ROS_VERSION == 2
static rclcpp::Clock s_wrapper_clock;
#endif
/** Creates a new ros node, shortcut for new ros::NodeHandle() on ROS1 resp. rclcpp::Node::make_shared(node_name) on ROS2 */
ROS::NodePtr ROS::createNode(const std::string& node_name)
{
ROS::NodePtr nh = 0;
#if defined __ROS_VERSION && __ROS_VERSION == 1
nh = new ros::NodeHandle();
#elif defined __ROS_VERSION && __ROS_VERSION == 2
rclcpp::NodeOptions node_options;
node_options.allow_undeclared_parameters(true);
nh = rclcpp::Node::make_shared(node_name, "", node_options);
#endif
double timestamp_sec = ROS::secondsSinceStart(ROS::now());
if ((timestamp_sec = ROS::secondsSinceStart(ROS::now())) < 0) // insure start timestamp after initialization of the first node
ROS_WARN_STREAM("## ERROR ROS::createNode(): time confusion, ROS::secondsSinceStart(ROS::now()) returned negative seconds " << timestamp_sec);
return nh;
}
#if defined __ROS_VERSION && __ROS_VERSION == 2
/** ROS1-/ROS2-compatible shortcut for rclcpp::init(argc, argv); */
void ROS::init(int argc, char** argv, const std::string nodename)
{
rclcpp::init(argc, argv);
}
#endif
/** ROS1-/ROS2-compatible shortcut for ros::spin(); */
#if defined __ROS_VERSION && __ROS_VERSION == 1
void ROS::spin(ROS::NodePtr nh)
{
ros::spin();
}
#endif
/** Deletes a ros node */
void ROS::deleteNode(ROS::NodePtr & node)
{
#if defined __ROS_VERSION && __ROS_VERSION == 1
if(node)
{
delete(node);
node = 0;
}
#endif
}
/** Shortcut to replace ros::Duration(seconds).sleep() by std::thread */
void ROS::sleep(double seconds)
{
std::this_thread::sleep_for(std::chrono::microseconds((int64_t)(1.0e6*seconds)));
}
/** Shortcut to ros::Time::now() on ROS1 resp. rclcpp::Clock::now() on ROS2 */
ROS::Time ROS::now(void)
{
#if defined __ROS_VERSION && __ROS_VERSION == 1
return ros::Time::now();
#elif defined __ROS_VERSION && __ROS_VERSION == 2
return s_wrapper_clock.now();
#else
return 0;
#endif
}
/** Splits a ROS::Duration into seconds and nanoseconds part */
void ROS::splitTime(ROS::Duration time, uint32_t& seconds, uint32_t& nanoseconds)
{
#if defined __ROS_VERSION && __ROS_VERSION == 1
seconds = time.sec;
nanoseconds = time.nsec;
#elif defined __ROS_VERSION && __ROS_VERSION == 2
seconds = (uint32_t)(time.nanoseconds() / 1000000000);
nanoseconds = (uint32_t)(time.nanoseconds() - 1000000000 * seconds);
#endif
}
/** Splits a ROS::Time into seconds and nanoseconds part */
void ROS::splitTime(ROS::Time time, uint32_t& seconds, uint32_t& nanoseconds)
{
#if defined __ROS_VERSION && __ROS_VERSION == 1
seconds = time.sec;
nanoseconds = time.nsec;
#elif defined __ROS_VERSION && __ROS_VERSION == 2
seconds = (uint32_t)(time.nanoseconds() / 1000000000);
nanoseconds = (uint32_t)(time.nanoseconds() - 1000000000 * seconds);
#endif
}
/** Shortcut to return ros::Time(msg_header->stamp.sec,msg_header->stamp.nsec) on ROS1 resp. rclcpp::Time(msg_header->stamp.sec,msg_header->stamp.nanosec) on ROS2 */
ROS::Time ROS::timeFromHeader(const std_msgs::Header* msg_header)
{
return ROS::Time(std::max(0,(int32_t)msg_header->stamp.sec), msg_header->stamp.NSEC);
}
/** Returns a time (type ros::Time on ROS1 resp. rclcpp::Time on ROS2) from a given amount of seconds.
** Note: ros::Time(1) initializes 1 second, while rclcpp::Time(1) initializes 1 nanosecond.
** Do not use the Time constructor with one parameter! Always use ROS::timeFromSec(seconds)
** or ROS::Time(int32_t seconds, uint32_t nanoseconds). */
ROS::Time ROS::timeFromSec(double seconds)
{
int32_t i32seconds = (int32_t)(seconds);
int32_t i32nanoseconds = (int32_t)(1000000000 * (seconds - i32seconds));
return ROS::Time(std::max(0,i32seconds), std::max(0,i32nanoseconds));
}
/** Returns a duration (type ros::Duration on ROS1 resp. rclcpp::Duration on ROS2) from a given amount of seconds.
** Note: ros::Duration(1) initializes 1 second, while rclcpp::Duration(1) initializes 1 nanosecond.
** Do not use the Duration constructor with one parameter! Always use ROS::durationFromSec(seconds)
** or ROS::Duration(int32_t seconds, uint32_t nanoseconds). */
ROS::Duration ROS::durationFromSec(double seconds)
{
int32_t i32seconds = (int32_t)(seconds);
int32_t i32nanoseconds = (int32_t)(1000000000 * (seconds - i32seconds));
return ROS::Duration(i32seconds, i32nanoseconds);
}
/** Shortcut to return ros::Duration::toSec() on ROS1 resp. rclcpp::Duration::seconds() on ROS2 */
double ROS::seconds(ROS::Duration duration)
{
#if defined __ROS_VERSION && __ROS_VERSION == 1
return duration.toSec();
#elif defined __ROS_VERSION && __ROS_VERSION == 2
return duration.seconds();
#else
return 0;
#endif
}
/** Shortcut to return the time in seconds since program start (first node started) */
double ROS::secondsSinceStart(const ROS::Time& time)
{
static ROS::Time s_wrapper_start_time = ROS::now();
return ROS::seconds(time - s_wrapper_start_time);
}
/** Shortcut to return the timestamp in milliseconds from ROS1 resp. ROS2 time */
uint64_t ROS::timestampMilliseconds(const ROS::Time& time)
{
#if defined __ROS_VERSION && __ROS_VERSION == 1
return (uint64_t)(time.sec * 1000) + (uint64_t)(time.nsec / 1000000);
#elif defined __ROS_VERSION && __ROS_VERSION == 2
return (uint64_t)(time.nanoseconds() / 1000000);
#endif
}
| [
"[email protected]"
] | |
92b1c323ab0d1fe439d6b7a866557767f399700c | 23d01d942c97a31e46529c4371e98aa0c757ecd1 | /apps/libs/src/libomp/openmp/runtime/src/kmp_taskdeps.cpp | 46ba5df9c8cc862ae749c42ad089fccc8c1116b0 | [
"MIT",
"LicenseRef-scancode-generic-cla",
"LicenseRef-scancode-arm-llvm-sga",
"NCSA",
"BSD-2-Clause"
] | permissive | ModeladoFoundation/ocr-apps | f538bc31282f56d43a952610a8f4ec6bacd88e67 | c0179d63574e7bb01f940aceaa7fe1c85fea5902 | refs/heads/master | 2021-09-02T23:41:54.190248 | 2017-08-30T01:48:39 | 2017-08-30T01:49:30 | 116,198,341 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 21,909 | cpp | /*
* kmp_taskdeps.cpp
*/
//===----------------------------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is dual licensed under the MIT and the University of Illinois Open
// Source Licenses. See LICENSE.txt for details.
//
//===----------------------------------------------------------------------===//
//#define KMP_SUPPORT_GRAPH_OUTPUT 1
#include "kmp.h"
#include "kmp_io.h"
#include "kmp_wait_release.h"
#if OMP_40_ENABLED
//TODO: Improve memory allocation? keep a list of pre-allocated structures? allocate in blocks? re-use list finished list entries?
//TODO: don't use atomic ref counters for stack-allocated nodes.
//TODO: find an alternate to atomic refs for heap-allocated nodes?
//TODO: Finish graph output support
//TODO: kmp_lock_t seems a tad to big (and heavy weight) for this. Check other runtime locks
//TODO: Any ITT support needed?
#ifdef KMP_SUPPORT_GRAPH_OUTPUT
static kmp_int32 kmp_node_id_seed = 0;
#endif
static void
__kmp_init_node ( kmp_depnode_t *node )
{
node->dn.task = NULL; // set to null initially, it will point to the right task once dependences have been processed
node->dn.successors = NULL;
__kmp_init_lock(&node->dn.lock);
node->dn.nrefs = 1; // init creates the first reference to the node
#ifdef KMP_SUPPORT_GRAPH_OUTPUT
node->dn.id = KMP_TEST_THEN_INC32(&kmp_node_id_seed);
#endif
}
static inline kmp_depnode_t *
__kmp_node_ref ( kmp_depnode_t *node )
{
KMP_TEST_THEN_INC32(&node->dn.nrefs);
return node;
}
static inline void
__kmp_node_deref ( kmp_info_t *thread, kmp_depnode_t *node )
{
if (!node) return;
kmp_int32 n = KMP_TEST_THEN_DEC32(&node->dn.nrefs) - 1;
if ( n == 0 ) {
KMP_ASSERT(node->dn.nrefs == 0);
#if USE_FAST_MEMORY
__kmp_fast_free(thread,node);
#else
__kmp_thread_free(thread,node);
#endif
}
}
#define KMP_ACQUIRE_DEPNODE(gtid,n) __kmp_acquire_lock(&(n)->dn.lock,(gtid))
#define KMP_RELEASE_DEPNODE(gtid,n) __kmp_release_lock(&(n)->dn.lock,(gtid))
static void
__kmp_depnode_list_free ( kmp_info_t *thread, kmp_depnode_list *list );
enum {
KMP_DEPHASH_OTHER_SIZE = 97,
KMP_DEPHASH_MASTER_SIZE = 997
};
static inline kmp_int32
__kmp_dephash_hash ( kmp_intptr_t addr, size_t hsize )
{
//TODO alternate to try: set = (((Addr64)(addrUsefulBits * 9.618)) % m_num_sets );
return ((addr >> 6) ^ (addr >> 2)) % hsize;
}
static kmp_dephash_t *
__kmp_dephash_create ( kmp_info_t *thread, kmp_taskdata_t *current_task )
{
kmp_dephash_t *h;
size_t h_size;
if ( current_task->td_flags.tasktype == TASK_IMPLICIT )
h_size = KMP_DEPHASH_MASTER_SIZE;
else
h_size = KMP_DEPHASH_OTHER_SIZE;
kmp_int32 size = h_size * sizeof(kmp_dephash_entry_t) + sizeof(kmp_dephash_t);
#if USE_FAST_MEMORY
h = (kmp_dephash_t *) __kmp_fast_allocate( thread, size );
#else
h = (kmp_dephash_t *) __kmp_thread_malloc( thread, size );
#endif
h->size = h_size;
#ifdef KMP_DEBUG
h->nelements = 0;
h->nconflicts = 0;
#endif
h->buckets = (kmp_dephash_entry **)(h+1);
for ( size_t i = 0; i < h_size; i++ )
h->buckets[i] = 0;
return h;
}
static void
__kmp_dephash_free ( kmp_info_t *thread, kmp_dephash_t *h )
{
for ( size_t i=0; i < h->size; i++ ) {
if ( h->buckets[i] ) {
kmp_dephash_entry_t *next;
for ( kmp_dephash_entry_t *entry = h->buckets[i]; entry; entry = next ) {
next = entry->next_in_bucket;
__kmp_depnode_list_free(thread,entry->last_ins);
__kmp_node_deref(thread,entry->last_out);
#if USE_FAST_MEMORY
__kmp_fast_free(thread,entry);
#else
__kmp_thread_free(thread,entry);
#endif
}
}
}
#if USE_FAST_MEMORY
__kmp_fast_free(thread,h);
#else
__kmp_thread_free(thread,h);
#endif
}
static kmp_dephash_entry *
__kmp_dephash_find ( kmp_info_t *thread, kmp_dephash_t *h, kmp_intptr_t addr )
{
kmp_int32 bucket = __kmp_dephash_hash(addr,h->size);
kmp_dephash_entry_t *entry;
for ( entry = h->buckets[bucket]; entry; entry = entry->next_in_bucket )
if ( entry->addr == addr ) break;
if ( entry == NULL ) {
// create entry. This is only done by one thread so no locking required
#if USE_FAST_MEMORY
entry = (kmp_dephash_entry_t *) __kmp_fast_allocate( thread, sizeof(kmp_dephash_entry_t) );
#else
entry = (kmp_dephash_entry_t *) __kmp_thread_malloc( thread, sizeof(kmp_dephash_entry_t) );
#endif
entry->addr = addr;
entry->last_out = NULL;
entry->last_ins = NULL;
entry->next_in_bucket = h->buckets[bucket];
h->buckets[bucket] = entry;
#ifdef KMP_DEBUG
h->nelements++;
if ( entry->next_in_bucket ) h->nconflicts++;
#endif
}
return entry;
}
static kmp_depnode_list_t *
__kmp_add_node ( kmp_info_t *thread, kmp_depnode_list_t *list, kmp_depnode_t *node )
{
kmp_depnode_list_t *new_head;
#if USE_FAST_MEMORY
new_head = (kmp_depnode_list_t *) __kmp_fast_allocate(thread,sizeof(kmp_depnode_list_t));
#else
new_head = (kmp_depnode_list_t *) __kmp_thread_malloc(thread,sizeof(kmp_depnode_list_t));
#endif
new_head->node = __kmp_node_ref(node);
new_head->next = list;
return new_head;
}
static void
__kmp_depnode_list_free ( kmp_info_t *thread, kmp_depnode_list *list )
{
kmp_depnode_list *next;
for ( ; list ; list = next ) {
next = list->next;
__kmp_node_deref(thread,list->node);
#if USE_FAST_MEMORY
__kmp_fast_free(thread,list);
#else
__kmp_thread_free(thread,list);
#endif
}
}
static inline void
__kmp_track_dependence ( kmp_depnode_t *source, kmp_depnode_t *sink,
kmp_task_t *sink_task )
{
#ifdef KMP_SUPPORT_GRAPH_OUTPUT
kmp_taskdata_t * task_source = KMP_TASK_TO_TASKDATA(source->dn.task);
kmp_taskdata_t * task_sink = KMP_TASK_TO_TASKDATA(sink->dn.task); // this can be NULL when if(0) ...
__kmp_printf("%d(%s) -> %d(%s)\n", source->dn.id, task_source->td_ident->psource, sink->dn.id, task_sink->td_ident->psource);
#endif
#if OMPT_SUPPORT && OMPT_TRACE
/* OMPT tracks dependences between task (a=source, b=sink) in which
task a blocks the execution of b through the ompt_new_dependence_callback */
if (ompt_enabled &&
ompt_callbacks.ompt_callback(ompt_event_task_dependence_pair))
{
kmp_taskdata_t * task_source = KMP_TASK_TO_TASKDATA(source->dn.task);
kmp_taskdata_t * task_sink = KMP_TASK_TO_TASKDATA(sink_task);
ompt_callbacks.ompt_callback(ompt_event_task_dependence_pair)(
task_source->ompt_task_info.task_id,
task_sink->ompt_task_info.task_id);
}
#endif /* OMPT_SUPPORT && OMPT_TRACE */
}
template< bool filter >
static inline kmp_int32
__kmp_process_deps ( kmp_int32 gtid, kmp_depnode_t *node, kmp_dephash_t *hash,
bool dep_barrier,kmp_int32 ndeps, kmp_depend_info_t *dep_list,
kmp_task_t *task )
{
KA_TRACE(30, ("__kmp_process_deps<%d>: T#%d processing %d depencies : dep_barrier = %d\n", filter, gtid, ndeps, dep_barrier ) );
kmp_info_t *thread = __kmp_threads[ gtid ];
kmp_int32 npredecessors=0;
for ( kmp_int32 i = 0; i < ndeps ; i++ ) {
const kmp_depend_info_t * dep = &dep_list[i];
KMP_DEBUG_ASSERT(dep->flags.in);
if ( filter && dep->base_addr == 0 ) continue; // skip filtered entries
kmp_dephash_entry_t *info = __kmp_dephash_find(thread,hash,dep->base_addr);
kmp_depnode_t *last_out = info->last_out;
if ( dep->flags.out && info->last_ins ) {
for ( kmp_depnode_list_t * p = info->last_ins; p; p = p->next ) {
kmp_depnode_t * indep = p->node;
if ( indep->dn.task ) {
KMP_ACQUIRE_DEPNODE(gtid,indep);
if ( indep->dn.task ) {
__kmp_track_dependence(indep,node,task);
indep->dn.successors = __kmp_add_node(thread, indep->dn.successors, node);
KA_TRACE(40,("__kmp_process_deps<%d>: T#%d adding dependence from %p to %p\n",
filter,gtid, KMP_TASK_TO_TASKDATA(indep->dn.task), KMP_TASK_TO_TASKDATA(node->dn.task)));
npredecessors++;
}
KMP_RELEASE_DEPNODE(gtid,indep);
}
}
__kmp_depnode_list_free(thread,info->last_ins);
info->last_ins = NULL;
} else if ( last_out && last_out->dn.task ) {
KMP_ACQUIRE_DEPNODE(gtid,last_out);
if ( last_out->dn.task ) {
__kmp_track_dependence(last_out,node,task);
last_out->dn.successors = __kmp_add_node(thread, last_out->dn.successors, node);
KA_TRACE(40,("__kmp_process_deps<%d>: T#%d adding dependence from %p to %p\n",
filter,gtid, KMP_TASK_TO_TASKDATA(last_out->dn.task), KMP_TASK_TO_TASKDATA(node->dn.task)));
npredecessors++;
}
KMP_RELEASE_DEPNODE(gtid,last_out);
}
if ( dep_barrier ) {
// if this is a sync point in the serial sequence, then the previous outputs are guaranteed to be completed after
// the execution of this task so the previous output nodes can be cleared.
__kmp_node_deref(thread,last_out);
info->last_out = NULL;
} else {
if ( dep->flags.out ) {
__kmp_node_deref(thread,last_out);
info->last_out = __kmp_node_ref(node);
} else
info->last_ins = __kmp_add_node(thread, info->last_ins, node);
}
}
KA_TRACE(30, ("__kmp_process_deps<%d>: T#%d found %d predecessors\n", filter, gtid, npredecessors ) );
return npredecessors;
}
#define NO_DEP_BARRIER (false)
#define DEP_BARRIER (true)
// returns true if the task has any outstanding dependence
static bool
__kmp_check_deps ( kmp_int32 gtid, kmp_depnode_t *node, kmp_task_t *task, kmp_dephash_t *hash, bool dep_barrier,
kmp_int32 ndeps, kmp_depend_info_t *dep_list,
kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list )
{
int i;
#if KMP_DEBUG
kmp_taskdata_t * taskdata = KMP_TASK_TO_TASKDATA(task);
#endif
KA_TRACE(20, ("__kmp_check_deps: T#%d checking dependencies for task %p : %d possibly aliased dependencies, %d non-aliased depedencies : dep_barrier=%d .\n", gtid, taskdata, ndeps, ndeps_noalias, dep_barrier ) );
// Filter deps in dep_list
// TODO: Different algorithm for large dep_list ( > 10 ? )
for ( i = 0; i < ndeps; i ++ ) {
if ( dep_list[i].base_addr != 0 )
for ( int j = i+1; j < ndeps; j++ )
if ( dep_list[i].base_addr == dep_list[j].base_addr ) {
dep_list[i].flags.in |= dep_list[j].flags.in;
dep_list[i].flags.out |= dep_list[j].flags.out;
dep_list[j].base_addr = 0; // Mark j element as void
}
}
// doesn't need to be atomic as no other thread is going to be accessing this node just yet
// npredecessors is set -1 to ensure that none of the releasing tasks queues this task before we have finished processing all the dependencies
node->dn.npredecessors = -1;
// used to pack all npredecessors additions into a single atomic operation at the end
int npredecessors;
npredecessors = __kmp_process_deps<true>(gtid, node, hash, dep_barrier,
ndeps, dep_list, task);
npredecessors += __kmp_process_deps<false>(gtid, node, hash, dep_barrier,
ndeps_noalias, noalias_dep_list, task);
node->dn.task = task;
KMP_MB();
// Account for our initial fake value
npredecessors++;
// Update predecessors and obtain current value to check if there are still any outstandig dependences (some tasks may have finished while we processed the dependences)
npredecessors = KMP_TEST_THEN_ADD32(&node->dn.npredecessors, npredecessors) + npredecessors;
KA_TRACE(20, ("__kmp_check_deps: T#%d found %d predecessors for task %p \n", gtid, npredecessors, taskdata ) );
// beyond this point the task could be queued (and executed) by a releasing task...
return npredecessors > 0 ? true : false;
}
void
__kmp_release_deps ( kmp_int32 gtid, kmp_taskdata_t *task )
{
kmp_info_t *thread = __kmp_threads[ gtid ];
kmp_depnode_t *node = task->td_depnode;
if ( task->td_dephash ) {
KA_TRACE(40, ("__kmp_realease_deps: T#%d freeing dependencies hash of task %p.\n", gtid, task ) );
__kmp_dephash_free(thread,task->td_dephash);
}
if ( !node ) return;
KA_TRACE(20, ("__kmp_realease_deps: T#%d notifying succesors of task %p.\n", gtid, task ) );
KMP_ACQUIRE_DEPNODE(gtid,node);
node->dn.task = NULL; // mark this task as finished, so no new dependencies are generated
KMP_RELEASE_DEPNODE(gtid,node);
kmp_depnode_list_t *next;
for ( kmp_depnode_list_t *p = node->dn.successors; p; p = next ) {
kmp_depnode_t *successor = p->node;
kmp_int32 npredecessors = KMP_TEST_THEN_DEC32(&successor->dn.npredecessors) - 1;
// successor task can be NULL for wait_depends or because deps are still being processed
if ( npredecessors == 0 ) {
KMP_MB();
if ( successor->dn.task ) {
KA_TRACE(20, ("__kmp_realease_deps: T#%d successor %p of %p scheduled for execution.\n", gtid, successor->dn.task, task ) );
__kmp_omp_task(gtid,successor->dn.task,false);
}
}
next = p->next;
__kmp_node_deref(thread,p->node);
#if USE_FAST_MEMORY
__kmp_fast_free(thread,p);
#else
__kmp_thread_free(thread,p);
#endif
}
__kmp_node_deref(thread,node);
KA_TRACE(20, ("__kmp_realease_deps: T#%d all successors of %p notified of completation\n", gtid, task ) );
}
/*!
@ingroup TASKING
@param loc_ref location of the original task directive
@param gtid Global Thread ID of encountering thread
@param new_task task thunk allocated by __kmp_omp_task_alloc() for the ''new task''
@param ndeps Number of depend items with possible aliasing
@param dep_list List of depend items with possible aliasing
@param ndeps_noalias Number of depend items with no aliasing
@param noalias_dep_list List of depend items with no aliasing
@return Returns either TASK_CURRENT_NOT_QUEUED if the current task was not suspendend and queued, or TASK_CURRENT_QUEUED if it was suspended and queued
Schedule a non-thread-switchable task with dependences for execution
*/
kmp_int32
__kmpc_omp_task_with_deps( ident_t *loc_ref, kmp_int32 gtid, kmp_task_t * new_task,
kmp_int32 ndeps, kmp_depend_info_t *dep_list,
kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list )
{
kmp_taskdata_t * new_taskdata = KMP_TASK_TO_TASKDATA(new_task);
KA_TRACE(10, ("__kmpc_omp_task_with_deps(enter): T#%d loc=%p task=%p\n",
gtid, loc_ref, new_taskdata ) );
kmp_info_t *thread = __kmp_threads[ gtid ];
kmp_taskdata_t * current_task = thread->th.th_current_task;
#if OMPT_SUPPORT && OMPT_TRACE
/* OMPT grab all dependences if requested by the tool */
if (ompt_enabled && ndeps+ndeps_noalias > 0 &&
ompt_callbacks.ompt_callback(ompt_event_task_dependences))
{
kmp_int32 i;
new_taskdata->ompt_task_info.ndeps = ndeps+ndeps_noalias;
new_taskdata->ompt_task_info.deps = (ompt_task_dependence_t *)
KMP_OMPT_DEPS_ALLOC(thread,
(ndeps+ndeps_noalias)*sizeof(ompt_task_dependence_t));
KMP_ASSERT(new_taskdata->ompt_task_info.deps != NULL);
for (i = 0; i < ndeps; i++)
{
new_taskdata->ompt_task_info.deps[i].variable_addr =
(void*) dep_list[i].base_addr;
if (dep_list[i].flags.in && dep_list[i].flags.out)
new_taskdata->ompt_task_info.deps[i].dependence_flags =
ompt_task_dependence_type_inout;
else if (dep_list[i].flags.out)
new_taskdata->ompt_task_info.deps[i].dependence_flags =
ompt_task_dependence_type_out;
else if (dep_list[i].flags.in)
new_taskdata->ompt_task_info.deps[i].dependence_flags =
ompt_task_dependence_type_in;
}
for (i = 0; i < ndeps_noalias; i++)
{
new_taskdata->ompt_task_info.deps[ndeps+i].variable_addr =
(void*) noalias_dep_list[i].base_addr;
if (noalias_dep_list[i].flags.in && noalias_dep_list[i].flags.out)
new_taskdata->ompt_task_info.deps[ndeps+i].dependence_flags =
ompt_task_dependence_type_inout;
else if (noalias_dep_list[i].flags.out)
new_taskdata->ompt_task_info.deps[ndeps+i].dependence_flags =
ompt_task_dependence_type_out;
else if (noalias_dep_list[i].flags.in)
new_taskdata->ompt_task_info.deps[ndeps+i].dependence_flags =
ompt_task_dependence_type_in;
}
}
#endif /* OMPT_SUPPORT && OMPT_TRACE */
bool serial = current_task->td_flags.team_serial || current_task->td_flags.tasking_ser || current_task->td_flags.final;
#if OMP_45_ENABLED
serial = serial && !(new_taskdata->td_flags.proxy == TASK_PROXY);
#endif
if ( !serial && ( ndeps > 0 || ndeps_noalias > 0 )) {
/* if no dependencies have been tracked yet, create the dependence hash */
if ( current_task->td_dephash == NULL )
current_task->td_dephash = __kmp_dephash_create(thread, current_task);
#if USE_FAST_MEMORY
kmp_depnode_t *node = (kmp_depnode_t *) __kmp_fast_allocate(thread,sizeof(kmp_depnode_t));
#else
kmp_depnode_t *node = (kmp_depnode_t *) __kmp_thread_malloc(thread,sizeof(kmp_depnode_t));
#endif
__kmp_init_node(node);
new_taskdata->td_depnode = node;
if ( __kmp_check_deps( gtid, node, new_task, current_task->td_dephash, NO_DEP_BARRIER,
ndeps, dep_list, ndeps_noalias,noalias_dep_list ) ) {
KA_TRACE(10, ("__kmpc_omp_task_with_deps(exit): T#%d task had blocking dependencies: "
"loc=%p task=%p, return: TASK_CURRENT_NOT_QUEUED\n", gtid, loc_ref,
new_taskdata ) );
return TASK_CURRENT_NOT_QUEUED;
}
} else {
#if OMP_45_ENABLED
kmp_task_team_t * task_team = thread->th.th_task_team;
if ( task_team && task_team->tt.tt_found_proxy_tasks )
__kmpc_omp_wait_deps ( loc_ref, gtid, ndeps, dep_list, ndeps_noalias, noalias_dep_list );
else
#endif
KA_TRACE(10, ("__kmpc_omp_task_with_deps(exit): T#%d ignored dependencies for task (serialized)"
"loc=%p task=%p\n", gtid, loc_ref, new_taskdata ) );
}
KA_TRACE(10, ("__kmpc_omp_task_with_deps(exit): T#%d task had no blocking dependencies : "
"loc=%p task=%p, transferring to __kmpc_omp_task\n", gtid, loc_ref,
new_taskdata ) );
return __kmpc_omp_task(loc_ref,gtid,new_task);
}
/*!
@ingroup TASKING
@param loc_ref location of the original task directive
@param gtid Global Thread ID of encountering thread
@param ndeps Number of depend items with possible aliasing
@param dep_list List of depend items with possible aliasing
@param ndeps_noalias Number of depend items with no aliasing
@param noalias_dep_list List of depend items with no aliasing
Blocks the current task until all specifies dependencies have been fulfilled.
*/
void
__kmpc_omp_wait_deps ( ident_t *loc_ref, kmp_int32 gtid, kmp_int32 ndeps, kmp_depend_info_t *dep_list,
kmp_int32 ndeps_noalias, kmp_depend_info_t *noalias_dep_list )
{
KA_TRACE(10, ("__kmpc_omp_wait_deps(enter): T#%d loc=%p\n", gtid, loc_ref) );
if ( ndeps == 0 && ndeps_noalias == 0 ) {
KA_TRACE(10, ("__kmpc_omp_wait_deps(exit): T#%d has no dependencies to wait upon : loc=%p\n", gtid, loc_ref) );
return;
}
kmp_info_t *thread = __kmp_threads[ gtid ];
kmp_taskdata_t * current_task = thread->th.th_current_task;
// We can return immediately as:
// - dependences are not computed in serial teams (except if we have proxy tasks)
// - if the dephash is not yet created it means we have nothing to wait for
bool ignore = current_task->td_flags.team_serial || current_task->td_flags.tasking_ser || current_task->td_flags.final;
#if OMP_45_ENABLED
ignore = ignore && thread->th.th_task_team != NULL && thread->th.th_task_team->tt.tt_found_proxy_tasks == FALSE;
#endif
ignore = ignore || current_task->td_dephash == NULL;
if ( ignore ) {
KA_TRACE(10, ("__kmpc_omp_wait_deps(exit): T#%d has no blocking dependencies : loc=%p\n", gtid, loc_ref) );
return;
}
kmp_depnode_t node;
__kmp_init_node(&node);
if (!__kmp_check_deps( gtid, &node, NULL, current_task->td_dephash, DEP_BARRIER,
ndeps, dep_list, ndeps_noalias, noalias_dep_list )) {
KA_TRACE(10, ("__kmpc_omp_wait_deps(exit): T#%d has no blocking dependencies : loc=%p\n", gtid, loc_ref) );
return;
}
int thread_finished = FALSE;
kmp_flag_32 flag((volatile kmp_uint32 *)&(node.dn.npredecessors), 0U);
while ( node.dn.npredecessors > 0 ) {
flag.execute_tasks(thread, gtid, FALSE, &thread_finished,
#if USE_ITT_BUILD
NULL,
#endif
__kmp_task_stealing_constraint );
}
KA_TRACE(10, ("__kmpc_omp_wait_deps(exit): T#%d finished waiting : loc=%p\n", gtid, loc_ref) );
}
#endif /* OMP_40_ENABLED */
| [
"[email protected]"
] | |
44b9dd02e46ec9c2ac21ae56aaedd8d4806449b2 | b2ab1f110526245fc5b7e5ea37fd49bc6e947370 | /devel/include/path_collision_check/IsTraVal.h | 3b9ba87580d6160be1968a9491eb490810c3b15b | [] | no_license | YunxuanMao/ws_robot_charge | c0492e580e938c901f9fab435de8835208e667e1 | 242064fe031c8a7d1ab9746d5cd212a1ff42f597 | refs/heads/master | 2023-04-13T16:15:57.223601 | 2021-04-27T07:29:59 | 2021-04-27T07:29:59 | 362,019,582 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,925 | h | // Generated by gencpp from file path_collision_check/IsTraVal.msg
// DO NOT EDIT!
#ifndef PATH_COLLISION_CHECK_MESSAGE_ISTRAVAL_H
#define PATH_COLLISION_CHECK_MESSAGE_ISTRAVAL_H
#include <ros/service_traits.h>
#include <path_collision_check/IsTraValRequest.h>
#include <path_collision_check/IsTraValResponse.h>
namespace path_collision_check
{
struct IsTraVal
{
typedef IsTraValRequest Request;
typedef IsTraValResponse Response;
Request request;
Response response;
typedef Request RequestType;
typedef Response ResponseType;
}; // struct IsTraVal
} // namespace path_collision_check
namespace ros
{
namespace service_traits
{
template<>
struct MD5Sum< ::path_collision_check::IsTraVal > {
static const char* value()
{
return "33c97e92ddfb5fd9eeda43da1e556307";
}
static const char* value(const ::path_collision_check::IsTraVal&) { return value(); }
};
template<>
struct DataType< ::path_collision_check::IsTraVal > {
static const char* value()
{
return "path_collision_check/IsTraVal";
}
static const char* value(const ::path_collision_check::IsTraVal&) { return value(); }
};
// service_traits::MD5Sum< ::path_collision_check::IsTraValRequest> should match
// service_traits::MD5Sum< ::path_collision_check::IsTraVal >
template<>
struct MD5Sum< ::path_collision_check::IsTraValRequest>
{
static const char* value()
{
return MD5Sum< ::path_collision_check::IsTraVal >::value();
}
static const char* value(const ::path_collision_check::IsTraValRequest&)
{
return value();
}
};
// service_traits::DataType< ::path_collision_check::IsTraValRequest> should match
// service_traits::DataType< ::path_collision_check::IsTraVal >
template<>
struct DataType< ::path_collision_check::IsTraValRequest>
{
static const char* value()
{
return DataType< ::path_collision_check::IsTraVal >::value();
}
static const char* value(const ::path_collision_check::IsTraValRequest&)
{
return value();
}
};
// service_traits::MD5Sum< ::path_collision_check::IsTraValResponse> should match
// service_traits::MD5Sum< ::path_collision_check::IsTraVal >
template<>
struct MD5Sum< ::path_collision_check::IsTraValResponse>
{
static const char* value()
{
return MD5Sum< ::path_collision_check::IsTraVal >::value();
}
static const char* value(const ::path_collision_check::IsTraValResponse&)
{
return value();
}
};
// service_traits::DataType< ::path_collision_check::IsTraValResponse> should match
// service_traits::DataType< ::path_collision_check::IsTraVal >
template<>
struct DataType< ::path_collision_check::IsTraValResponse>
{
static const char* value()
{
return DataType< ::path_collision_check::IsTraVal >::value();
}
static const char* value(const ::path_collision_check::IsTraValResponse&)
{
return value();
}
};
} // namespace service_traits
} // namespace ros
#endif // PATH_COLLISION_CHECK_MESSAGE_ISTRAVAL_H
| [
"[email protected]"
] | |
c3f565a1d9ce98f1c1b858954d96a7970df4bef0 | 82dc3cc4c97c05e384812cc9aa07938e2dbfe24b | /toolbox/src/param_tree/ParameterInterfaceT.cpp | b50b33b83c58cd6697fe4030eb72264185409ba6 | [
"BSD-3-Clause"
] | permissive | samanseifi/Tahoe | ab40da0f8d952491943924034fa73ee5ecb2fecd | 542de50ba43645f19ce4b106ac8118c4333a3f25 | refs/heads/master | 2020-04-05T20:24:36.487197 | 2017-12-02T17:09:11 | 2017-12-02T17:24:23 | 38,074,546 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,279 | cpp | /* $Id: ParameterInterfaceT.cpp,v 1.20 2004/08/05 23:03:19 paklein Exp $ */
#include "ParameterInterfaceT.h"
#include "ParameterListT.h"
#include "ParameterUtils.h"
#include "ParameterContainerT.h"
using namespace Tahoe;
/* array behavior */
namespace Tahoe {
DEFINE_TEMPLATE_STATIC const bool ArrayT<ParameterInterfaceT*>::fByteCopy = true;
DEFINE_TEMPLATE_STATIC const bool ArrayT<const ParameterInterfaceT*>::fByteCopy = true;
DEFINE_TEMPLATE_STATIC const bool ArrayT<SubListDescriptionT>::fByteCopy = false;
}
/* constructor */
ParameterInterfaceT::ParameterInterfaceT(const StringT& name)
{
SetName(name);
}
void ParameterInterfaceT::SetName(const StringT& name)
{
fName = name;
}
/* accept completed parameter list */
void ParameterInterfaceT::TakeParameterList(const ParameterListT& list)
{
const char caller[] = "ParameterInterfaceT::TakeParameterList";
if (list.Name() != Name())
ExceptionT::GeneralFail(caller, "list name \"%s\" must be \"%s\"",
list.Name().Pointer(), Name().Pointer());
}
/* build complete parameter list description */
void ParameterInterfaceT::DefineParameters(ParameterListT& list) const
{
const char caller[] = "ParameterInterfaceT::DefineParameters";
if (list.Name() != Name())
ExceptionT::GeneralFail(caller, "list name \"%s\" must be \"%s\"",
list.Name().Pointer(), Name().Pointer());
}
/* validate the given parameter list */
void ParameterInterfaceT::ValidateParameterList(const ParameterListT& raw_list, ParameterListT& valid_list) const
{
/* check name */
const char caller[] = "ParameterInterfaceT::ValidateParameterList";
if (raw_list.Name() != Name())
ExceptionT::GeneralFail(caller, "raw list name \"%s\" must be \"%s\"",
raw_list.Name().Pointer(), Name().Pointer());
if (valid_list.Name() != Name())
ExceptionT::GeneralFail(caller, "list name \"%s\" must be \"%s\"",
raw_list.Name().Pointer(), Name().Pointer());
/* collect description */
ParameterListT description(Name());
DefineParameters(description);
/* parameter lists */
const ArrayT<ParameterT>& raw_parameters = raw_list.Parameters();
const ArrayT<ParameterT>& parameters = description.Parameters();
const ArrayT<ParameterListT::OccurrenceT>& occurrences = description.ParameterOccurrences();
/* look through parameters */
for (int i = 0; i < parameters.Length(); i++)
{
const ParameterT& parameter = parameters[i];
ParameterListT::OccurrenceT occurrence = occurrences[i];
/* search entire list - parameters are not ordered */
int count = 0;
for (int j = 0; j < raw_parameters.Length(); j++) {
const ParameterT& raw_parameter = raw_parameters[j];
/* name match */
if (raw_parameter.Name() == parameter.Name()) {
/* check occurrence */
if (count > 0 && (occurrence == ParameterListT::Once || occurrence == ParameterListT::ZeroOrOnce))
ExceptionT::BadInputValue(caller, "parameter \"%s\" cannot appear in \"%s\" more than once",
parameter.Name().Pointer(), Name().Pointer());
/* get value */
ParameterT new_parameter(parameter.Type(), parameter.Name());
new_parameter.SetDescription(parameter.Description());
if (raw_parameter.Type() == parameter.Type())
new_parameter = raw_parameter;
else if (raw_parameter.Type() == ParameterT::String || raw_parameter.Type() == ParameterT::Word)
{
/* convert to string */
const StringT& value_str = raw_parameter;
/* set from string */
new_parameter.FromString(value_str);
}
else
ExceptionT::BadInputValue(caller, "source for \"%s\" must have type %d, %d, or %d: %d",
parameter.Name().Pointer(), ParameterT::String, ParameterT::Word, parameter.Type());
/* increment count */
count++;
/* check limits */
if (parameter.InBounds(new_parameter))
{
/* fix string-value pairs */
if (parameter.Type() == ValueT::Enumeration)
parameter.FixEnumeration(new_parameter);
/* copy in limits */
new_parameter.AddLimits(parameter.Limits());
/* copy in default */
const ValueT* default_value = parameter.Default();
if (default_value)
new_parameter.SetDefault(*default_value);
/* add it */
valid_list.AddParameter(new_parameter);
}
else
{
/* check again, now verbose */
parameter.InBounds(new_parameter, true);
ExceptionT::BadInputValue(caller, "improper value for parameter \"%s\" in \"%s\"",
parameter.Name().Pointer(), Name().Pointer());
}
}
}
/* look for default value */
if (count == 0 && (occurrence == ParameterListT::Once || occurrence == ParameterListT::OnePlus))
{
const ValueT* default_value = parameter.Default();
if (default_value) {
ParameterT new_parameter(parameter.Type(), parameter.Name());
new_parameter.SetDescription(parameter.Description());
new_parameter = *default_value;
/* check limits */
if (parameter.InBounds(new_parameter))
{
/* copy in limits */
new_parameter.AddLimits(parameter.Limits());
/* copy in default */
new_parameter.SetDefault(*default_value);
/* add it */
valid_list.AddParameter(new_parameter);
}
else
{
/* check again, now verbose */
parameter.InBounds(new_parameter, true);
ExceptionT::BadInputValue(caller, "improper value for parameter \"%s\" in \"%s\"",
parameter.Name().Pointer(), Name().Pointer());
}
}
else
ExceptionT::BadInputValue(caller,
"required parameter \"%s\" is missing from \"%s\" and has no default",
parameter.Name().Pointer(), Name().Pointer());
}
}
}
/* the order of subordinate lists */
ParameterListT::ListOrderT ParameterInterfaceT::ListOrder(void) const
{
return ParameterListT::Sequence;
}
/* return the list of subordinate names */
void ParameterInterfaceT::DefineSubs(SubListT& sub_list) const
{
#pragma unused(sub_list)
// sub_list.Dimension(0);
//NOTE: clearing the list causes classes which inherit ParameterInterfaceT more than once
// to have an incomplete list of subs.
}
void ParameterInterfaceT::DefineInlineSub(const StringT& name, ParameterListT::ListOrderT& order,
SubListT& sub_lists) const
{
/* check for definition in NewSub */
ParameterInterfaceT* inline_sub = NewSub(name);
if (inline_sub) /* define inline sub */ {
/* set sequence or choice */
order = inline_sub->ListOrder();
/* there should be no parameters */
ParameterListT params(inline_sub->Name());
inline_sub->DefineParameters(params);
if (params.NumParameters() > 0)
ExceptionT::GeneralFail("ParameterInterfaceT::DefineInlineSub",
"%d parameters not allowed in inline sub \"%s\"", params.NumParameters(), name.Pointer());
/* get subs */
inline_sub->DefineSubs(sub_lists);
/* clean up */
delete inline_sub;
}
}
/* return a pointer to the ParameterInterfaceT */
ParameterInterfaceT* ParameterInterfaceT::NewSub(const StringT& name) const
{
const char caller[] = "ParameterInterfaceT::NewSub";
/* look for names ending in "_ID_list" */
const char* find = strstr(name, "_ID_list");
if (find && strlen(find) == 8) {
StringListT* id_list = new StringListT(name);
id_list->SetMinLength(1);
return id_list;
}
if (name == "Integer")
return new IntegerParameterT;
else if (name == "IntegerList")
return new IntegerListT;
else if (name == "Double")
return new DoubleParameterT;
else if (name == "DoubleList")
return new DoubleListT;
else if (name == "String")
return new StringParameterT;
else if (name == "OrderedPair")
{
ParameterContainerT* pair = new ParameterContainerT("OrderedPair");
ParameterT x(ParameterT::Double, "x");
ParameterT y(ParameterT::Double, "y");
pair->AddParameter(x);
pair->AddParameter(y);
return pair;
}
else if (strncmp("Vector_", name, 7) == 0) /* Vector_N */
return new VectorParameterT(name);
else if (strncmp("Matrix_", name, 7) == 0) /* Matrix_MxN */
return new MatrixParameterT(name);
else
return NULL;
}
/* remove the first instance of the given sublist */
bool SubListT::RemoveSub(const char* name)
{
/* scan */
int index = -1;
for (int i = 0; index == -1 && i < fLength; i++)
if (fArray[i].Name() == name)
index = i;
/* remove */
if (index != -1) {
DeleteAt(index);
return true;
}
else
return false;
}
| [
"saman@bu.(none)"
] | saman@bu.(none) |
2ee0fda0e7ae01e65a8c6f7652a5bfc60c43b2df | 35edf8bfa6c145e8098071c53b5735a6ee77a0b9 | /BaruchCPPHW-master/Fulin Li Level 9 HW Submission/9.F/9.F/FDMDirector.hpp | 4e51bb0b78ae6d7b2b0f9735aec27b518ae53fed | [] | no_license | yhwputin/C | 6d36a2d3b2b339a6b0e85fdcb186609c2589fb14 | 57c3e9b862244d90ff71d7af577b4c321ad7e995 | refs/heads/master | 2022-03-26T03:00:56.613797 | 2019-12-04T22:25:27 | 2019-12-04T22:25:27 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,435 | hpp | // FDMDirector.hpp
//
// The class that drives the whole FDM process. It
// mediates between the Mesh generation class and the
// FDM class.
//
// This class computes the solution up to t = T (expiry).
//
// (C) Datasim Education BV 2005-2011
//
#ifndef FDMDirector_HPP
#define FDMDirector_HPP
#include "mesher.hpp"
#include "fdm.hpp"
#include <iostream>
using namespace std;
class FDMDirector
{
private:
FDMDirector ()
{
}
double T;
double Xmax;
double k;
long J, N;
double tprev, tnow;
FDM fdm;
public:
Vector<double, long> xarr; // Mesh array in space S
Vector<double, long> tarr; // Mesh array in time
public:
FDMDirector (double XM, double TM, long J, long NT)
{
T = TM;
J = J;
N = NT;
Xmax = XM;
fdm = FDM();
// Create meshes in S and t
Mesher mx(0.0, Xmax);
xarr = mx.xarr(J);
Mesher mt(0.0, T);
tarr = mt.xarr(NT);
Start();
}
const Vector<double, long>& current() const
{
return fdm.current();
}
void Start() // Calculate next level
{
// Steps 1, 2: Get stuff from Mesher
tprev = tnow = 0.0;
k = T/N;
// Step 3: Update new mesh array in FDM scheme
fdm.initIC(xarr);
}
void doit()
{
// Step 4, 5: Get new coefficient arrays + solve
for (int n = tarr.MinIndex() +1; n <= tarr.MaxIndex(); ++n)
{
tnow = tarr[n]; // n+1
fdm.calculateCoefficients(xarr, tprev, tnow);
fdm.solve(tnow);
tprev = tnow; // n becomes n+1
}
}
};
#endif | [
"[email protected]"
] | |
2911963f905226f3d05ba9200d662f9b769c43dd | 07295fd7664a9e0729594831ee8b705b0b190420 | /Qt/Apps/NClient/FileEditionWidget.cpp | 2f136ad6e7d41c0ba045a7c4904689bd39f5053e | [] | no_license | Neobot/PC | 3c8d24feccbf7876486247ccfd04979270f36e8e | 1a0fcec6812df9d9b8d1a817504bf45c0aee268d | refs/heads/master | 2021-01-10T19:48:30.196731 | 2015-05-25T11:13:22 | 2015-05-25T11:13:22 | 11,391,401 | 0 | 0 | null | 2014-10-25T12:08:59 | 2013-07-13T17:23:15 | C++ | UTF-8 | C++ | false | false | 15,734 | cpp | #include "FileEditionWidget.h"
#include "ui_FileEditionWidget.h"
#include "GridEditor.h"
#include "NSettingsPropertyBrowser.h"
#include "NSEditor.h"
#include "NetworkConnection.h"
#include "NetworkClientCommInterface.h"
#include "FileEnvReplicator.h"
#include <QHeaderView>
#include <QFileDialog>
#include <QInputDialog>
#include <QToolButton>
#include <QTemporaryFile>
#include <QMessageBox>
FileEditionWidget::FileEditionWidget(QWidget *parent) :
QWidget(parent),
ui(new Ui::FileEditionWidget), _askFileContext(None), _gridEditor(nullptr), _propertiesBrowser(nullptr),
_propertyDialog(nullptr), _plainTextEditor(nullptr), _textDialog(nullptr),
_nsEditor(nullptr), _nsDialog(nullptr)
{
ui->setupUi(this);
_editMapper = new QSignalMapper(this);
connect(_editMapper, SIGNAL(mapped(QString)), this, SLOT(editFile(QString)));
connect(ui->tableWidget, SIGNAL(cellDoubleClicked(int,int)), this, SLOT(rowDoubleClicked(int)));
_exportMapper = new QSignalMapper(this);
connect(_exportMapper, SIGNAL(mapped(QString)), this, SLOT(exportFile(QString)));
_importMapper = new QSignalMapper(this);
connect(_importMapper, SIGNAL(mapped(QString)), this, SLOT(importFile(QString)));
_resetMapper = new QSignalMapper(this);
connect(_resetMapper, SIGNAL(mapped(QString)), this, SLOT(resetFile(QString)));
connect(ui->btnImportFile, SIGNAL(clicked()), this, SLOT(importFromDisk()));
connect(ui->btnNewFile, SIGNAL(clicked()), this, SLOT(newFile()));
}
FileEditionWidget::~FileEditionWidget()
{
delete ui;
}
void FileEditionWidget::setInteractionEnabled(bool value)
{
ui->btnImportFile->setEnabled(value);
ui->btnNewFile->setEnabled(value);
ui->tableWidget->setEnabled(value);
}
void FileEditionWidget::setNetworkConnection(NetworkConnection *connection)
{
_connection = connection;
_connection->registerNetworkResponder(this);
}
void FileEditionWidget::setFileCategory(int category)
{
_category = category;
}
void FileEditionWidget::addAllowedExtension(const QString &extension)
{
_allowedExtensions << extension;
}
void FileEditionWidget::refresh()
{
_connection->getComm()->askFiles(_category);
}
void FileEditionWidget::clear()
{
ui->tableWidget->clear();
}
void FileEditionWidget::setFiles(const QStringList &filenames)
{
ui->tableWidget->clear();
ui->tableWidget->setColumnCount(2);
ui->tableWidget->setRowCount(filenames.count());
ui->tableWidget->horizontalHeader()->setSectionResizeMode(QHeaderView::ResizeToContents);
ui->tableWidget->horizontalHeader()->setSectionResizeMode(FilenamePos, QHeaderView::Stretch);
int row = 0;
foreach(const QString& file, filenames)
{
QTableWidgetItem* item = new QTableWidgetItem(file);
ui->tableWidget->setItem(row, FilenamePos, item);
ButtonWidget* btns = new ButtonWidget(this);
ui->tableWidget->setCellWidget(row, ButtonsPos, btns);
_editMapper->setMapping(btns, file);
_exportMapper->setMapping(btns, file);
_importMapper->setMapping(btns, file);
_resetMapper->setMapping(btns, file);
connect(btns, SIGNAL(editFile()), _editMapper, SLOT(map()));
connect(btns, SIGNAL(exportFile()), _exportMapper, SLOT(map()));
connect(btns, SIGNAL(importFile()), _importMapper, SLOT(map()));
connect(btns, SIGNAL(removeFile()), _resetMapper, SLOT(map()));
++row;
}
}
QString FileEditionWidget::getFileAtRow(int row) const
{
return ui->tableWidget->item(row, FilenamePos)->text();
}
void FileEditionWidget::editData(const QString &filename, const QByteArray &data)
{
QTemporaryFile tmp(QString("Edition_XXXXXX_").append(filename));
if (tmp.open())
{
tmp.write(data);
tmp.close();
QString tmpFilePath = QFileInfo(tmp.fileName()).absoluteFilePath();
bool editionOK = false;
QFileInfo info(filename);
if (info.suffix() == "ngrid")
{
if (!_gridEditor)
{
_gridEditor = new GridEditor(this, true, true);
_gridEditor->setLastTable();
_gridEditor->setWindowModality(Qt::WindowModal);
_gridEditor->restoreGeometry(_gridEditorGeometry);
_gridEditor->restoreState(_gridEditorState);
_gridEditor->setZoom(_gridEditorZoom);
connect(_gridEditor, SIGNAL(accepted()), this, SLOT(editionFinished()));
connect(_gridEditor, SIGNAL(rejected()), this, SLOT(editionCanceled()));
}
if (!_gridEditor->isVisible())
{
_gridEditor->open(tmpFilePath);
_gridEditor->show();
editionOK = true;
_currentEditionData.editor = _gridEditor;
}
}
else if (info.suffix() == "nsettings")
{
if (!_propertyDialog)
{
_propertiesBrowser = new Tools::NSettingsPropertyBrowser(this);
_propertyDialog = createEditionDialog(_propertiesBrowser);
_propertyDialog->setWindowModality(Qt::WindowModal);
_propertyDialog->restoreGeometry(_propertyDialogGeometry);
connect(_propertyDialog, SIGNAL(accepted()), this, SLOT(editionFinished()));
connect(_propertyDialog, SIGNAL(rejected()), this, SLOT(editionCanceled()));
}
if (!_propertyDialog->isVisible())
{
Tools::NSettings settings;
settings.loadFrom(tmpFilePath);
_propertiesBrowser->setSettings(settings);
_propertyDialog->show();
editionOK = true;
_currentEditionData.editor = _propertiesBrowser;
}
}
else if (info.suffix() == "ns")
{
if (!_nsDialog)
{
_nsEditor = new NSEditor(this);
_nsEditor->addSearchDirectory(_connection->getGlobalScriptDirectory());
_nsEditor->setFileManagementEnabled(false);
_nsDialog = createEditionDialog(_nsEditor);
_nsDialog->setWindowModality(Qt::WindowModal);
_nsDialog->restoreGeometry(_nsDialogGeometry);
connect(_nsDialog, SIGNAL(accepted()), this, SLOT(editionFinished()));
connect(_nsDialog, SIGNAL(rejected()), this, SLOT(editionCanceled()));
}
if (!_nsDialog->isVisible())
{
_nsEditor->setScript(data);
_nsDialog->show();
editionOK = true;
_currentEditionData.editor = _nsEditor;
}
}
else
{
if (!_textDialog)
{
_plainTextEditor = new QPlainTextEdit(this);
_textDialog = createEditionDialog(_plainTextEditor);
_textDialog->setWindowModality(Qt::WindowModal);
_textDialog->restoreGeometry(_textDialogGeometry);
connect(_textDialog, SIGNAL(accepted()), this, SLOT(editionFinished()));
connect(_textDialog, SIGNAL(rejected()), this, SLOT(editionCanceled()));
}
if (!_textDialog->isVisible())
{
_plainTextEditor->setPlainText(data);
_textDialog->show();
editionOK = true;
_currentEditionData.editor = _plainTextEditor;
}
}
if (editionOK)
{
_currentEditionData.filename = filename;
_currentEditionData.localFile = tmpFilePath;
}
else
{
_currentEditionData.filename.clear();
_currentEditionData.localFile.clear();
_currentEditionData.editor = nullptr;
QMessageBox::critical(this, "Edition failed", QString("Cannot edit ").append(filename));
}
}
}
void FileEditionWidget::importFromDisk()
{
QString file = QFileDialog::getOpenFileName(this, "Select a file to import", QString(), buildFileFilter());
if (!file.isEmpty())
{
QFile f(file);
if (f.open(QIODevice::ReadOnly))
{
QByteArray data = f.readAll();
_connection->getComm()->sendFileData(_category, QFileInfo(file).fileName(), data);
QTimer::singleShot(500, this, SLOT(refresh()));
f.close();
}
}
}
void FileEditionWidget::newFile()
{
QString name = QInputDialog::getText(this, "New file", "Type the name and extension of the file.", QLineEdit::Normal, "New File");
if (!name.isEmpty())
{
QFileInfo info(name);
if (!_allowedExtensions.isEmpty() && (info.suffix().isEmpty() || (!_allowedExtensions.contains(info.suffix()) && !_allowedExtensions.contains(QString()))))
{
QString defaultExt = _allowedExtensions.value(0);
if (!defaultExt.isEmpty())
{
name += ".";
name += defaultExt;
}
}
_connection->getComm()->sendFileData(_category, name, QByteArray());
QTimer::singleShot(500, this, SLOT(refresh()));
}
}
void FileEditionWidget::editionFinished()
{
bool readFromTmpFile = false;
_askFileContext = None;
QByteArray data;
if (_currentEditionData.editor == _nsEditor)
{
data = _nsEditor->getScript().toLatin1();
}
else if (_currentEditionData.editor == _propertiesBrowser)
{
Tools::NSettings settings = _propertiesBrowser->getSettings();
settings.writeTo(_currentEditionData.localFile);
readFromTmpFile = true;
}
else if (_currentEditionData.editor == _plainTextEditor)
{
data = _plainTextEditor->toPlainText().toLatin1();
}
else
{
readFromTmpFile = true;
}
if (readFromTmpFile)
{
QFile f(_currentEditionData.localFile);
if (f.open(QIODevice::ReadOnly))
{
data = f.readAll();
f.close();
}
}
QFile::remove(_currentEditionData.localFile);
if (_category == Comm::GlobalScripts)
_connection->getNsEnvReplicator().refreshWithData(_currentEditionData.filename, data);
_connection->getComm()->sendFileData(_category, _currentEditionData.filename, data);
}
void FileEditionWidget::editionCanceled()
{
_askFileContext = None;
QFile::remove(_currentEditionData.localFile);
}
ButtonWidget::ButtonWidget(QWidget *parent) : QWidget(parent)
{
QToolButton* editBtn = new QToolButton(this);
editBtn->setText("Edit");
editBtn->setToolTip("Edit the file");
editBtn->setIcon(QIcon(":/buttons/edit"));
editBtn->setAutoRaise(true);
editBtn->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
connect(editBtn, SIGNAL(clicked()), this, SIGNAL(editFile()));
QToolButton* exportBtn = new QToolButton(this);
exportBtn->setText("Export");
exportBtn->setToolTip("Export the file");
exportBtn->setIcon(QIcon(":/buttons/export"));
exportBtn->setAutoRaise(true);
exportBtn->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
connect(exportBtn, SIGNAL(clicked()), this, SIGNAL(exportFile()));
QToolButton* importBtn = new QToolButton(this);
importBtn->setText("Import");
importBtn->setToolTip("Import the file");
importBtn->setIcon(QIcon(":/buttons/import"));
importBtn->setAutoRaise(true);
importBtn->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
connect(importBtn, SIGNAL(clicked()), this, SIGNAL(importFile()));
QToolButton* resetBtn = new QToolButton(this);
resetBtn->setText("Reset");
resetBtn->setToolTip("Reset/Delete the file");
resetBtn->setIcon(QIcon(":/buttons/reset"));
resetBtn->setAutoRaise(true);
resetBtn->setToolButtonStyle(Qt::ToolButtonTextBesideIcon);
connect(resetBtn, SIGNAL(clicked()), this, SIGNAL(removeFile()));
QHBoxLayout* layout = new QHBoxLayout(this);
layout->setContentsMargins(0,0,0,0);
layout->setSpacing(0);
layout->addSpacing(5);
layout->addWidget(editBtn);
layout->addSpacing(4);
layout->addWidget(exportBtn);
layout->addWidget(importBtn);
layout->addSpacing(4);
layout->addWidget(resetBtn);
layout->addSpacing(5);
}
QDialog *FileEditionWidget::createEditionDialog(QWidget *mainWidget)
{
QDialog* d = new QDialog(this);
QVBoxLayout* mainLayout = new QVBoxLayout(d);
QHBoxLayout* buttonsLayout = new QHBoxLayout;
QPushButton* btnOK = new QPushButton(d);
btnOK->setText("OK");
connect(btnOK, SIGNAL(clicked()), d, SLOT(accept()));
QPushButton* btnCancel = new QPushButton(d);
btnCancel->setText("Cancel");
connect(btnCancel, SIGNAL(clicked()), d, SLOT(reject()));
buttonsLayout->addStretch();
buttonsLayout->addWidget(btnOK);
buttonsLayout->addWidget(btnCancel);
mainLayout->addWidget(mainWidget);
mainLayout->addLayout(buttonsLayout);
d->resize(1000, 500);
return d;
}
QString FileEditionWidget::buildFileFilter()
{
QString filter;
foreach(const QString& ext, _allowedExtensions)
{
filter += " *.";
if (ext.isEmpty())
filter += "*";
else
filter += ext;
}
return filter;
}
void FileEditionWidget::configurationFiles(int category, const QStringList &filenames)
{
if (_category == category)
{
clear();
setFiles(filenames);
}
}
void FileEditionWidget::configurationFileData(int category, const QString &filename, const QByteArray &data)
{
if (_category == category)
{
if (_askFileContext == Edition)
{
editData(filename, data);
}
else if (_askFileContext == Export)
{
QString filter = QString(".*").append(QFileInfo(filename).suffix());
QString localFile = QFileDialog::getSaveFileName(this, "Select a location", filename, filter);
if (!localFile.isEmpty())
{
QFile file(localFile);
if (file.open(QIODevice::WriteOnly))
file.write(data);
else
QMessageBox::critical(this, "Error", QString("Export in ").append(filename).append(" failed!"));
}
}
}
}
bool FileEditionWidget::editionInProgress() const
{
return (_gridEditor && _gridEditor->isVisible())
|| (_propertyDialog && _propertyDialog->isVisible())
|| (_textDialog && _textDialog->isVisible());
}
void FileEditionWidget::loadSettings(QSettings *settings)
{
_gridEditorGeometry = settings->value("GridEditorGeometry").toByteArray();
_gridEditorState = settings->value("GridEditorState").toByteArray();
_gridEditorZoom = settings->value("GridEditorZoom", 0.25).toDouble();
_propertyDialogGeometry = settings->value("PropertiesEditorGeometry").toByteArray();
_textDialogGeometry = settings->value("TextEditorGeometry").toByteArray();
_nsDialogGeometry = settings->value("NSEditorGeometry").toByteArray();
}
void FileEditionWidget::saveSettings(QSettings *settings)
{
if (_gridEditor)
{
settings->setValue("GridEditorGeometry", _gridEditor->saveGeometry());
settings->setValue("GridEditorState", _gridEditor->saveState());
settings->setValue("GridEditorZoom", _gridEditor->getZoom());
}
if (_propertyDialog)
settings->setValue("PropertiesEditorGeometry", _propertyDialog->saveGeometry());
if (_textDialog)
settings->setValue("TextEditorGeometry", _textDialog->saveGeometry());
if (_nsDialog)
settings->setValue("NSEditorGeometry", _nsDialog->saveGeometry());
}
void FileEditionWidget::rowDoubleClicked(int row)
{
QString file = getFileAtRow(row);
editFile(file);
}
void FileEditionWidget::exportFile(const QString &file)
{
_askFileContext = Export;
_connection->getComm()->askFileData(_category, file);
}
void FileEditionWidget::importFile(const QString &file)
{
QString filter = QString("*.").append(QFileInfo(file).suffix());
QString localFile = QFileDialog::getOpenFileName(this, "Select a file", QString(), filter);
if (!localFile.isEmpty())
{
QFile f(localFile);
if (f.open(QIODevice::ReadOnly))
{
QByteArray data = f.readAll();
_connection->getComm()->sendFileData(_category, file, data);
f.close();
}
}
}
void FileEditionWidget::resetFile(const QString &file)
{
if (QMessageBox::question(this, "Reset/Remove a file", QString("Are you sure, you want to remove the file ").append(file).append("?"),
QMessageBox::Yes | QMessageBox::No, QMessageBox::Yes) == QMessageBox::Yes)
{
_connection->getComm()->resetFileData(_category, file);
refresh();
}
}
void FileEditionWidget::editFile(const QString &file)
{
if (!editionInProgress())
{
_askFileContext = Edition;
_connection->getComm()->askFileData(_category, file);
}
}
| [
"[email protected]"
] | |
4276be6993e61e65db65dc4ff2ac1a9a6a543345 | 34b02bdc74ffd35caf0ced89612e413e43ef9e70 | /project/QtOpenCV/src/QPublic.cpp | 4079f452e3a54b3ceac80573441195e070d3a99a | [] | no_license | Makmanfu/CppNote | 693f264e3984c6e2e953e395b836306197cc9632 | e1c76e036df4a9831618704e9ccc0ad22cd4b748 | refs/heads/master | 2020-03-26T01:11:51.613952 | 2018-08-10T06:52:21 | 2018-08-10T06:52:39 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 14,032 | cpp |
#include "stdafx.h"
#include "QPublic.h"
QString TCSR(QString str)
{
#if (QT_VERSION > QT_VERSION_CHECK(4, 8, 7))
return "";
#else
return QString::fromLocal8Bit(str.toAscii());
#endif
}
QPointF getPos(QMouseEvent* event)
{
#if (QT_VERSION > QT_VERSION_CHECK(4, 8, 7))
return event->localPos();
#else
return event->posF();
#endif
}
CommonHelper* CommonHelper::_instance = 0;
CommonHelper* CommonHelper::Instance()
{
if (NULL == _instance)
_instance = new CommonHelper();
return _instance;
}
QMoveDlg::QMoveDlg(QWidget* parent /*= 0*/) : QWidget(parent)
{
}
void QMoveDlg::mousePressEvent(QMouseEvent* ev)
{
m_PosDisp = ev->globalPos() - pos(); //记下当前点击的点坐标
//mPosDisp = ev->pos();
m_bPressed = true;
}
void QMoveDlg::mouseReleaseEvent(QMouseEvent* ev)
{
ev->accept();
m_bPressed = false;
}
void QMoveDlg::mouseMoveEvent(QMouseEvent* ev)
{
if (m_bPressed)
{
//方法1：达到移动窗口作用 同时限制移动区域
QPoint point(ev->globalPos() - m_PosDisp);
QRect windowRect;
//获得父窗口
if (nullptr != this->parent())
windowRect = QRect(((QWidget*)(this->parent()))->geometry());
else
windowRect = QRect(QApplication::desktop()->availableGeometry());
QRect widgetRect(this->frameGeometry());
int y = windowRect.bottomRight().y() - widgetRect.height();
int x = windowRect.bottomRight().x() - widgetRect.width();
//以下是防止窗口拖出可见范围外
//左,右,上,下
if (point.x() <= 0) point = QPoint(0, point.y());
if (point.y() >= y && widgetRect.topLeft().y() >= y) point = QPoint(point.x(), y);
if (point.y() <= 0) point = QPoint(point.x(), 0);
if (point.x() >= x && widgetRect.topLeft().x() >= x) point = QPoint(x, point.y());
move(point);
//方法2：
//可以通过判断QRect windowRect是否包含（contains） QRect widgetRect 再移动
//这里没有给出代码
}
}
FlowLayout::FlowLayout(QWidget* parent, int margin, int hSpacing, int vSpacing)
: QLayout(parent), m_hSpace(hSpacing), m_vSpace(vSpacing)
{
setContentsMargins(margin, margin, margin, margin);
}
FlowLayout::FlowLayout(int margin, int hSpacing, int vSpacing)
: m_hSpace(hSpacing), m_vSpace(vSpacing)
{
setContentsMargins(margin, margin, margin, margin);
}
FlowLayout::~FlowLayout()
{
QLayoutItem* item;
while ((item = takeAt(0)))
delete item;
}
void FlowLayout::addItem(QLayoutItem* item)
{
itemList.append(item);
}
int FlowLayout::horizontalSpacing() const
{
if (m_hSpace >= 0)
return m_hSpace;
else
return smartSpacing(QStyle::PM_LayoutHorizontalSpacing);
}
int FlowLayout::verticalSpacing() const
{
if (m_vSpace >= 0)
return m_vSpace;
else
return smartSpacing(QStyle::PM_LayoutVerticalSpacing);
}
int FlowLayout::count() const
{
return itemList.size();
}
QLayoutItem* FlowLayout::itemAt(int index) const
{
return itemList.value(index);
}
QLayoutItem* FlowLayout::takeAt(int index)
{
if (index >= 0 && index < itemList.size())
return itemList.takeAt(index);
else
return 0;
}
Qt::Orientations FlowLayout::expandingDirections() const
{
return 0;
}
bool FlowLayout::hasHeightForWidth() const
{
return true;
}
int FlowLayout::heightForWidth(int width) const
{
int height = doLayout(QRect(0, 0, width, 0), true);
return height;
}
void FlowLayout::setGeometry(const QRect& rect)
{
QLayout::setGeometry(rect);
doLayout(rect, false);
}
QSize FlowLayout::sizeHint() const
{
return minimumSize();
}
QSize FlowLayout::minimumSize() const
{
QSize size;
QLayoutItem* item;
foreach(item, itemList)
size = size.expandedTo(item->minimumSize());
size += QSize(2 * margin(), 2 * margin());
return size;
}
int FlowLayout::doLayout(const QRect& rect, bool testOnly) const
{
int left, top, right, bottom;
getContentsMargins(&left, &top, &right, &bottom);
QRect effectiveRect = rect.adjusted(+left, +top, -right, -bottom);
int x = effectiveRect.x();
int y = effectiveRect.y();
int lineHeight = 0;
QLayoutItem* item;
foreach(item, itemList)
{
QWidget* wid = item->widget();
int spaceX = horizontalSpacing();
if (spaceX == -1)
spaceX = wid->style()->layoutSpacing(
QSizePolicy::PushButton, QSizePolicy::PushButton, Qt::Horizontal);
int spaceY = verticalSpacing();
if (spaceY == -1)
spaceY = wid->style()->layoutSpacing(
QSizePolicy::PushButton, QSizePolicy::PushButton, Qt::Vertical);
int nextX = x + item->sizeHint().width() + spaceX;
if (nextX - spaceX > effectiveRect.right() && lineHeight > 0)
{
x = effectiveRect.x();
y = y + lineHeight + spaceY;
nextX = x + item->sizeHint().width() + spaceX;
lineHeight = 0;
}
if (!testOnly)
item->setGeometry(QRect(QPoint(x, y), item->sizeHint()));
x = nextX;
lineHeight = qMax(lineHeight, item->sizeHint().height());
}
return y + lineHeight - rect.y() + bottom;
}
int FlowLayout::smartSpacing(QStyle::PixelMetric pm) const
{
QObject* parent = this->parent();
if (!parent)
return -1;
else if (parent->isWidgetType())
{
QWidget* pw = static_cast<QWidget*>(parent);
return pw->style()->pixelMetric(pm, 0, pw);
}
else
return static_cast<QLayout*>(parent)->spacing();
}
TabGUIBase::TabGUIBase(QWidget* parent) : QWidget(parent)
{
//设置字体
QFont ft = QFont(TCSR("微软雅黑"));
ft.setPointSize(8);
this->setFont(ft);
// 加载QSS样式
//CUiTool::Instance()->QWidgetSetStyle(this, "style.qss");
//CommonHelper::Instance()->setStyle("style.qss");
//锁定控件最小值
this->setMinimumSize(600, 600);
//setWindowOpacity(0.95);
if (this->objectName().isEmpty())
this->setObjectName(QString::fromUtf8("TabGUIBase"));
this->resize(373, 146);
this->setContextMenuPolicy(Qt::DefaultContextMenu);
QIcon icon;
icon.addFile(QString::fromUtf8(":/Res/tray.ico"), QSize(), QIcon::Normal, QIcon::Off);
this->setWindowIcon(icon);
this->setWindowTitle(TCSR("TabGUIBase"));
GuiInit();
}
TabGUIBase::~TabGUIBase()
{
//改成未选择就行了
OnComBoxPageIndexChanged(0);
if (m_pGrid != NULL)
{
delete m_pGrid;
m_pGrid = NULL;
}
}
void TabGUIBase::addcomboxItem(const QString& str)
{
m_pComBoxPage->insertItem(m_pComBoxPage->count(), str);
}
void TabGUIBase::GuiInit(void)
{
//创建启动器
m_pPageUI = new UIDirect();
m_pWgtShow = new QWidget(this);
m_pWgtShow->move(0, 0);
m_pGrid = new QGridLayout; //设置布局哦
m_pGrid->addWidget(m_pWgtShow, 0, 0);
m_pGrid->setMargin(0);
this->setLayout(m_pGrid);
m_pGridW = new QGridLayout;
m_pGridW->setMargin(0);
m_pWgtShow->setLayout(m_pGridW);
m_pComBoxPage = new QComboBox(this);
m_pComBoxPage->setFixedSize(100, 25);
m_pComBoxPage->setWindowFlags(Qt::WindowStaysOnTopHint);
m_pComBoxPage->move(10, 10);
m_pComBoxPage->setEditable(false); //屏蔽编辑
m_pComBoxPage->setMaxCount(15); //超过15个出现滚动条
connect(m_pComBoxPage, SIGNAL(currentIndexChanged(int)), this, SLOT(OnComBoxPageIndexChanged(int)));
m_pComBoxPage->insertItem(0, TCSR("NULL"));
//addcomboxItem(TCSR("QWidget"));
}
void TabGUIBase::setHideComBox(bool _bl)
{
this->m_pComBoxPage->setVisible(_bl);
}
void TabGUIBase::OnComBoxPageIndexChanged(int nId)
{
m_pPageUI->Free();
switch (nId)
{
case 0:
default:
m_pCurrUI = new QWidget(m_pWgtShow);
break;
case 1:
m_pCurrUI = new QWidget(m_pWgtShow);
break;
}
m_pCurrUI->setParent(m_pWgtShow);
m_pPageUI->SetQWidget(m_pCurrUI);
m_pPageUI->Create(m_pGridW);
}
CUiTool* CUiTool::_instance = 0;
CUiTool* CUiTool::Instance()
{
if (NULL == _instance)
_instance = new CUiTool();
return _instance;
}
void CUiTool::TestBox(const QString& str, QWidget* parent)
{
//QMessageBox::about(parent, TCSR("TEST"), TCSR("here it is!"));
QMessageBox::about(parent, TCSR("TEST"), str);
}
void CUiTool::setStyle(const QString& style)
{
QFile qss(style);
qss.open(QFile::ReadOnly);
qApp->setStyleSheet(qss.readAll());
qss.close();
}
void CUiTool::QWidgetSetStyle(QWidget* QW, const QString& style)
{
// 加载QSS样式
QFile qss("style.qss");
qss.open(QFile::ReadOnly);
QW->setStyleSheet(qss.readAll());
qss.close();
}
void CUiTool::loaddll(QString dllname, QWidget* dlg)
{
typedef void(*myfun)(QWidget*); // 定义导出函数类型
QLibrary hdll(dllname);
if (hdll.load())
{
//用resolve来解析fun1函数
myfun fun = (myfun)hdll.resolve("ShowWidget");
//解析成功则进行运算并提示相关信息
if (fun) fun(dlg);
}
}
void CUiTool::loaddll(QString dllname, QWidget* dlg, QGridLayout* gl)
{
typedef void(*myfun)(QWidget*, QGridLayout*); // 定义导出函数类型
QLibrary hdll(dllname);
if (hdll.load())
{
//用resolve来解析fun1函数
myfun fun = (myfun)hdll.resolve("ShowWidgetGL");
//解析成功则进行运算并提示相关信息
if (fun) fun(dlg, gl);
}
}
void CUiTool::loaddll(QString dllname, char* funname)
{
typedef void(*myfun)(void); // 定义导出函数类型
QLibrary hdll(dllname);
if (hdll.load())
{
//用resolve来解析fun1函数
myfun fun = (myfun)hdll.resolve(funname);
//解析成功则进行运算并提示相关信息
if (fun) fun();
}
}
bool CUiTool::RunCheckOnly(QString appname)
{
// 确保只运行一次
QSystemSemaphore sema("QtJAMKey", 1, QSystemSemaphore::Open);
// 在临界区操作共享内存 SharedMemory
sema.acquire();
// 全局对象名
static QSharedMemory mem(appname);
// 如果全局对象以存在则退出
if (!mem.create(1))
{
sema.release();// 如果是 Unix 系统，会自动释放。
return false;
}
sema.release();// 临界区
return true;
}
void CUiTool::GetFilelist(QStringList& files, QString path, QString extname)
{
//判断路径是否存在
QDir dir(path);
if (!dir.exists())
return;
dir.setFilter(QDir::Files | QDir::NoSymLinks);
QFileInfoList list = dir.entryInfoList();
int file_count = list.count();
if (file_count <= 0)
return;
for (int i = 0; i < file_count; i++)
{
QFileInfo file_info = list.at(i);
QString suffix = file_info.suffix();
if (QString::compare(suffix, extname, Qt::CaseInsensitive) == 0)
{
QString absolute_file_path = file_info.absoluteFilePath();
files.append(absolute_file_path);
//qDebug() << absolute_file_path;
}
}
}
//内部使用
QString GetResPath()
{
#ifdef RES_STATIC
return ":/images/Resources/";
#else
return "./images/";
#endif
}
void CUiTool::InitPushButton(QPushButton* button, QString strPmpNormal, QString strPmpHover, QString strPmpPressed, QString strPmpDisabled)
{
button->setFocusPolicy(Qt::NoFocus);
QPixmap pmp = QPixmap(GetResPath() + strPmpNormal);
button->setFixedSize(pmp.size());
QString strStyleSheet = QString(" QPushButton { border: 0pt solid #abc; border-image: url(" + GetResPath() + "%1);}").arg(strPmpNormal);
if (strPmpHover.length() > 0)
strStyleSheet += QString(" QPushButton:hover { border-image: url(" + GetResPath() + "%1);}").arg(strPmpHover);
if (strPmpPressed.length() > 0)
strStyleSheet += QString(" QPushButton:pressed { border-image: url(" + GetResPath() + "%1);}").arg(strPmpPressed);
if (strPmpDisabled.length() > 0)
strStyleSheet += QString(" QPushButton:disabled { border-image: url(" + GetResPath() + "%1);}").arg(strPmpDisabled);
button->setStyleSheet(strStyleSheet);
}
void CUiTool::InitPushButton(QPushButton* button, QString strPmp, QString strText, int nWidth, int nHeight, int nFontSize, int nColor)
{
button->setFocusPolicy(Qt::NoFocus);
button->setFixedSize(nWidth, nHeight);
QPixmap pmp = QPixmap(GetResPath() + strPmp);
QString strStyleSheet = QString(" QPushButton { font-size:%1px; font-weight:normal; color:rgb(%2, %3, %4); }").arg(nFontSize).arg(nColor >> 16).arg((nColor >> 8) & 0xFF).arg(nColor & 0xFF);
strStyleSheet += " QPushButton { background-repeat: no repeat; background-position: left; border-radius: 5px; border: 0pt solid #abc;}";
strStyleSheet += " QPushButton:hover { border: 2pt solid #abc; color:rgb(0, 0, 0); }";
strStyleSheet += " QPushButton:pressed { border: 0pt solid #abc; color:rgb(0, 0, 0); }";
button->setStyleSheet(strStyleSheet);
// QFont Font = button->font();
// Font.setPixelSize(nFontSize);
// button->setFont(Font);
button->setIcon(QIcon(pmp));
button->setText(strText);
button->setFlat(true);
}
CMylay::CMylay(QWidget *parent) :QGridLayout(parent)
{
this->setParent(parent);
this->setSpacing(0);
this->setContentsMargins(0, 0, 0, 0);
//// 下面代码将被优化掉
//m_mapWidget = new MapWidget(ui->wdgmap);
//m_maplay = new QGridLayout(ui->wdgmap);
//m_maplay->setSpacing(0);
//m_maplay->setContentsMargins(0, 0, 0, 0);
//m_maplay->addWidget(m_mapWidget);
//调用如下
//m_mapWidget = new SeaMapWidget(ui->wdgmap);
//m_maplay = new CMylay(ui->wdgmap);
//m_maplay->setWgt(m_mapWidget);
}
CMylay::~CMylay()
{
}
void CMylay::setWgt(QWidget *wgt)
{
this->setSpacing(0);
this->setContentsMargins(0, 0, 0, 0);
this->addWidget(wgt);
}
| [
"[email protected]"
] | |
d2edbf3c64c43be0903fd85575791ee3ae132e12 | 221b0d7d432aa639979fca58b4e98d221d08048a | /assign4/program1.cpp | b5d0f1e5a76289798c77d4f117b3ff2365fdc88b | [] | no_license | nish17/object-oriented-programming | 58c8f84adf893dc620f98fedbc42e7ee62fe6661 | 73ddcbe944257de5e5740c398cec4417d8a65bff | refs/heads/master | 2021-09-14T07:51:03.770054 | 2018-05-10T07:04:21 | 2018-05-10T07:04:21 | 117,770,554 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 1,727 | cpp | #include <bits/stdc++.h>
using namespace std;
class Microsoft
{
int employees;
string hq, name;
public:
Microsoft()
{
employees = 10000;
name = "Microsoft";
}
int getNoOfEmployees()
{
return employees;
}
string getBrandName()
{
return name;
}
string getHQ()
{
hq = "Redmond, Washington, United States";
return hq;
}
};
class Hardware : public Microsoft
{
string name;
public:
vector<string> products;
Hardware()
{
products.push_back("keyboard");
products.push_back("mouse");
products.push_back("Surface");
products.push_back("Windows Phone");
}
string getClassName()
{
name = "Hardware";
return name;
}
void inputs()
{
string in;
getline(cin, in);
products.push_back(in);
}
int getProductsLength()
{
return products.capacity();
}
};
class Software : public Hardware
{
string name;
public:
vector<string> products;
Software()
{
products.push_back("Windows OS");
products.push_back("Skype");
products.push_back("Outlook");
products.push_back("Office");
// inputs();
}
string getClassName()
{
name = "Software";
return name;
}
};
int main()
{
Microsoft ma;
Hardware ha;
Software sa;
cout << " Number of employees at " << ma.getBrandName() << " is " << ma.getNoOfEmployees() << " and its hq is in " << ma.getHQ() << endl;
// << ha.getProductsLength() << endl;
cout << "\n\n\n\n";
for (int i = 0; i < ha.getProductsLength(); i++)
{
cout << ha.getBrandName() + " " + ha.products[i] + " (" + ha.getClassName() + ") " << endl;
cout << sa.getBrandName() + " " + sa.products[i] + " (" + sa.getClassName() + ") " << endl;
}
return 0;
} | [
"[email protected]"
] | |
3feeed093fe6255a2af60675b1cb65b6f4d82793 | cf28547f46b6965dcdb0271f7d66a483df1c10e4 | /views/console/ConsoleView.h | 8c6b95241461249b7a42ca7b1300a166fcb7f166 | [] | no_license | thar/Klondike | c5f69c09739c8bccc30e5b718e9114333ac11222 | 4b97c94c6f12a79971813737c17624d759e73288 | refs/heads/master | 2021-01-01T05:09:14.505740 | 2016-10-17T14:44:30 | 2019-11-01T09:28:28 | 56,752,027 | 0 | 0 | null | 2019-11-01T09:28:29 | 2016-04-21T07:29:05 | C++ | UTF-8 | C++ | false | false | 1,006 | h | #ifndef KLONDIKE_CONSOLEVIEW_H
#define KLONDIKE_CONSOLEVIEW_H
#include "../../View.h"
#include "ActionListView.h"
#include "../../controllers/local/UserActionListController.h"
#include "../../controllers/local/AutomaticDeckActionListController.h"
#include "../../controllers/local/AutomaticGameActionListController.h"
#include "../../controllers/local/LocalScoreController.h"
namespace views
{
namespace console
{
class ConsoleView : public View
{
public:
void interact(controllers::OperationController &operationController);
void visit(controllers::local::UserActionListController& controller);
void visit(controllers::local::AutomaticDeckActionListController& controller);
void visit(controllers::local::AutomaticGameActionListController& controller);
void visit(controllers::local::LocalScoreController& controller);
protected:
private:
};
}
}
#endif //KLONDIKE_CONSOLEVIEW_H
| [
"[email protected]"
] | |
bd4ef3c61cb310e8175e5e7061a012e86ef653d1 | 345185c88e1a2eac12c812b03f69cda5a1f310fa | /Coding Practice/35. Kth Smallest Element in a BST.cpp | ee8577b97e878abcc265268e19e8066a3ade884d | [] | no_license | changkk/ckrobotics | 722b1d606c500f9c3d71837e303885eec17a108a | 03d1e53caccda3f2be07817ad43051ffce22714e | refs/heads/master | 2023-02-08T04:33:21.447764 | 2020-12-26T01:11:48 | 2020-12-26T01:11:48 | 285,646,815 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,685 | cpp | /**
* Definition for a binary tree node.
* struct TreeNode {
* int val;
* TreeNode *left;
* TreeNode *right;
* TreeNode() : val(0), left(nullptr), right(nullptr) {}
* TreeNode(int x) : val(x), left(nullptr), right(nullptr) {}
* TreeNode(int x, TreeNode *left, TreeNode *right) : val(x), left(left), right(right) {}
* };
*/
/*
DFS
Go far left which is the smallest, and once get to the end, check if there is right
If there is right, go to the left end. Do this until there is not left and right.
If there is no both left and right, pop it.
example1
stack
3 -> 1
*/
class Solution {
public:
int kthSmallest(TreeNode* root, int k) {
int count = 0;
while(root)
{
if(root->left)
{
TreeNode* pre = root->left;
while(pre->right && pre->right != root)
pre = pre->right;
if(!pre->right)
{
pre->right = root;
root = root->left;
}
else
{
pre->right = NULL;
count++;
if(count == k)
{
return root->val;
}
root = root->right;
}
}
else
{
count++;
if(count == k)
{
return root->val;
}
root = root->right;
}
}
return 0;
}
}; | [
"[email protected]"
] | |
0ff4e05cef2b67543838c50d9b16b098fa8dfb4e | af0b174f94cdc2ecb40c22513071855c53c110b6 | /src/Camera/Camera.cpp | d6b42824264a1242146fae3e2221fc842ec0a694 | [] | no_license | Idefix96/3D_Studio | 0d2297cced381d6724f1cfa178d4bc6fe9758686 | a1dddd8f9d1f454d647c8d6d8d56f0da7c5ddcbb | refs/heads/master | 2021-05-07T07:00:03.645369 | 2017-12-06T10:40:11 | 2017-12-06T10:40:11 | 111,781,810 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,253 | cpp | #include "Camera.h"
Camera::Camera(float fov, float width, float height, float zNear, float zFar)
{
Camera::mPerspectiveMatrix = glm::perspective(fov, width / height, zNear, zFar);
Camera::vPosition = glm::vec3(6.5,3,4);
Camera::mRotY = glm::mat4(1.0f);
Camera::mRotX = glm::mat4(1.0f);
//OpenGL standard: camera looks along negative z-axis
Camera::vCenter = glm::vec3(0,0,-1);
Camera::vUp = glm::vec3(0,1,0);
Camera::vLookDir = glm::normalize(Camera::vCenter - Camera::vPosition);
Camera::mWorldToCameraMatrix = glm::lookAt(Camera::vPosition, Camera::vCenter, Camera::vUp);
m_Fovy = fov;
m_Width = width;
m_Height = height;
m_zNear = zNear;
m_zFar = zFar;
}
void Camera::MapCameraToShader(GLuint shader)
{
glUseProgram(shader);
glUniformMatrix4fv(glGetUniformLocation(shader,"gPersp"), 1, GL_FALSE, glm::value_ptr(mPerspectiveMatrix));
glUniformMatrix4fv(glGetUniformLocation(shader,"gWorldToCamera"), 1, GL_FALSE, glm::value_ptr(getWorldToCameraMatrix()));
glm::mat4 CamBT =glm::lookAt(glm::vec3(0), Camera::vLookDir, Camera::vUp);
glUniformMatrix4fv(glGetUniformLocation(shader,"gCameraRotation"), 1, GL_FALSE, glm::value_ptr(CamBT));
glUniform3fv(glGetUniformLocation(shader, "EyePos"),1, glm::value_ptr(getPosition()));
glUniform3fv(glGetUniformLocation(shader, "CameraRight"),1, glm::value_ptr(getXVector()));
//glUniform3fv(glGetUniformLocation(shader, "CameraUp"),1, glm::value_ptr(vUp));
glm::vec4 vTempUp = Camera::mRotX*glm::vec4(Camera::vUp.x,Camera::vUp.y, Camera::vUp.z,0.0);
glUniform3fv(glGetUniformLocation(shader, "CameraUp"),1, glm::value_ptr(glm::vec3(vTempUp.x,vTempUp.y,vTempUp.z)));
glUniform3fv(glGetUniformLocation(shader, "CameraLook"),1, glm::value_ptr(vLookDir));
}
//sets the camera to a specific point vTranslation
void Camera::Translate(glm::vec3 vTranslation)
{
Camera::vPosition += vTranslation;
Camera::Update();
}
//rotates the Camera around global y-axis by fAlpha
void Camera::RotateAroundYaxis(float fAlpha)
{
Camera::mRotY = glm::rotate(glm::mat4(1.0f),fAlpha,glm::vec3(0.0,1.0,0.0));
glm::vec4 vTempLookDir = Camera::mRotY*glm::vec4(Camera::vLookDir.x, Camera::vLookDir.y, Camera::vLookDir.z, 0.0f);
Camera::vLookDir = normalize(glm::vec3(vTempLookDir.x, vTempLookDir.y, vTempLookDir.z));
Camera::vCenter = Camera::vPosition + Camera::vLookDir;
Camera::Update();
}
//rotates the Camera around local x-axis by fAlpha
void Camera::RotateAroundXaxis(float fAlpha)
{
static float fAngle = glm::acos(glm::dot(glm::normalize(glm::vec3(0,1,0)),glm::normalize(vLookDir)));
if ( ((fAngle <= 3.0*3.1415926/4.0) && (fAngle >= 3.1415926/4.0)) || ((fAngle > 3.0*3.1415926/4.0) && (fAlpha < 0)) || ((fAngle < 3.1415926/4.0) && (fAlpha > 0)) )
{
fAngle += fAlpha;
Camera::mRotX = glm::rotate(glm::mat4(1.0f),fAlpha,glm::cross(Camera::vUp,Camera::vLookDir));
glm::vec4 vTempLookDir = Camera::mRotX*glm::vec4(Camera::vLookDir.x, Camera::vLookDir.y, Camera::vLookDir.z, 0.0f);
Camera::vLookDir = glm::normalize(glm::vec3(vTempLookDir.x, vTempLookDir.y, vTempLookDir.z));
Camera::vCenter = Camera::vPosition + Camera::vLookDir;
Camera::Update();
}
}
//moves the camera along vLookDir by fWay
void Camera::MoveForward(float fWay)
{
vPosition += glm::vec3(fWay*vLookDir.x, fWay*vLookDir.y, fWay*vLookDir.z);
vCenter += glm::vec3(fWay*vLookDir.x, fWay*vLookDir.y, fWay*vLookDir.z);
vLookDir = glm::normalize(Camera::vCenter - Camera::vPosition);
Camera::Update();
}
void Camera::MoveUp(float fWay)
{
vPosition += glm::vec3(0, fWay, 0);
vCenter += glm::vec3(0, fWay, 0);
vLookDir = glm::normalize(Camera::vCenter - Camera::vPosition);
Camera::Update();
}
void Camera::MoveOnGround(float fWay)
{
glm::vec2 vLookDir2D = glm::normalize(glm::vec2(vLookDir.x, vLookDir.z));
vPosition += glm::vec3(fWay*vLookDir2D.x, 0, fWay*vLookDir2D.y);
vCenter += glm::vec3(fWay*vLookDir2D.x, 0, fWay*vLookDir2D.y);
vLookDir = glm::normalize(Camera::vCenter - Camera::vPosition);
Camera::Update();
}
void Camera::TriggerRotationWithMouse()
{
bMouseClickDetected = true;
}
void Camera::ControlWithMouse(int x, int y)
{
static int iMouseLastPositionX = x;
static int iMouseLastPositionY = y;
if (!bMouseClickDetected)
{
iMouseLastPositionX = x;
iMouseLastPositionY = y;
}
this->RotateAroundYaxis(float(iMouseLastPositionX - x)/100.0f);
this->RotateAroundXaxis(float(iMouseLastPositionY - y)/100.0f);
Camera::Update();
iMouseLastPositionX = x;
iMouseLastPositionY = y;
bMouseClickDetected = false;
}
void Camera::DecreaseFovy(float fovy)
{
m_Fovy -= fovy;
Camera::mPerspectiveMatrix = glm::perspective(m_Fovy, m_Width / m_Height, m_zNear, m_zFar);
}
void Camera::IncreaseFovy(float fovy)
{
m_Fovy += fovy;
Camera::mPerspectiveMatrix = glm::perspective(m_Fovy, m_Width / m_Height, m_zNear, m_zFar);
}
void Camera::Update()
{
Camera::mWorldToCameraMatrix = glm::lookAt(Camera::vPosition, Camera::vCenter, Camera::vUp);
}
void Camera::setPosition(glm::vec3 vNewPosition)
{
vPosition = vNewPosition;
vLookDir = glm::normalize(Camera::vCenter - Camera::vPosition);
Camera::Update();
}
void Camera::setCenter(glm::vec3 vNewCenter)
{
vCenter = vNewCenter;
vLookDir = glm::normalize(Camera::vCenter - Camera::vPosition);
Camera::Update();
}
glm::mat4 Camera::getPerspectiveMatrix()
{
return Camera::mPerspectiveMatrix;
}
glm::vec3 Camera::getPosition()
{
return Camera::vPosition;
}
glm::vec3 Camera::getLookDir()
{
return Camera::vLookDir;
}
glm::mat4 Camera::getWorldToCameraMatrix()
{
return Camera::mWorldToCameraMatrix;
}
glm::vec3 Camera::getXVector()
{
return glm::normalize(glm::cross(Camera::vUp,Camera::vLookDir));
}
glm::vec3 Camera::getYVector()
{
return Camera::vUp;
}
glm::vec3 Camera::getZVector()
{
return Camera::vLookDir;
}
float Camera::getFov()
{
return m_Fovy;
}
float Camera::getWidth()
{
return m_Width;
}
float Camera::getHeight()
{
return m_Height;
}
float Camera::getZNear()
{
return m_zNear;
}
float Camera::getZFar()
{
return m_zFar;
}
void Camera::setDefaultProjectionMatrix()
{
Camera::mPerspectiveMatrix = glm::perspective(45.0f,1920.0f/1080.0f,0.1f,10000.0f);
}
void Camera::setOrthoProjection()
{
Camera::mPerspectiveMatrix = glm::mat4(1.0f);
}
| [
"[email protected]"
] | |
d2b642d3c5dd7a73a060de96b86305ae20ec9b4c | 20843dfdf8af3019953d0cdac245d4b7f6ed0ab4 | /my_algorithm.cpp | ad6103bffcbb11b2fa3bf7b4bca3ecd849631284 | [] | no_license | kakuhiroshi/c- | a62863c4ef2b22ffe7f60e0062199d9627637166 | 893ffccf1f35b8ac04b98333ddb60fd9fd086eb6 | refs/heads/master | 2021-01-10T09:38:35.831450 | 2015-10-19T12:42:11 | 2015-10-19T12:42:11 | 44,530,262 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,422 | cpp | #include"my_algorithm.h"
#include<algorithm>
#include<iostream>
#include<string>
using namespace std;
template<class T>
void __test(T test_val, T true_val, const char* file, unsigned int line, int status){
if(test_val != true_val)
cout<< "[error: "<<file<<"("<<line<<"):"<<status<<"]"<<endl;
}
template<class ElementIterator, class Element>
int b_search(ElementIterator first, ElementIterator last, Element value){
if(first == nullptr || last == nullptr || first >= last)
return -1;
ElementIterator low, mid, high;
low = first;
high = last;
while(low < high){
mid = low +(high - low) / 2;
if(*mid < value)
low = mid + 1;
else if(*mid == value)
return (mid - first);
else
high = mid;
}
return -1;
}
void _test_binary_search(){
int *arr = new int[10];
fill(arr, arr + 10, 10);
__test(b_search(arr, arr + 10, 10), 5, __FILE__, __LINE__, 10);
__test(b_search(arr, arr + 10, 5), -1, __FILE__, __LINE__, 5);
__test(b_search(arr, arr + 10, 15), -1, __FILE__, __LINE__, 15);
for(int i = 0; i < 10; i++){
arr[i] = 10 * i;
}
for(int i = 0; i < 10; i++){
__test(b_search(arr, arr + 10, 10 * i), i, __FILE__, __LINE__, i);
__test(b_search(arr, arr + 10, 10 * i - 5), -1, __FILE__, __LINE__, i - 5);
}
__test(b_search(arr, arr + 10, 10 * 10 - 5), -1, __FILE__, __LINE__, 10 * 10 - 5);
__test(b_search(arr, arr + 10, 10 * 10), -1, __FILE__, __LINE__, 10 * 10);
delete [] arr;
}
| [
"[email protected]"
] | |
a21a4b009948d154fac6df94e5b0e2d4e0a4eb68 | f16641091e05dc0c5cd6a63da1c64b1fb24276b4 | /SDI/TestCalc/main.cpp | accf07db872348fe6920efa1b7d7846cee74b1b1 | [] | no_license | benjamindoe/SDI | ef71b7a6b18413a6f982abccf6839703413aa0a5 | a1ae53c4ec537484a4056eebba2aae681c1a9c98 | refs/heads/master | 2021-05-01T12:45:43.994514 | 2016-04-21T11:18:01 | 2016-04-21T11:18:01 | 46,410,639 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 285 | cpp | #include <iostream>
#include "calculator.h"
using namespace std;
int main(int argc, char * argv[])
{
Calculator calc;
cout << calc.add(32, 45) << endl;
cout << calc.subtract(32, 45) << endl;
cout << calc.divide(32, 45) << endl;
cout << calc.multiply(32, 45) << endl;
} | [
"[email protected]"
] | |
4e6ca71f6b7eaacaf699f3248ffc42780225b454 | f178b0232a682ce0a657bad4f943db421cb12a07 | /src/qt/paymentserver.h | fc8dae964f5d0337ff6b568c54acf193282f22f8 | [
"MIT"
] | permissive | Dynamo13D/ubicoin | 8e401368c446ab5b340b60096bf2cfb9d2514ce2 | 42da9562958fc95f57d26532fc4544fbf85f297e | refs/heads/master | 2022-07-17T19:30:26.135649 | 2020-05-19T18:31:30 | 2020-05-19T18:31:30 | 265,322,310 | 0 | 0 | MIT | 2020-05-19T17:56:00 | 2020-05-19T17:55:59 | null | UTF-8 | C++ | false | false | 5,132 | h | // Copyright (c) 2011-2018 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef UBICOIN_QT_PAYMENTSERVER_H
#define UBICOIN_QT_PAYMENTSERVER_H
// This class handles payment requests from clicking on
// ubicoin: URIs
//
// This is somewhat tricky, because we have to deal with
// the situation where the user clicks on a link during
// startup/initialization, when the splash-screen is up
// but the main window (and the Send Coins tab) is not.
//
// So, the strategy is:
//
// Create the server, and register the event handler,
// when the application is created. Save any URIs
// received at or during startup in a list.
//
// When startup is finished and the main window is
// shown, a signal is sent to slot uiReady(), which
// emits a receivedURI() signal for any payment
// requests that happened during startup.
//
// After startup, receivedURI() happens as usual.
//
// This class has one more feature: a static
// method that finds URIs passed in the command line
// and, if a server is running in another process,
// sends them to the server.
//
#include <qt/paymentrequestplus.h>
#include <qt/walletmodel.h>
#include <QObject>
#include <QString>
class OptionsModel;
QT_BEGIN_NAMESPACE
class QApplication;
class QByteArray;
class QLocalServer;
class QNetworkAccessManager;
class QNetworkReply;
class QSslError;
class QUrl;
QT_END_NAMESPACE
// BIP70 max payment request size in bytes (DoS protection)
static const qint64 BIP70_MAX_PAYMENTREQUEST_SIZE = 50000;
class PaymentServer : public QObject
{
Q_OBJECT
public:
// Parse URIs on command line
// Returns false on error
static void ipcParseCommandLine(interfaces::Node& node, int argc, char *argv[]);
// Returns true if there were URIs on the command line
// which were successfully sent to an already-running
// process.
// Note: if a payment request is given, SelectParams(MAIN/TESTNET)
// will be called so we startup in the right mode.
static bool ipcSendCommandLine();
// parent should be QApplication object
explicit PaymentServer(QObject* parent, bool startLocalServer = true);
~PaymentServer();
// Load root certificate authorities. Pass nullptr (default)
// to read from the file specified in the -rootcertificates setting,
// or, if that's not set, to use the system default root certificates.
// If you pass in a store, you should not X509_STORE_free it: it will be
// freed either at exit or when another set of CAs are loaded.
static void LoadRootCAs(X509_STORE* store = nullptr);
// Return certificate store
static X509_STORE* getCertStore();
// OptionsModel is used for getting proxy settings and display unit
void setOptionsModel(OptionsModel *optionsModel);
// Verify that the payment request network matches the client network
static bool verifyNetwork(interfaces::Node& node, const payments::PaymentDetails& requestDetails);
// Verify if the payment request is expired
static bool verifyExpired(const payments::PaymentDetails& requestDetails);
// Verify the payment request size is valid as per BIP70
static bool verifySize(qint64 requestSize);
// Verify the payment request amount is valid
static bool verifyAmount(const CAmount& requestAmount);
Q_SIGNALS:
// Fired when a valid payment request is received
void receivedPaymentRequest(SendCoinsRecipient);
// Fired when a valid PaymentACK is received
void receivedPaymentACK(const QString &paymentACKMsg);
// Fired when a message should be reported to the user
void message(const QString &title, const QString &message, unsigned int style);
public Q_SLOTS:
// Signal this when the main window's UI is ready
// to display payment requests to the user
void uiReady();
// Submit Payment message to a merchant, get back PaymentACK:
void fetchPaymentACK(WalletModel* walletModel, const SendCoinsRecipient& recipient, QByteArray transaction);
// Handle an incoming URI, URI with local file scheme or file
void handleURIOrFile(const QString& s);
private Q_SLOTS:
void handleURIConnection();
void netRequestFinished(QNetworkReply*);
void reportSslErrors(QNetworkReply*, const QList<QSslError> &);
void handlePaymentACK(const QString& paymentACKMsg);
protected:
// Constructor registers this on the parent QApplication to
// receive QEvent::FileOpen and QEvent:Drop events
bool eventFilter(QObject *object, QEvent *event);
private:
static bool readPaymentRequestFromFile(const QString& filename, PaymentRequestPlus& request);
bool processPaymentRequest(const PaymentRequestPlus& request, SendCoinsRecipient& recipient);
void fetchRequest(const QUrl& url);
// Setup networking
void initNetManager();
bool saveURIs; // true during startup
QLocalServer* uriServer;
QNetworkAccessManager* netManager; // Used to fetch payment requests
OptionsModel *optionsModel;
};
#endif // UBICOIN_QT_PAYMENTSERVER_H
| [
"[email protected]"
] | |
6f00a4e5076ea85419521584cb6817b15d090f5e | 4343093e6cee29f00e811da82bc4b8ff603f2c73 | /XPFace/Include/XFDialog.h | adf3eab6578afdb58ec5b6a0c6cacc2b1936f6b6 | [] | no_license | wisfern/tradingstrategyking | 48bf287f24ee1ef0570ac1f30876f202c71110bb | af33e30a3754e49df82fb5f99897c98d2e8cc573 | refs/heads/master | 2020-04-06T04:59:34.281495 | 2015-05-20T07:41:00 | 2015-05-20T07:41:00 | 35,932,464 | 4 | 2 | null | null | null | null | GB18030 | C++ | false | false | 3,393 | h | #if !defined(AFX_XFDIALOG_H__9E89DE8F_4796_46DB_8262_75BFFEF26FC0__INCLUDED_)
#define AFX_XFDIALOG_H__9E89DE8F_4796_46DB_8262_75BFFEF26FC0__INCLUDED_
#if _MSC_VER > 1000
#pragma once
#endif // _MSC_VER > 1000
// XFDialog.h : header file
//
BOOL CLASS_EXPORT IsNumber( CString & string, BOOL bCanHasZeroLength );
/////////////////////////////////////////////////////////////////////////////
// CXFDialog dialog
class CLASS_EXPORT CXFDialog : public CDialog
{
// Construction
public:
CXFDialog( );
CXFDialog(LPCTSTR lpszTemplateName, CWnd* pParentWnd = NULL);
CXFDialog(UINT nIDTemplate, CWnd* pParentWnd = NULL); // standard constructor
void SetAutoDelete( BOOL bAutoDelete = FALSE );
void SetTransparent( BOOL bTransparent = TRUE, BYTE byteDeep = 244 );
// Dialog Data
//{{AFX_DATA(CXFDialog)
// NOTE: the ClassWizard will add data members here
//}}AFX_DATA
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CXFDialog)
protected:
virtual void DoDataExchange(CDataExchange* pDX); // DDX/DDV support
virtual void PostNcDestroy();
//}}AFX_VIRTUAL
// Implementation
protected:
// Generated message map functions
//{{AFX_MSG(CXFDialog)
afx_msg HBRUSH OnCtlColor(CDC* pDC, CWnd* pWnd, UINT nCtlColor);
virtual BOOL OnInitDialog();
virtual void OnOK();
virtual void OnCancel();
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
protected:
BOOL m_bAutoDelete;
BOOL m_bTransparent;
BYTE m_byteDeep;
};
/////////////////////////////////////////////////////////////////////////////
// CXFResDialog dialog
// 使用 XPFace DLL资源的 Dialog，需从CXFResDialog继承
class CLASS_EXPORT CXFResDialog : public CXFDialog
{
// Construction
public:
CXFResDialog( );
CXFResDialog(LPCTSTR lpszTemplateName, CWnd* pParentWnd = NULL);
CXFResDialog(UINT nIDTemplate, CWnd* pParentWnd = NULL); // standard constructor
// Overrides
// ClassWizard generated virtual function overrides
//{{AFX_VIRTUAL(CSelectEngineDlg)
public:
virtual int DoModal();
//}}AFX_VIRTUAL
};
/////////////////////////////////////////////////////////////////////////////
// CKSFileDialog 2000 Style
class CLASS_EXPORT CKSFileDialog : public CFileDialog
{
DECLARE_DYNAMIC(CKSFileDialog)
public:
void SetStringFilter(LPCSTR filter);
void SetDocumentPointer (CDocument* pDoc);
void SetAppPointer(CWinApp* pApp);
int DoModal();
CKSFileDialog(BOOL bOpenFileDialog, // TRUE for FileOpen, FALSE for FileSaveAs
LPCTSTR lpszDefExt = NULL,
LPCTSTR lpszFileName = NULL,
DWORD dwFlags = OFN_EXPLORER|OFN_ENABLESIZING| OFN_OVERWRITEPROMPT,
LPCTSTR lpszFilter = NULL,
CWnd* pParentWnd = NULL);
virtual BOOL DoPromptFileName(CString& fileName, UINT nIDSTitle, DWORD lFlags,
BOOL bOpenFileDialog, CDocTemplate* pTemplate);
virtual BOOL DoSave(LPCTSTR lpszPathName, BOOL bReplace);
protected:
void AppendFilterSuffix(CString& filter, OPENFILENAME& ofn,
CDocTemplate* pTemplate, CString* pstrDefaultExt);
//{{AFX_MSG(CKSFileDialog)
//}}AFX_MSG
DECLARE_MESSAGE_MAP()
CWinApp *m_pApp;
CDocument *m_pDoc;
CString m_StrFilter;
};
//{{AFX_INSERT_LOCATION}}
// Microsoft Visual C++ will insert additional declarations immediately before the previous line.
#endif // !defined(AFX_XFDIALOG_H__9E89DE8F_4796_46DB_8262_75BFFEF26FC0__INCLUDED_)
| [
"[email protected]@f36f75e2-b680-11de-9846-1b058f2a8eb1"
] | [email protected]@f36f75e2-b680-11de-9846-1b058f2a8eb1 |
54de5694783586e4cd4e0a97ac4766df636d2e13 | 3595753897389851bb83b6f05d6c04dd0017fadb | /enigma.ino | 715f4d941222f342ae265354efe9c2586bcab784 | [] | no_license | grantmiiller/engima | 494eb7abceb9391db5dbd59cb5ae27257ba4a813 | 77510ba4e40341f8e60052509eb92f95fef7d0e2 | refs/heads/master | 2021-01-24T03:19:52.317359 | 2018-02-25T23:06:03 | 2018-02-25T23:06:03 | 122,885,580 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,940 | ino | // Demo TFT Display and 4x4 Keypad for Black Pill STM32
#include "SPI.h"
#include <Adafruit_GFX_AS.h>
#include <Adafruit_ILI9341_STM.h>
#define NO_KEY 0
const byte ROWS = 4; //four rows
const byte COLS = 4; //four columns
const int TOTAL_KEYS = ROWS * COLS;
char chars[] = {'0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', '*', '#'};
char keys[ROWS][COLS] = {
{'1','2','3','A'},
{'4','5','6','B'},
{'7','8','9','C'},
{'*','0','#','D'}
};
byte rowPins[ROWS] = {PB12, PB13, PB14, PB15}; //connect to the row pinouts of the keypad
byte colPins[COLS] = {PA8, PB5, PB6, PB7}; //connect to the column pinouts of the keypad
#define TFT_CS PA1
#define TFT_DC PA3
#define TFT_RST PA2
// Just a pin with an LED to show true or false values
#define DEBUG_PIN PB11
// The pin to listen for enter state
#define ENTER_PIN PB8
// definitions of states
// State used to short circuit, mostly for debugging
#define STATE_NO_OP 0
// Getting if we are Decrypting or decrypting
#define STATE_GET_EN_DE 1
#define STATE_GET_KEY 2
#define STATE_GET_MESSAGE 3
#define STATE_PRINT_OUTPUT 4
// State if we are encrypting or decrypting
#define ENCRYPT_STATE 1
#define DECRYPT_STATE 2
// Boolean to show if user is trying to enter a value
int ENTER_FLAG = 0;
// How long until we allow a new enter. This is to prevent a button press and then immediate unpress due to a glitch
int ENTER_DELTA = 300;
// Last time enter state was flipped
int LAST_ENTER_TIME = 0;
int APP_STATE = STATE_GET_EN_DE;
int ENC_DEC_STATE = 0;
int WAITING_FOR_INPUT_STATE = 0;
const int KEY_MAX_SIZE = 10;
char ENCRYPTION_KEY[KEY_MAX_SIZE];
int KEY_INDEX = 0;
const int MESSAGE_MAX_SIZE = 100;
char MESSAGE[MESSAGE_MAX_SIZE];
int MESSAGE_INDEX = 0;
Adafruit_ILI9341_STM tft = Adafruit_ILI9341_STM(TFT_CS, TFT_DC, TFT_RST);
void setup() {
tft.begin();
tft.setRotation(3);
clear_screen();
tft.setTextColor(ILI9341_RED);
tft.setTextSize(2);
keypad_setup();
get_encrypt_decrypt_state();
pinMode(DEBUG_PIN, OUTPUT);
// Make sure enter pin is set to low
pinMode(ENTER_PIN, INPUT);
digitalWrite(ENTER_PIN, LOW);
}
void clear_screen() {
tft.fillScreen(ILI9341_BLACK);
tft.setCursor(0, 0);
}
void get_encrypt_decrypt_state() {
clear_screen();
tft.println("Choose Option:");
tft.println("1) Encrypt");
tft.println("2) Decrypt");
}
char get_key_press() {
char key = getKeyPad();
return key;
}
void print_key_press() {
char key = get_key_press();
if (key != NO_KEY) {
tft.print(key);
delay(500);
}
}
void read_enter_state() {
int current_time = millis();
if (current_time - LAST_ENTER_TIME > ENTER_DELTA) {
if(digitalRead(ENTER_PIN) == HIGH) {
ENTER_FLAG = 1;
} else {
ENTER_FLAG = 0;
}
LAST_ENTER_TIME = current_time;
}
}
void toggle_enter_state(int toggle) {
int current_time = millis();
ENTER_FLAG = toggle;
LAST_ENTER_TIME = current_time;
}
void get_de_en_state_logic() {
char key = get_key_press();
if (key == NO_KEY) { return; }
if (key != '1' && key != '2') {
clear_screen();
tft.println("Invalid Option.");
tft.print(key);
delay(1000);
get_encrypt_decrypt_state();
} else {
clear_screen();
if (key == '1') {
ENC_DEC_STATE = ENCRYPT_STATE;
tft.println("You choose Encrypt");
}
if (key == '2') {
ENC_DEC_STATE = DECRYPT_STATE;
tft.println("You choose Decrypt");
}
APP_STATE = STATE_GET_KEY;
WAITING_FOR_INPUT_STATE = 0;
delay(1000);
}
}
void get_key_logic() {
if(!WAITING_FOR_INPUT_STATE) {
clear_screen();
tft.println("Enter key:");
WAITING_FOR_INPUT_STATE = 1;
} else {
char key = get_key_press();
// Switch to next state
if (KEY_INDEX + 1 >= KEY_MAX_SIZE || (ENTER_FLAG && KEY_INDEX >= 1)) {
APP_STATE = STATE_GET_MESSAGE;
WAITING_FOR_INPUT_STATE = 0;
toggle_enter_state(0);
clear_screen();
tft.println("The key you entered is: \n");
for (int i = 0; i < KEY_INDEX; i++) {
tft.print(ENCRYPTION_KEY[i]);
}
delay(300);
return;
}
if (key == NO_KEY) { return; }
ENCRYPTION_KEY[KEY_INDEX] = key;
tft.print(key);
KEY_INDEX++;
delay(500);
}
}
void get_message_logic() {
if(!WAITING_FOR_INPUT_STATE) {
clear_screen();
tft.println("Enter message:");
WAITING_FOR_INPUT_STATE = 1;
} else {
char key = get_key_press();
// Switch to next state
if (MESSAGE_INDEX + 1 >= MESSAGE_MAX_SIZE || (ENTER_FLAG && MESSAGE_INDEX >= 1)) {
APP_STATE = STATE_PRINT_OUTPUT;
WAITING_FOR_INPUT_STATE = 0;
toggle_enter_state(0);
clear_screen();
tft.println("The message you entered is: \n");
for (int i = 0; i < MESSAGE_INDEX; i++) {
tft.print(MESSAGE[i]);
}
delay(300);
clear_screen();
return;
}
if (key == NO_KEY) { return; }
MESSAGE[MESSAGE_INDEX] = key;
tft.print(key);
MESSAGE_INDEX++;
delay(500);
}
}
char* generate_rotors(int seed) {
randomSeed(seed);
char newArray[TOTAL_KEYS] = {0};
for (int i= 0; i< TOTAL_KEYS; i++)
{
int pos = random(TOTAL_KEYS);
int t = chars[i];
newArray[i] = chars[pos];
newArray[pos] = t;
}
return newArray;
}
void print_message() {
char* rotor_1[TOTAL_KEYS] = {0};
rotor_1[TOTAL_KEYS] = generate_rotors(1);
for (int i= 0; i< TOTAL_KEYS; i++) {
tft.print(rotor_1[i]);
}
}
void loop(void) {
if (true) {
} else {
return;
}
read_enter_state();
if (ENTER_FLAG == 1) {
digitalWrite(DEBUG_PIN, HIGH);
} else {
digitalWrite(DEBUG_PIN, LOW);
}
// Logic for deciding if encrypting or decrypting
if (APP_STATE == STATE_GET_EN_DE) {
get_de_en_state_logic();
}
if (APP_STATE == STATE_GET_KEY) {
get_key_logic();
}
if (APP_STATE == STATE_GET_MESSAGE) {
get_message_logic();
}
if(APP_STATE == STATE_PRINT_OUTPUT) {
print_message();
}
}
void keypad_setup() {
for(int i=0; i<ROWS; i++) {
pinMode(rowPins[i], INPUT);
}
for (int i=0; i<COLS; i++) {
pinMode(colPins[i], INPUT);
}
}
char getKeyPad() {
char keyFound = NO_KEY;
// iterate the columns
for (int colIndex=0; colIndex < COLS; colIndex++) {
// col: set to output to low
byte curCol = colPins[colIndex];
pinMode(curCol, OUTPUT);
digitalWrite(curCol, LOW);
// row: interate through the rows
for (int rowIndex=0; rowIndex < ROWS; rowIndex++) {
byte rowCol = rowPins[rowIndex];
pinMode(rowCol, INPUT_PULLUP);
if ( ! digitalRead(rowCol) )
keyFound = keys[rowIndex][colIndex];
pinMode(rowCol, INPUT);
}
// disable the column
pinMode(curCol, INPUT);
}
return keyFound;
}
| [
"[email protected]"
] | |
3c45220aeb3d59489653362d464f0ca1ac84d219 | 04251e142abab46720229970dab4f7060456d361 | /lib/rosetta/source/src/protocols/topology_broker/SequenceNumberResolver.hh | ffed1e5c7f05d65eca9c6b82342be7803321a3c6 | [] | no_license | sailfish009/binding_affinity_calculator | 216257449a627d196709f9743ca58d8764043f12 | 7af9ce221519e373aa823dadc2005de7a377670d | refs/heads/master | 2022-12-29T11:15:45.164881 | 2020-10-22T09:35:32 | 2020-10-22T09:35:32 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,077 | hh | // -*- mode:c++;tab-width:2;indent-tabs-mode:t;show-trailing-whitespace:t;rm-trailing-spaces:t -*-
// vi: set ts=2 noet:
//
// (c) Copyright Rosetta Commons Member Institutions.
// (c) This file is part of the Rosetta software suite and is made available under license.
// (c) The Rosetta software is developed by the contributing members of the Rosetta Commons.
// (c) For more information, see http://www.rosettacommons.org. Questions about this can be
// (c) addressed to University of Washington CoMotion, email: [email protected].
/// @file
/// @brief
/// @author Oliver Lange
#ifndef INCLUDED_protocols_topology_broker_SequenceNumberResolver_hh
#define INCLUDED_protocols_topology_broker_SequenceNumberResolver_hh
// Unit Headers
#include <protocols/topology_broker/SequenceNumberResolver.fwd.hh>
// Package Headers
#include <utility/VirtualBase.hh>
#include <protocols/topology_broker/Exceptions.hh>
// Project Headers
#include <core/types.hh>
// C/C++ headers
#include <map>
#include <iterator>
#include <stdexcept>
namespace protocols {
namespace topology_broker {
class SequenceNumberResolver : public utility::VirtualBase {
public:
SequenceNumberResolver() {}
SequenceNumberResolver( const SequenceNumberResolver& );
/// @throws EXCN_BadInput if label or offset is already taken
void register_label_offset( std::string const& label, core::Size offset );
/// @brief Returns global position of element at position resid in sequence claim with the specified label.
core::Size find_global_pose_number( std::string const& label, core::Size resid) const;
core::Size find_global_pose_number( std::pair< std::string, core::Size> pos_pair ) const;
/// @brief Returns global position of first element of sequence claim with the specified label.
core::Size find_global_pose_number( std::string const& label) const;
/// @brief Returns label of sequence claim that corresponds to the global sequence position <pose_number>
std::string find_label( core::Size pose_number ) const;
/// @breif Returns position of global <pose_number> in corresponding sequence claim.
core::Size find_local_pose_number( core::Size pose_number ) const;
/// @brief Returns offset of a given label.
core::Size offset( std::string const& label ) const;
/// @brief returns the map element with the largest offset = SequenceClaim at the end of the sequence
std::pair <core::Size, std::string> terminal_pair() const;
private:
/// @brief map sequence labels to offsets
typedef std::map< std::string, core::Size > OffsetMap;
OffsetMap offset_map_;
/// @brief Inverse map, mapping offsets to labels
std::map< core::Size, std::string > offset_map_reversed_;
/// @brief Searches for entry in reversed map with highest offset that is smaller than the given pose_number.
/// This entry contains label and offset corresponding to the given pose_number.
std::map<core::Size, std::string>::const_iterator search_reversed_map( core::Size pose_number ) const;
}; //class SequenceNumberResolver
}
}
#endif // INCLUDED_protocols_topology_broker_SequenceNumberResolver_hh
| [
"[email protected]"
] | |
0d244b01cf1facbd503c7a12cb5f43b2117c74b3 | 6e8749dd03f21f047812f9666d1c8a47f54dadc3 | /Header/Administracion/Discos/Mkdisk.h | 2a099e04d84820f5a42a6d8d49b7432c25c6ef24 | [] | no_license | bram814/-MIA-Proyecto1_201800937 | 1218d6322fcda06c6e1260f3b5167cf8dcd9ff4f | b256dd86d5d61c11f8dc135ad47d840bff71dd59 | refs/heads/main | 2023-07-18T14:59:22.651452 | 2021-09-09T03:26:14 | 2021-09-09T03:26:14 | 392,883,136 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 222 | h | //
// Created by abraham on 8/08/21.
//
#ifndef PROYECTO_MKDISK_H
#define PROYECTO_MKDISK_H
#include "../../Controlador.h"
class Mkdisk{
public:
static void create_mkdisk(Nodo *root);
};
#endif //PROYECTO_MKDISK_H | [
"[email protected]"
] | |
255e4cbe23dba44ff58d4c5d2a49cb93120adcf1 | afffce06c7457b27118e5d4cf60d632d60644793 | /utils/input/devKeyboard.h | c235d7b3be5a6ca6bbca4639368dfeee001f850f | [
"MIT"
] | permissive | udacity/RoboND-DeepRL-Project | 134e4aadeb17e265014d05a21adec872e4022d4b | fc3809f97edc57f1dc437800ecfb1cf0a67c12da | refs/heads/master | 2021-12-22T06:17:42.515494 | 2021-12-02T12:59:19 | 2021-12-02T12:59:19 | 130,131,049 | 57 | 95 | NOASSERTION | 2019-03-21T23:32:22 | 2018-04-18T22:58:30 | C++ | UTF-8 | C++ | false | false | 1,971 | h | /*
* Copyright (c) 2017, NVIDIA CORPORATION. All rights reserved.
*
* Permission is hereby granted, free of charge, to any person obtaining a
* copy of this software and associated documentation files (the "Software"),
* to deal in the Software without restriction, including without limitation
* the rights to use, copy, modify, merge, publish, distribute, sublicense,
* and/or sell copies of the Software, and to permit persons to whom the
* Software is furnished to do so, subject to the following conditions:
*
* The above copyright notice and this permission notice shall be included in
* all copies or substantial portions of the Software.
*
* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
* IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
* FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
* THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
* LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
* FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
* DEALINGS IN THE SOFTWARE.
*/
#ifndef __DEV_KEYBOARD_H__
#define __DEV_KEYBOARD_H__
#include <stdio.h>
#include <stdint.h>
#include <string.h>
#include <string>
#include <linux/input-event-codes.h>
/**
* Keyboard device
*/
class KeyboardDevice
{
public:
/**
* Create device
*/
static KeyboardDevice* Create( const char* path="/dev/input/by-path/platform-i8042-serio-0-event-kbd" );
/**
* Destructor
*/
~KeyboardDevice();
/**
* Poll the device for updates
*/
bool Poll( uint32_t timeout=0 );
/**
* Check if a particular key is pressed
*/
bool KeyDown( uint32_t code ) const;
/**
* Enable/disable verbose logging
*/
void Debug( bool enabled=true );
protected:
// constructor
KeyboardDevice();
static const int MAX_KEYS = 256;
int mKeyMap[MAX_KEYS];
int mFD;
bool mDebug;
std::string mPath;
};
#endif
| [
"[email protected]"
] | |
b1f910ca9bf320b2313e3d02106192af5075171a | 08b8cf38e1936e8cec27f84af0d3727321cec9c4 | /data/crawl/tar/new_hunk_35.cpp | 56271432edd1156abca63db07d639efa5841261e | [] | no_license | ccdxc/logSurvey | eaf28e9c2d6307140b17986d5c05106d1fd8e943 | 6b80226e1667c1e0760ab39160893ee19b0e9fb1 | refs/heads/master | 2022-01-07T21:31:55.446839 | 2018-04-21T14:12:43 | 2018-04-21T14:12:43 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,383 | cpp | obstack_free (&stk, NULL);
}
void
xattrs_acls_get (int parentfd, char const *file_name,
struct tar_stat_info *st, int fd, int xisfile)
{
if (acls_option > 0)
{
#ifndef HAVE_POSIX_ACLS
static int done = 0;
if (!done)
WARN ((0, 0, _("POSIX ACL support is not available")));
done = 1;
#else
int err = file_has_acl_at (parentfd, file_name, &st->stat);
if (err == 0)
return;
if (err == -1)
{
call_arg_warn ("file_has_acl_at", file_name);
return;
}
xattrs__acls_get_a (parentfd, file_name, st,
&st->acls_a_ptr, &st->acls_a_len);
if (!xisfile)
xattrs__acls_get_d (parentfd, file_name, st,
&st->acls_d_ptr, &st->acls_d_len);
#endif
}
}
void
xattrs_acls_set (struct tar_stat_info const *st,
char const *file_name, char typeflag)
{
if ((acls_option > 0) && (typeflag != SYMTYPE))
{
#ifndef HAVE_POSIX_ACLS
static int done = 0;
if (!done)
WARN ((0, 0, _("POSIX ACL support is not available")));
done = 1;
#else
xattrs__acls_set (st, file_name, ACL_TYPE_ACCESS,
st->acls_a_ptr, st->acls_a_len, false);
if ((typeflag == DIRTYPE) || (typeflag == GNUTYPE_DUMPDIR))
xattrs__acls_set (st, file_name, ACL_TYPE_DEFAULT,
st->acls_d_ptr, st->acls_d_len, true);
#endif
}
}
static void
mask_map_realloc (struct xattrs_mask_map *map)
{
if (map->size == 0)
{
| [
"[email protected]"
] | |
c90c563aaed1f55f763426177f6419c100eedb1b | e018d8a71360d3a05cba3742b0f21ada405de898 | /Client/Packet/Cpackets/CGDepositPet.h | eb02bb83b15ff4f2a653c20dbf50415c711a3145 | [] | no_license | opendarkeden/client | 33f2c7e74628a793087a08307e50161ade6f4a51 | 321b680fad81d52baf65ea7eb3beeb91176c15f4 | refs/heads/master | 2022-11-28T08:41:15.782324 | 2022-11-26T13:21:22 | 2022-11-26T13:21:22 | 42,562,963 | 24 | 18 | null | 2022-11-26T13:21:23 | 2015-09-16T03:43:01 | C++ | WINDOWS-1252 | C++ | false | false | 2,580 | h | ////////////////////////////////////////////////////////////////////////////////
//
// Filename : CGDepositPet.h
// Written By : ±è¼º¹Î
// Description :
//
////////////////////////////////////////////////////////////////////////////////
#ifndef __CG_DEPOSIT_PET_H__
#define __CG_DEPOSIT_PET_H__
// include files
#include "Packet.h"
#include "PacketFactory.h"
////////////////////////////////////////////////////////////////////////////////
//
// class CGDepositPet;
//
////////////////////////////////////////////////////////////////////////////////
class CGDepositPet : public Packet
{
public:
void read(SocketInputStream & iStream) throw(ProtocolException, Error);
void write(SocketOutputStream & oStream) const throw(ProtocolException, Error);
void execute(Player* pPlayer) throw(ProtocolException, Error);
PacketID_t getPacketID() const throw() { return PACKET_CG_DEPOSIT_PET; }
PacketSize_t getPacketSize() const throw() { return szObjectID + szBYTE; }
string getPacketName() const throw() { return "CGDepositPet"; }
string toString() const throw();
public:
ObjectID_t getObjectID() const { return m_ObjectID; }
void setObjectID( ObjectID_t objectID ) { m_ObjectID = objectID; }
BYTE getIndex(void) const { return m_Index;}
void setIndex(BYTE index) { m_Index = index;}
private:
ObjectID_t m_ObjectID;
BYTE m_Index;
};
////////////////////////////////////////////////////////////////////////////////
//
// class CGDepositPetFactory;
//
////////////////////////////////////////////////////////////////////////////////
class CGDepositPetFactory : public PacketFactory
{
public:
Packet* createPacket() throw() { return new CGDepositPet(); }
string getPacketName() const throw() { return "CGDepositPet"; }
PacketID_t getPacketID() const throw() { return Packet::PACKET_CG_DEPOSIT_PET; }
PacketSize_t getPacketMaxSize() const throw() { return szObjectID + szBYTE; }
};
////////////////////////////////////////////////////////////////////////////////
//
// class CGDepositPetHandler;
//
////////////////////////////////////////////////////////////////////////////////
class CGDepositPetHandler {
public:
// execute packet's handler
static void execute(CGDepositPet* pPacket, Player* player) throw(ProtocolException, Error);
//static void executeSlayer(CGDepositPet* pPacket, Player* player) throw(ProtocolException, Error);
//static void executeVampire(CGDepositPet* pPacket, Player* player) throw(ProtocolException, Error);
};
#endif
| [
"[email protected]"
] | |
7b22b3fc38fd24b690b561e0c7a30d704b9cda4c | 023d66af8374aee6c32ca7e36bf2905442c5b060 | /snark-logic/libs-source/algebra/include/nil/crypto3/algebra/curves/detail/edwards/babyjubjub/element_g1.hpp | f5003437ef6688c9bcb5b269d87fa04f10a075b6 | [
"MIT"
] | permissive | podlodkin/podlodkin-freeton-year-control | 4493e412edcac47cd5b55ec9f552d997e40a35ef | e394c11f2414804d2fbde93a092ae589d4359739 | refs/heads/main | 2023-08-14T21:48:34.735864 | 2021-09-15T20:32:42 | 2021-09-15T20:32:42 | 401,226,621 | 0 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 14,481 | hpp | //---------------------------------------------------------------------------//
// Copyright (c) 2020-2021 Mikhail Komarov <[email protected]>
// Copyright (c) 2020-2021 Nikita Kaskov <[email protected]>
// Copyright (c) 2020-2021 Ilias Khairullin <[email protected]>
//
// MIT License
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in all
// copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
// SOFTWARE.
//---------------------------------------------------------------------------//
#ifndef CRYPTO3_ALGEBRA_CURVES_TWISTED_EDWARDS_G1_ELEMENT_HPP
#define CRYPTO3_ALGEBRA_CURVES_TWISTED_EDWARDS_G1_ELEMENT_HPP
#include <nil/crypto3/algebra/curves/detail/edwards/jubjub/basic_policy.hpp>
#include <nil/crypto3/algebra/curves/detail/edwards/babyjubjub/basic_policy.hpp>
#include <nil/crypto3/algebra/curves/detail/scalar_mul.hpp>
#include <nil/crypto3/detail/literals.hpp>
namespace nil {
namespace crypto3 {
namespace algebra {
namespace curves {
namespace detail {
/** @brief A struct representing a group G1 of Edwards curve.
* @tparam Version version of the curve
*
*/
template<std::size_t Version>
struct edwards_g1;
/** @brief A struct representing an element from the group G1 of edwards curve.
*
*/
template<std::size_t Version>
struct element_twisted_edwards_g1 {
constexpr static const std::size_t version = Version;
using group_type = edwards_g1<version>;
using policy_type = edwards_basic_policy<version>;
using underlying_field_type = typename policy_type::g1_field_type;
using g1_field_type_value = typename policy_type::g1_field_type::value_type;
// must be removed later
typedef typename underlying_field_type::value_type underlying_field_value_type;
underlying_field_value_type X;
underlying_field_value_type Y;
underlying_field_value_type Z;
/************************* Constructors and zero/one ***********************************/
/** @brief
* @return the point at infinity by default
*
*/
constexpr element_twisted_edwards_g1() : element_twisted_edwards_g1(policy_type::g1_zero_fill[0],
policy_type::g1_zero_fill[1], policy_type::g1_zero_fill[2]) {};
/** @brief
* @return the selected point $(X:Y:Z)$ in the projective coordinates
*
*/
constexpr element_twisted_edwards_g1(underlying_field_value_type in_X, underlying_field_value_type in_Y,
underlying_field_value_type in_Z = underlying_field_value_type::one()) {
this->X = in_X;
this->Y = in_Y;
this->Z = in_Z;
};
/** @brief Get the point at infinity
*
*/
static element_twisted_edwards_g1 zero() {
return element_twisted_edwards_g1();
}
/** @brief Get the generator of group G1
*
*/
static element_twisted_edwards_g1 one() {
return element_twisted_edwards_g1(policy_type::g1_one_fill[0], policy_type::g1_one_fill[1],
policy_type::g1_one_fill[2]);
}
/************************* Comparison operations ***********************************/
bool operator==(const element_twisted_edwards_g1 &other) const {
if (this->is_zero()) {
return other.is_zero();
}
if (other.is_zero()) {
return false;
}
/* now neither is O */
// X1/Z1 = X2/Z2 <=> X1*Z2 = X2*Z1
if ((this->X * other.Z) != (other.X * this->Z)) {
return false;
}
// Y1/Z1 = Y2/Z2 <=> Y1*Z2 = Y2*Z1
if ((this->Y * other.Z) != (other.Y * this->Z)) {
return false;
}
return true;
}
bool operator!=(const element_twisted_edwards_g1 &other) const {
return !(operator==(other));
}
/** @brief
*
* @return true if element from group G1 is the point at infinity
*/
bool is_zero() const {
return (this->X.is_zero() && this->Y.is_one() && this->Z.is_zero());
}
/** @brief
*
* @return true if element from group G1 in affine coordinates
*/
bool is_special() const {
return (this->is_zero() || this->Z == underlying_field_value_type::one());
}
/** @brief
*
* @return true if element from group G1 lies on the elliptic curve
*
* A check, that a*X*X + Y*Y = 1 + d*X*X*Y*Y
*/
constexpr bool is_well_formed() const {
if (this->is_zero()) {
return true;
} else {
underlying_field_value_type XX = this->X.squared();
underlying_field_value_type YY = this->Y.squared();
return (underlying_field_value_type(policy_type::a)*XX + YY ==
underlying_field_value_type::one() +
underlying_field_value_type(policy_type::d)*XX*YY);
}
}
/************************* Arithmetic operations ***********************************/
element_twisted_edwards_g1 operator=(const element_twisted_edwards_g1 &other) {
// handle special cases having to do with O
this->X = other.X;
this->Y = other.Y;
this->Z = other.Z;
return *this;
}
element_twisted_edwards_g1 operator+(const element_twisted_edwards_g1 &other) const {
// handle special cases having to do with O
if (this->is_zero()) {
return other;
}
if (other.is_zero()) {
return (*this);
}
if (*this == other) {
return this->doubled();
}
return this->add(other);
}
element_twisted_edwards_g1 operator-() const {
return element_twisted_edwards_g1(-(this->X), this->Y, this->Z);
}
element_twisted_edwards_g1 operator-(const element_twisted_edwards_g1 &B) const {
return (*this) + (-B);
}
/** @brief
*
* @return doubled element from group G1
*/
element_twisted_edwards_g1 doubled() const {
if (this->is_zero()) {
return (*this);
} else {
return this->add(*this); // Temporary intil we find something more efficient
}
}
private:
element_twisted_edwards_g1 add(const element_twisted_edwards_g1 &other) const {
underlying_field_value_type XX = (this->X)*(other.X);
underlying_field_value_type YY = (this->Y)*(other.Y);
underlying_field_value_type XY = (this->X)*(other.Y);
underlying_field_value_type YX = (this->Y)*(other.X);
underlying_field_value_type lambda = d * XX * YY;
underlying_field_value_type X3 = (XY + YX) *
(underlying_field_value_type::one() + lambda).inversed();
underlying_field_value_type Y3 = (YY - a * XX) *
(underlying_field_value_type::one() - lambda).inversed();
return element_twisted_edwards_g1(X3, Y3);
}
public:
/************************* Reducing operations ***********************************/
/** @brief
*
* @return return the corresponding element from inverted coordinates to affine coordinates
*/
element_twisted_edwards_g1 to_affine() const {
underlying_field_value_type p_out[3];
if (this->is_zero()) {
p_out[0] = underlying_field_value_type::zero();
p_out[1] = underlying_field_value_type::one();
p_out[2] = underlying_field_value_type::one();
} else {
// go from inverted coordinates to projective coordinates
underlying_field_value_type tX = this->Y * this->Z;
underlying_field_value_type tY = this->X * this->Z;
underlying_field_value_type tZ = this->X * this->Y;
// go from projective coordinates to affine coordinates
underlying_field_value_type tZ_inv = tZ.inversed();
p_out[0] = tX * tZ_inv;
p_out[1] = tY * tZ_inv;
p_out[2] = underlying_field_value_type::one();
}
return element_twisted_edwards_g1(p_out[0], p_out[1], p_out[2]);
}
/** @brief
*
* @return return the corresponding element from projective coordinates to affine coordinates
*/
element_twisted_edwards_g1 to_projective() const {
underlying_field_value_type p_out[3];
if (this->Z.is_zero()) {
return *this;
}
underlying_field_value_type Z_inv = this->Z.inversed();
p_out[0] = this->X * Z_inv;
p_out[1] = this->Y * Z_inv;
p_out[2] = underlying_field_value_type::one();
return element_twisted_edwards_g1(p_out[0], p_out[1], p_out[2]);
}
private:
constexpr static const g1_field_type_value a = policy_type::a;
constexpr static const g1_field_type_value d = policy_type::d;
};
template <std::size_t Version>
constexpr typename element_twisted_edwards_g1<Version>::g1_field_type_value const
element_twisted_edwards_g1<Version>::a;
template <std::size_t Version>
constexpr typename element_twisted_edwards_g1<Version>::g1_field_type_value const
element_twisted_edwards_g1<Version>::d;
} // namespace detail
} // namespace curves
} // namespace algebra
} // namespace crypto3
} // namespace nil
#endif // CRYPTO3_ALGEBRA_CURVES_TWISTED_EDWARDS_G1_ELEMENT_HPP
| [
"[email protected]"
] | |
277f1b17b6939094944f76c18339d1c40474c99c | 01fe3ab824ec01590d2a02009e5f0339149b53ec | /OpenGL/package/Palette.hpp | 9d1fefb7592b2b4dd47e5413ad67360ad6b9f61a | [] | no_license | ao1415/OpenGL | 5e4da21f4e4c1490c2f251ac6916a372f0522835 | 57b84750ef85b553d85a8ee1fe353467fb8c53b8 | refs/heads/master | 2020-09-16T01:43:51.279665 | 2017-02-10T05:26:28 | 2017-02-10T05:26:28 | 67,856,861 | 0 | 0 | null | null | null | null | SHIFT_JIS | C++ | false | false | 11,743 | hpp | #pragma once
#include "Color.hpp"
namespace opc {
/// <summary>
/// 定義された色
/// </summary>
namespace Palette {
/// <summary>
/// 0x000000
/// </summary>
const Color Black(0x000000);
/// <summary>
/// 0x000080
/// </summary>
const Color Navy(0x000080);
/// <summary>
/// 0x00008B
/// </summary>
const Color Darkblue(0x00008B);
/// <summary>
/// 0x0000CD
/// </summary>
const Color Mediumblue(0x0000CD);
/// <summary>
/// 0x0000FF
/// </summary>
const Color Blue(0x0000FF);
/// <summary>
/// 0x006400
/// </summary>
const Color Darkgreen(0x006400);
/// <summary>
/// 0x008000
/// </summary>
const Color Green(0x008000);
/// <summary>
/// 0x008080
/// </summary>
const Color Teal(0x008080);
/// <summary>
/// 0x008B8B
/// </summary>
const Color Darkcyan(0x008B8B);
/// <summary>
/// 0x00BFFF
/// </summary>
const Color Deepskyblue(0x00BFFF);
/// <summary>
/// 0x00CED1
/// </summary>
const Color Darkturquoise(0x00CED1);
/// <summary>
/// 0x00FA9A
/// </summary>
const Color Mediumspringgreen(0x00FA9A);
/// <summary>
/// 0x00FF00
/// </summary>
const Color Lime(0x00FF00);
/// <summary>
/// 0x00FF7F
/// </summary>
const Color Springgreen(0x00FF7F);
/// <summary>
/// 0x00FFFF
/// </summary>
const Color Cyan(0x00FFFF);
/// <summary>
/// 0x00FFFF
/// </summary>
const Color Aqua(0x00FFFF);
/// <summary>
/// 0x191970
/// </summary>
const Color Midnightblue(0x191970);
/// <summary>
/// 0x1E90FF
/// </summary>
const Color Dodgerblue(0x1E90FF);
/// <summary>
/// 0x20B2AA
/// </summary>
const Color Lightseagreen(0x20B2AA);
/// <summary>
/// 0x228B22
/// </summary>
const Color Forestgreen(0x228B22);
/// <summary>
/// 0x2E8B57
/// </summary>
const Color Seagreen(0x2E8B57);
/// <summary>
/// 0x2F4F4F
/// </summary>
const Color Darkslategray(0x2F4F4F);
/// <summary>
/// 0x32CD32
/// </summary>
const Color Limegreen(0x32CD32);
/// <summary>
/// 0x3CB371
/// </summary>
const Color Mediumseagreen(0x3CB371);
/// <summary>
/// 0x40E0D0
/// </summary>
const Color Turquoise(0x40E0D0);
/// <summary>
/// 0x4169E1
/// </summary>
const Color Royalblue(0x4169E1);
/// <summary>
/// 0x4682B4
/// </summary>
const Color Steelblue(0x4682B4);
/// <summary>
/// 0x483D8B
/// </summary>
const Color Darkslateblue(0x483D8B);
/// <summary>
/// 0x48D1CC
/// </summary>
const Color Mediumturquoise(0x48D1CC);
/// <summary>
/// 0x4B0082
/// </summary>
const Color Indigo(0x4B0082);
/// <summary>
/// 0x556B2F
/// </summary>
const Color Darkolivegreen(0x556B2F);
/// <summary>
/// 0x5F9EA0
/// </summary>
const Color Cadetblue(0x5F9EA0);
/// <summary>
/// 0x6495ED
/// </summary>
const Color Cornflowerblue(0x6495ED);
/// <summary>
/// 0x66CDAA
/// </summary>
const Color Mediumaquamarine(0x66CDAA);
/// <summary>
/// 0x696969
/// </summary>
const Color Dimgray(0x696969);
/// <summary>
/// 0x6A5ACD
/// </summary>
const Color Slateblue(0x6A5ACD);
/// <summary>
/// 0x6B8E23
/// </summary>
const Color Olivedrab(0x6B8E23);
/// <summary>
/// 0x708090
/// </summary>
const Color Slategray(0x708090);
/// <summary>
/// 0x778899
/// </summary>
const Color Lightslategray(0x778899);
/// <summary>
/// 0x7B68EE
/// </summary>
const Color Mediumslateblue(0x7B68EE);
/// <summary>
/// 0x7CFC00
/// </summary>
const Color Lawngreen(0x7CFC00);
/// <summary>
/// 0x7FFF00
/// </summary>
const Color Chartreuse(0x7FFF00);
/// <summary>
/// 0x7FFFD4
/// </summary>
const Color Aquamarine(0x7FFFD4);
/// <summary>
/// 0x800000
/// </summary>
const Color Maroon(0x800000);
/// <summary>
/// 0x800080
/// </summary>
const Color Purple(0x800080);
/// <summary>
/// 0x808000
/// </summary>
const Color Olive(0x808000);
/// <summary>
/// 0x808080
/// </summary>
const Color Gray(0x808080);
/// <summary>
/// 0x87CEEB
/// </summary>
const Color Skyblue(0x87CEEB);
/// <summary>
/// 0x87CEFA
/// </summary>
const Color Lightskyblue(0x87CEFA);
/// <summary>
/// 0x8A2BE2
/// </summary>
const Color Blueviolet(0x8A2BE2);
/// <summary>
/// 0x8B0000
/// </summary>
const Color Darkred(0x8B0000);
/// <summary>
/// 0x8B008B
/// </summary>
const Color Darkmagenta(0x8B008B);
/// <summary>
/// 0x8B4513
/// </summary>
const Color Saddlebrown(0x8B4513);
/// <summary>
/// 0x8FBC8F
/// </summary>
const Color Darkseagreen(0x8FBC8F);
/// <summary>
/// 0x90EE90
/// </summary>
const Color Lightgreen(0x90EE90);
/// <summary>
/// 0x9370DB
/// </summary>
const Color Mediumpurple(0x9370DB);
/// <summary>
/// 0x9400D3
/// </summary>
const Color Darkviolet(0x9400D3);
/// <summary>
/// 0x98FB98
/// </summary>
const Color Palegreen(0x98FB98);
/// <summary>
/// 0x9932CC
/// </summary>
const Color Darkorchid(0x9932CC);
/// <summary>
/// 0x9ACD32
/// </summary>
const Color Yellowgreen(0x9ACD32);
/// <summary>
/// 0xA0522D
/// </summary>
const Color Sienna(0xA0522D);
/// <summary>
/// 0xA52A2A
/// </summary>
const Color Brown(0xA52A2A);
/// <summary>
/// 0xA9A9A9
/// </summary>
const Color Darkgray(0xA9A9A9);
/// <summary>
/// 0xADD8E6
/// </summary>
const Color Lightblue(0xADD8E6);
/// <summary>
/// 0xADFF2F
/// </summary>
const Color Greenyellow(0xADFF2F);
/// <summary>
/// 0xAFEEEE
/// </summary>
const Color Paleturquoise(0xAFEEEE);
/// <summary>
/// 0xB0C4DE
/// </summary>
const Color Lightsteelblue(0xB0C4DE);
/// <summary>
/// 0xB0E0E6
/// </summary>
const Color Powderblue(0xB0E0E6);
/// <summary>
/// 0xB22222
/// </summary>
const Color Firebrick(0xB22222);
/// <summary>
/// 0xB8860B
/// </summary>
const Color Darkgoldenrod(0xB8860B);
/// <summary>
/// 0xBA55D3
/// </summary>
const Color Mediumorchid(0xBA55D3);
/// <summary>
/// 0xBC8F8F
/// </summary>
const Color Rosybrown(0xBC8F8F);
/// <summary>
/// 0xBDB76B
/// </summary>
const Color Darkkhaki(0xBDB76B);
/// <summary>
/// 0xC0C0C0
/// </summary>
const Color Silver(0xC0C0C0);
/// <summary>
/// 0xC71585
/// </summary>
const Color Mediumvioletred(0xC71585);
/// <summary>
/// 0xCD5C5C
/// </summary>
const Color Indianred(0xCD5C5C);
/// <summary>
/// 0xCD853F
/// </summary>
const Color Peru(0xCD853F);
/// <summary>
/// 0xD2691E
/// </summary>
const Color Chocolate(0xD2691E);
/// <summary>
/// 0xD2B48C
/// </summary>
const Color Tan(0xD2B48C);
/// <summary>
/// 0xD3D3D3
/// </summary>
const Color Lightgray(0xD3D3D3);
/// <summary>
/// 0xD8BFD8
/// </summary>
const Color Thistle(0xD8BFD8);
/// <summary>
/// 0xDA70D6
/// </summary>
const Color Orchid(0xDA70D6);
/// <summary>
/// 0xDAA520
/// </summary>
const Color Goldenrod(0xDAA520);
/// <summary>
/// 0xDB7093
/// </summary>
const Color Palevioletred(0xDB7093);
/// <summary>
/// 0xDC143C
/// </summary>
const Color Crimson(0xDC143C);
/// <summary>
/// 0xDCDCDC
/// </summary>
const Color Gainsboro(0xDCDCDC);
/// <summary>
/// 0xDDA0DD
/// </summary>
const Color Plum(0xDDA0DD);
/// <summary>
/// 0xDEB887
/// </summary>
const Color Burlywood(0xDEB887);
/// <summary>
/// 0xE0FFFF
/// </summary>
const Color Lightcyan(0xE0FFFF);
/// <summary>
/// 0xE6E6FA
/// </summary>
const Color Lavendar(0xE6E6FA);
/// <summary>
/// 0xE9967A
/// </summary>
const Color Darksalmon(0xE9967A);
/// <summary>
/// 0xEE82EE
/// </summary>
const Color Violet(0xEE82EE);
/// <summary>
/// 0xEEE8AA
/// </summary>
const Color Palegoldenrod(0xEEE8AA);
/// <summary>
/// 0xF08080
/// </summary>
const Color Lightcoral(0xF08080);
/// <summary>
/// 0xF0E68C
/// </summary>
const Color Khaki(0xF0E68C);
/// <summary>
/// 0xF0F8FF
/// </summary>
const Color Aliceblue(0xF0F8FF);
/// <summary>
/// 0xF0FFF0
/// </summary>
const Color Honeydew(0xF0FFF0);
/// <summary>
/// 0xF0FFFF
/// </summary>
const Color Azure(0xF0FFFF);
/// <summary>
/// 0xF4A460
/// </summary>
const Color Sandybrown(0xF4A460);
/// <summary>
/// 0xF5DEB3
/// </summary>
const Color Wheat(0xF5DEB3);
/// <summary>
/// 0xF5F5DC
/// </summary>
const Color Beige(0xF5F5DC);
/// <summary>
/// 0xF5F5F5
/// </summary>
const Color Whitesmoke(0xF5F5F5);
/// <summary>
/// 0xF5FFFA
/// </summary>
const Color Mintcream(0xF5FFFA);
/// <summary>
/// 0xF8F8FF
/// </summary>
const Color Ghostwhite(0xF8F8FF);
/// <summary>
/// 0xFA8072
/// </summary>
const Color Salmon(0xFA8072);
/// <summary>
/// 0xFAEBD7
/// </summary>
const Color Antiquewhite(0xFAEBD7);
/// <summary>
/// 0xFAF0E6
/// </summary>
const Color Linen(0xFAF0E6);
/// <summary>
/// 0xFAFAD2
/// </summary>
const Color Lightgoldenrodyellow(0xFAFAD2);
/// <summary>
/// 0xFDF5E6
/// </summary>
const Color Oldlace(0xFDF5E6);
/// <summary>
/// 0xFF0000
/// </summary>
const Color Red(0xFF0000);
/// <summary>
/// 0xFF00FF
/// </summary>
const Color Magenta(0xFF00FF);
/// <summary>
/// 0xFF00FF
/// </summary>
const Color Fuchsia(0xFF00FF);
/// <summary>
/// 0xFF1493
/// </summary>
const Color Deeppink(0xFF1493);
/// <summary>
/// 0xFF4500
/// </summary>
const Color Orangered(0xFF4500);
/// <summary>
/// 0xFF6347
/// </summary>
const Color Tomato(0xFF6347);
/// <summary>
/// 0xFF69B4
/// </summary>
const Color Hotpink(0xFF69B4);
/// <summary>
/// 0xFF7F50
/// </summary>
const Color Coral(0xFF7F50);
/// <summary>
/// 0xFF8C00
/// </summary>
const Color Darkorange(0xFF8C00);
/// <summary>
/// 0xFFA07A
/// </summary>
const Color Lightsalmon(0xFFA07A);
/// <summary>
/// 0xFFA500
/// </summary>
const Color Orange(0xFFA500);
/// <summary>
/// 0xFFB6C1
/// </summary>
const Color Lightpink(0xFFB6C1);
/// <summary>
/// 0xFFC0CB
/// </summary>
const Color Pink(0xFFC0CB);
/// <summary>
/// 0xFFD700
/// </summary>
const Color Gold(0xFFD700);
/// <summary>
/// 0xFFDAB9
/// </summary>
const Color Peachpuff(0xFFDAB9);
/// <summary>
/// 0xFFDEAD
/// </summary>
const Color Navajowhite(0xFFDEAD);
/// <summary>
/// 0xFFE4B5
/// </summary>
const Color Moccasin(0xFFE4B5);
/// <summary>
/// 0xFFE4C4
/// </summary>
const Color Bisque(0xFFE4C4);
/// <summary>
/// 0xFFE4E1
/// </summary>
const Color Mistyrose(0xFFE4E1);
/// <summary>
/// 0xFFEBCD
/// </summary>
const Color Blanchedalmond(0xFFEBCD);
/// <summary>
/// 0xFFEFD5
/// </summary>
const Color Papayawhite(0xFFEFD5);
/// <summary>
/// 0xFFF0F5
/// </summary>
const Color Lavenderblush(0xFFF0F5);
/// <summary>
/// 0xFFF5EE
/// </summary>
const Color Seashell(0xFFF5EE);
/// <summary>
/// 0xFFF8DC
/// </summary>
const Color Cornsilk(0xFFF8DC);
/// <summary>
/// 0xFFFACD
/// </summary>
const Color Lemonchiffon(0xFFFACD);
/// <summary>
/// 0xFFFAF0
/// </summary>
const Color Floralwhite(0xFFFAF0);
/// <summary>
/// 0xFFFAFA
/// </summary>
const Color Snow(0xFFFAFA);
/// <summary>
/// 0xFFFF00
/// </summary>
const Color Yellow(0xFFFF00);
/// <summary>
/// 0xFFFFE0
/// </summary>
const Color Lightyellow(0xFFFFE0);
/// <summary>
/// 0xFFFFF0
/// </summary>
const Color Ivory(0xFFFFF0);
/// <summary>
/// 0xFFFFFF
/// </summary>
const Color White(0xFFFFFF);
}
}
| [
"[email protected]"
] | |
21df2349a174735c0df4ed80ef58db40b7d90ed5 | 049fb72887fef437e86e4f6aaab0217c7f64596f | /src/particles/ImpactEmitter.cpp | 8bc552076ab1eca504aa0bec34d5809450fde8d5 | [] | no_license | amecky/HitEm | f0ac9ebb6fe58acf30462feb72c85437c54ae4ff | d74e8b5a30135699bd6585d6406ef5034b03f042 | refs/heads/master | 2021-01-10T14:28:28.191906 | 2015-10-21T14:24:35 | 2015-10-21T14:24:35 | 44,268,825 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,290 | cpp | #include "ImpactEmitter.h"
// -----------------------------------------------
// ImpactEmitter
// -----------------------------------------------
void ImpactEmitter::createParticles(ds::ParticleBuffer* buffer,ds::ParticleData* particleData) {
int gx = m_Position.x + 16;
int gy = m_Position.y;
ds::Vec2 pos = ds::Vec2(gx,gy);
float angle = m_StartAngle + 180.0f;
float steps = (m_Range + m_StartAngle) / 4.0f;
//LOG(logINFO) << "creating particles at " << pos.x << " " << pos.y << " start angle " << m_StartAngle;
for ( int x = 0; x < 4; ++x ) {
ds::Particle* p = buffer->createParticle(particleData);
ds::Vec2 pp = pos;
/*
if ( m_Orientation == 0 ) {
pp.x = pos.x - x * 4;
pp.y = gy;
}
else if ( m_Orientation == 1 ) {
pp.x = gx;
pp.y = pos.y - x * 4;
}
else if ( m_Orientation == 2 ) {
pp.x = pos.x + x * 4;
pp.y = gy;
}
else if ( m_Orientation == 0 ) {
pp.x = gx;
pp.y = pos.y + x * 4;
}
*/
p->startPos = ds::Vec2(pp.x,pp.y);
float vr = random(15.0f,45.0f);
ds::Vec2 vel = ds::math::getRadialVelocity(angle,vr);
p->acceleration = ds::Vec2(0,0);
p->velocity = ds::Vec2(vel.x,-vel.y);
p->color = particleData->startColor;
p->rotation = 0.0f;
angle += steps;
if ( angle > 360.0f ) {
angle -= 360.0f;
}
}
}
| [
"[email protected]"
] | |
1b2fd1f762a5c0fa9b606981aac0d2a059de3cae | 4f91e9fefa54ac101c5b50513eb9530d2ef722aa | /include/vision_unit/detect_factory/armor_detect.h | 71eebb9475af965ebed4341c58d1358bcceee159 | [] | no_license | kohillyang/vision_detect | e8bd940dc7acb822616a7b331aaef61a2428f5ed | b49e399e6f570121fb0f118aea7ecd469f17dcaa | refs/heads/master | 2021-01-01T18:19:07.560566 | 2017-08-09T13:58:58 | 2017-08-09T13:58:58 | 98,300,821 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 4,891 | h | #ifndef __ARMOR_H__
#define __ARMOR_H__
#include <opencv2/opencv.hpp>
#include <vector>
#include <list>
#include <tuple>
#include <chrono>
#include "detect_factory.h"
namespace autocar
{
namespace vision_mul
{
class armor_info
{
public:
armor_info(int type_, cv::RotatedRect armor_, std::vector<cv::Point2f> points_, cv::RotatedRect left_=cv::RotatedRect(), cv::RotatedRect right_=cv::RotatedRect())
{
type = type_;
armor = armor_;
points = points_;
left_light = left_;
right_light = right_;
score = 0.0f;
}
armor_info();
int type;
cv::RotatedRect armor;
std::vector<cv::Point2f> points;
cv::RotatedRect left_light;
cv::RotatedRect right_light;
float score;
};
class armor_detecter: public detect_factory
{
private:
const static float m_threshold_max_angle;
const static float m_threshold_min_area;
const static float m_threshold_dis_lower;
const static float m_threshold_dis_upper;
const static float m_threshold_len;
const static float m_threshold_height;
const static float m_threshold_gray;
public:
/**
* @brief constructor
*/
armor_detecter(bool debug_on);
/**
* @brief Highlight the blue or red region of the image
* @param image input image ref
* @param detect_blue true represent blue, false represent red
* @return gray image
*/
cv::Mat highlight_blue_or_red(const cv::Mat &image, bool detect_blue);
/**
* @brief The wrapper for function cv::findContours
* @param binary binary image
* @return contour
*/
std::vector<std::vector<cv::Point>> find_contours(const cv::Mat &binary);
/**
* @brief Finding the true light contour
* @param contours_light blue or red region contour
* @return light contour
*/
std::vector<cv::RotatedRect> point_to_rects(const std::vector<std::vector<cv::Point>> &contours);
/**
* @brief Finding the true light contour
* @param contours_light blue or red region contour
* @param contours_brightness gray image contour
* @return light contour
*/
std::vector<cv::RotatedRect> to_light_rects(const std::vector<std::vector<cv::Point>> &contours_light, const std::vector<std::vector<cv::Point>> &contours_brightness);
/**
* @brief detect the lights on the armors
* @param detect_blue true represent blue, false represent red
* @return
*/
std::vector<cv::RotatedRect> detect_lights(bool detect_blue);
/**
* @brief Filtering the detected lights
* @param lights detected lights ref
* @param thresh_max_angle the max area of the lights
* @param thresh_min_area the min area of the lights
* @return
*/
std::vector<cv::RotatedRect> filter_lights(const std::vector<cv::RotatedRect> &lights, float thresh_max_angle, float thresh_min_area);
/**
* @brief The possible armors
* @param detected lights beside the armors
* @param thres_max_angle the max angle of the armor
* @param thres_dis_lower
* @param thres_dis_upper
* @param thres_len
* @param thres_height
* @param thres_gray
* @param detect_blue
* @return
*/
std::vector<armor_info> possible_armors(const std::vector<cv::RotatedRect> &lights, float thres_max_angle, float thres_dis_lower, \
float thres_dis_upper, float thres_len, float thres_height, float thres_gray, bool detect_blue);
void cal_armor_info(std::vector<cv::Point2f> &armor_points, cv::RotatedRect left_light, cv::RotatedRect right_light);
/**
* @brief Filtering Detected armors by aspect ratio, conv and so on
* @param armors detected armors ref
* @return filtered armors
*/
std::vector<armor_info> filter_by_features(std::vector<armor_info> &armors);
/**
* @brief The entrance function of armor detect
* @param image rgb image
* @return return ture if find armor, else return false
*/
bool detect(const cv::Mat &image, bool detect_blue);
/**
* @brief Slect one armor as the target armor which we will shoot
* @param all_armors all detected armors
* @return the target armor
*/
void slect_final_armor(std::vector<armor_info> all_armors);
/**
* @brief Get the private armor information
* @return
*/
armor_info* get_armor();
/**
* @brief Show the processed image for debug
*/
void debug_vision();
private:
cv::Mat m_common;
cv::Mat m_image;
cv::Mat m_image_hql;
cv::Mat m_show;
cv::Mat m_gray;
cv::Mat possible_armor;
cv::Mat light_img1;
cv::Mat light_img2;
cv::Mat light_img;
cv::Mat m_binary_brightness;
cv::Mat m_binary_color;
cv::Mat m_binary_light;
bool debug_on_;
std::chrono::system_clock::time_point speed_test_start_begin_time;
armor_info *armor;
armor_info *old_armor;
};
}
}
#endif // !__ARMOR_H__
| [
"[email protected]"
] | |
1323f8884d3cada30e7155bbe0159a435393753f | 1e71caca345a9322200b2c655048ac3af7309736 | /Lab10.ino | 31435384578eb83406105af0385afaa2c08102d0 | [] | no_license | PeterLe222/BlackJack | 10d88860b40768c6c76cb3235e3d3d9a7f76e2bc | 8f2c28dbff6e4c32a33e3c2a56b3e6456ab155b0 | refs/heads/master | 2021-01-24T18:39:59.423997 | 2017-03-21T19:12:40 | 2017-03-21T19:12:40 | 84,470,388 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 9,217 | ino | /*
* Game BlackJack
* Using: Arduino Uno, LCD display 16x2, 2 pressbuttons
*/
#include <LiquidCrystal.h>
LiquidCrystal lcd(12, 11, 5, 4, 3, 2);
#define BUTTON_1 7 // pin 7 connects to button 1
#define BUTTON_2 8 // pin 8 connects to button 2
boolean buttonState1 = LOW;
boolean buttonState2 = LOW;
int pressedButton1 = 0; // variable store button 1 pressed
int pressedButton2 = 0; // variable store button 2 pressed
// function debounce press button
boolean debounceButton(boolean state, int button);
// function reset the game
void reset();
// function create card deck
void cardDeck();
// function count the same card
int Check(int *p, int takeCard);
// function calculate the sum of cards
int sumCard(int *p, int min, int max);
// function print card to lcd display
void printCard(int *p, int min, int max);
// function check if there is Ace on deck
int checkAce(int *p, int min, int max);
// function show player's card
void playerHand(int *p, int min, int max);
// function show computer's card and result
void checkGame(int *array, int min);
int array[10]; // array of deck
int i = 1; // variable store array's index
int sumPlayer;// variable store the sum of card value on player's hand
int sumCom; // variable store the sum of card value on computer's hand
void setup() {
pinMode(BUTTON_1, INPUT);
pinMode(BUTTON_2, INPUT);
randomSeed(analogRead(0)); // create random seed
Serial.begin(9600);
// set up the LCD's number of columns and rows:
lcd.begin(16, 2);
lcd.setCursor(3, 0);
lcd.print("BlackJack");
delay(1000); // delay 1 second
lcd.clear(); // clear everything on display
lcd.setCursor(0, 1);
// print introduction
lcd.print("P:PlayerD:Dealer");
lcd.setCursor(0, 0);
lcd.print("Game starts in ");
// countdown in 5 seconds
for (int i = 5; 0 < i; i--)
{
lcd.setCursor(15, 0);
lcd.print(i);
delay(1000);
}
lcd.clear();
}
void loop() {
Serial.print("Btn1= ");Serial.println(pressedButton1);
Serial.print("Btn2= ");Serial.println(pressedButton2);
// count pressed on button 1
if(debounceButton(buttonState1, BUTTON_1) == HIGH && buttonState1 == LOW)
{
pressedButton1++;
buttonState1 = HIGH;
}
else if(debounceButton(buttonState1, BUTTON_1) == LOW && buttonState1 == HIGH)
{
buttonState1 = LOW;
}
// count pressed on button 2
if(debounceButton(buttonState2, BUTTON_2) == HIGH && buttonState2 == LOW)
{
pressedButton2++;
buttonState2 = HIGH;
}
else if(debounceButton(buttonState2, BUTTON_2) == LOW && buttonState2 == HIGH)
{
buttonState2 = LOW;
}
/* show first 2 cards */
if (pressedButton1 == 0 && pressedButton2 == 0)
{
pressedButton1 = 1;
cardDeck(); // draw cards
}
if (pressedButton1 == 1 && pressedButton2 == 0)
{
playerHand(array,0, pressedButton1 + 1); // print player's card
sumPlayer = sumCard(array,0,pressedButton1 + 1); // calculate the point of player's card
}
/* draw third card */
if (pressedButton1 == 2 && pressedButton2 == 0)
{
playerHand(array,0, pressedButton1 + 1);
sumPlayer = sumCard(array,0,pressedButton1 + 1);
/* if player's card bigger than 21, show result */
if (sumPlayer > 21)
{
lcd.setCursor(11,0);
lcd.print("Busts");
lcd.setCursor(0,1);
lcd.print("Dealer Win");
reset();
}
}
/* draw forth card */
if (pressedButton1 == 3)
{
playerHand(array,0, pressedButton1 + 1);
sumPlayer = sumCard(array,0,pressedButton1 + 1);
if (sumPlayer > 21)
{
lcd.setCursor(11,0);
lcd.print("Busts");
lcd.setCursor(0,1);
lcd.print("Dealer Win");
reset();
}
}
/* draw fifth card and show result*/
if (pressedButton1 == 4)
{
playerHand(array,0, pressedButton1 + 1);
sumPlayer = sumCard(array,0,pressedButton1 + 1);
if (sumPlayer > 21)
{
lcd.setCursor(11,0);
lcd.print("Busts");
lcd.setCursor(0,1);
lcd.print("Dealer Win");
reset();
}
pressedButton2 = 1;
}
/* press button 2 to see result */
if (pressedButton2 == 1 && pressedButton1 == 1)
{
checkGame(array,pressedButton1);
}
if (pressedButton2 == 1 && pressedButton1 == 2)
{
checkGame(array,pressedButton1);
}
if (pressedButton2 == 1 && pressedButton1 == 3)
{
checkGame(array,pressedButton1);
}
if (pressedButton2 == 1 && pressedButton1 == 4)
{
checkGame(array,pressedButton1);
}
}
boolean debounceButton(boolean state, int button)
{
boolean stateNow = digitalRead(button);
if(state!=stateNow)
{
delay(10);
stateNow = digitalRead(button);
}
return stateNow;
}
int checkAce(int *p, int min, int max){
int ace = 0; // variable store number of card ACE
for (int i = min; i < max; i++) // run through the drawed cards
{
if (p[i] == 1) // ACE value in array is 1
{
ace++;
}
}
return ace;
}
void printCard(int *p, int min, int max){
for (int i = min; i < max; i++) // run through the drawed cards
{
if (*(p+i) == 11) // print J when value in card deck is 11
{
lcd.print("J ");
}
else if (*(p+i) == 12) // print Q when value in card deck is 12
{
lcd.print("Q ");
}
else if (*(p+i) == 13) // print K when value in card deck is 13
{
lcd.print("K ");
}
else if (*(p+i) == 1) // print A when value in card deck is 1
{
lcd.print("A ");
}
else // print normal cards
{
lcd.print(*(p+i));
lcd.print(" ");
}
}
}
int Check(int *p, int takeCard){
int checkCard = 0; // variable store number of same cards
// check and return the number of same card
for (int i = 0; i < 10; i++) // run through the card deck
{
// if there is same card with drawed card, increase the number of checkCard
if (p[i] == takeCard)
{
checkCard++;
}
}
return checkCard;
}
int sumCard(int *p, int min, int max){
int sum = 0; // variable store total point of drawed cards
for (int i = min; i < max; i++)
{
if (p[i] == 11) // plus 10 when card is J
{
sum += 10;
}
else if (p[i] == 12) // plus 10 when card is Q
{
sum += 10;
}
else if (p[i] == 13) // plus 10 when card is K
{
sum += 10;
}
else // other cards add the same value in card deck
{
sum += p[i];
}
}
return sum;
}
void playerHand(int *p, int min, int max){
lcd.setCursor(0,0); // set position on display to print
lcd.print("P:"); // print 'P' for player
printCard(p, min, max); // print drawed cards
}
void cardDeck(){
for (int i = 0; i < 10; i++)
{
array[i] = random(1,14); // take random number from 1 to 13
int checkCard = Check(array, array[i]); // check same cards
// if there are more than 4 same cards, draw again
if (checkCard == 4)
{
i--;
}
}
}
void reset(){
delay(5000); // wait 5 seconds
lcd.clear(); // clear everything on display
i = 1; // reset i value
pressedButton1 = pressedButton2 = 0; // reset 2 buttons
}
void checkGame(int *array, int min){
/* +10 when there is an Ace for player
* when total point of drawed cards smaller than 12
*/
if (sumCard(array,0,min+1) < 12 && checkAce(array, 0, min+1)==1)
{
sumPlayer += 10;
}
lcd.setCursor(0,1);
lcd.print("D:"); // print 'D' as Dealer
printCard(array,min+1, min+2+i);
sumCom = sumCard(array,min+1,min+2+i);
/* +10 when there is an Ace for computer
* when total point +10 equal or bigger than 17
*/
if ((sumCom + 10) >= 17 && checkAce(array,min+1,min+2+i) == 1)
{
sumCom += 10;
// check if point of player and computer are equal
if (sumCom == sumPlayer)
{
lcd.setCursor(12,0);
lcd.print("Draw"); // print Draw for Player
lcd.setCursor(12,1);
lcd.print("Draw"); // print Draw for Dealer
reset();
}
// check point of player and computer
else if (sumCom > sumPlayer)
{
lcd.setCursor(13,1);
lcd.print("Win"); // print Win for Dealer
reset();
}
// player win
else
{
lcd.setCursor(13,0);
lcd.print("Win"); // print Win for Player
reset();
}
}
else // if there are more than an ACE or there is no ACE
{
// total point of drawed card smaller than 17, draw 1 more card
if (sumCom < 17)
{
i++;
}
// Dealer busts
else if (sumCom > 21)
{
lcd.setCursor(13,0);
lcd.print("Win"); // print Win for Player
reset();
}
// drawed cards point of Dealer bigger than 16 and smaller than 21
else
{
// Dealer and Player get the same point
if (sumCom == sumPlayer)
{
lcd.setCursor(12,0);
lcd.print("Draw");
lcd.setCursor(12,1);
lcd.print("Draw");
reset();
}
// Dealer's point smaller than Player's
else if (sumCom < sumPlayer)
{
lcd.setCursor(13,0);
lcd.print("Win");
reset();
}
// Dealer's point bigger than Player's
else
{
lcd.setCursor(13,1);
lcd.print("Win");
reset();
}
}
}
}
| [
"[email protected]"
] | |
1cfaaa17e3c58dc041f8c5904817c7425e57e092 | f64dd4b2de108c319add6439922366ee1f09f667 | /0711/mainwindow.h | 5daa93794c0eb41511be4e401941ad7ffded74d4 | [] | no_license | StephenAmell2018/HR_program | 363919cdb0c330ec709ec7414d0969fa5043f5e8 | bbc35e41fdc035ba05fb153d648c7b0f845a2ed5 | refs/heads/master | 2020-04-02T10:02:42.142728 | 2018-10-23T12:36:52 | 2018-10-23T12:36:52 | 154,321,817 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,075 | h | #ifndef MAINWINDOW_H
#define MAINWINDOW_H
#include <QMainWindow>
#include <QPaintEvent>
#include <QTimer>
#include <QPainter>
#include <QPixmap>
#include <QLabel>
#include <QImage>
#include <QDebug>
#include <opencv2/opencv.hpp>
#include <QMainWindow>
using namespace cv;
void mouseWrapper( int event, int x, int y, int flags, void* param );
namespace Ui {
class MainWindow;
}
class MainWindow : public QMainWindow
{
Q_OBJECT
public:
explicit MainWindow(QWidget *parent = 0);
~MainWindow();
void onMouse(int EVENT, int x, int y, int flags, void* userdata);//注意要放到public中；
private slots:
void on_pushButton_clicked();
void getFrame();
private:
Ui::MainWindow *ui;
QImage *imag;
CvCapture *capture;//highgui里提供的一个专门处理摄像头图像的结构体
IplImage *frame;//摄像头每次抓取的图像为一帧，使用该指针指向一帧图像的内存空间
QTimer *timer;//定时器用于定时取帧，上面说的隔一段时间就去取就是用这个实现
};
#endif // MAINWINDOW_H
| [
"[email protected]"
] | |
3f8576d416adeeeb84aee268299ac73eddb9b475 | d14b5d78b72711e4614808051c0364b7bd5d6d98 | /third_party/llvm-10.0/llvm/include/llvm/CodeGen/MachineInstrBundleIterator.h | 0f59563e7e1bec7239304ed2e0c93d715c8264a4 | [
"Apache-2.0"
] | permissive | google/swiftshader | 76659addb1c12eb1477050fded1e7d067f2ed25b | 5be49d4aef266ae6dcc95085e1e3011dad0e7eb7 | refs/heads/master | 2023-07-21T23:19:29.415159 | 2023-07-21T19:58:29 | 2023-07-21T20:50:19 | 62,297,898 | 1,981 | 306 | Apache-2.0 | 2023-07-05T21:29:34 | 2016-06-30T09:25:24 | C++ | UTF-8 | C++ | false | false | 11,216 | h | //===- llvm/CodeGen/MachineInstrBundleIterator.h ----------------*- C++ -*-===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//
//
// Defines an iterator class that bundles MachineInstr.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CODEGEN_MACHINEINSTRBUNDLEITERATOR_H
#define LLVM_CODEGEN_MACHINEINSTRBUNDLEITERATOR_H
#include "llvm/ADT/ilist.h"
#include "llvm/ADT/simple_ilist.h"
#include <cassert>
#include <iterator>
#include <type_traits>
namespace llvm {
template <class T, bool IsReverse> struct MachineInstrBundleIteratorTraits;
template <class T> struct MachineInstrBundleIteratorTraits<T, false> {
using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>;
using instr_iterator = typename list_type::iterator;
using nonconst_instr_iterator = typename list_type::iterator;
using const_instr_iterator = typename list_type::const_iterator;
};
template <class T> struct MachineInstrBundleIteratorTraits<T, true> {
using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>;
using instr_iterator = typename list_type::reverse_iterator;
using nonconst_instr_iterator = typename list_type::reverse_iterator;
using const_instr_iterator = typename list_type::const_reverse_iterator;
};
template <class T> struct MachineInstrBundleIteratorTraits<const T, false> {
using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>;
using instr_iterator = typename list_type::const_iterator;
using nonconst_instr_iterator = typename list_type::iterator;
using const_instr_iterator = typename list_type::const_iterator;
};
template <class T> struct MachineInstrBundleIteratorTraits<const T, true> {
using list_type = simple_ilist<T, ilist_sentinel_tracking<true>>;
using instr_iterator = typename list_type::const_reverse_iterator;
using nonconst_instr_iterator = typename list_type::reverse_iterator;
using const_instr_iterator = typename list_type::const_reverse_iterator;
};
template <bool IsReverse> struct MachineInstrBundleIteratorHelper;
template <> struct MachineInstrBundleIteratorHelper<false> {
/// Get the beginning of the current bundle.
template <class Iterator> static Iterator getBundleBegin(Iterator I) {
if (!I.isEnd())
while (I->isBundledWithPred())
--I;
return I;
}
/// Get the final node of the current bundle.
template <class Iterator> static Iterator getBundleFinal(Iterator I) {
if (!I.isEnd())
while (I->isBundledWithSucc())
++I;
return I;
}
/// Increment forward ilist iterator.
template <class Iterator> static void increment(Iterator &I) {
I = std::next(getBundleFinal(I));
}
/// Decrement forward ilist iterator.
template <class Iterator> static void decrement(Iterator &I) {
I = getBundleBegin(std::prev(I));
}
};
template <> struct MachineInstrBundleIteratorHelper<true> {
/// Get the beginning of the current bundle.
template <class Iterator> static Iterator getBundleBegin(Iterator I) {
return MachineInstrBundleIteratorHelper<false>::getBundleBegin(
I.getReverse())
.getReverse();
}
/// Get the final node of the current bundle.
template <class Iterator> static Iterator getBundleFinal(Iterator I) {
return MachineInstrBundleIteratorHelper<false>::getBundleFinal(
I.getReverse())
.getReverse();
}
/// Increment reverse ilist iterator.
template <class Iterator> static void increment(Iterator &I) {
I = getBundleBegin(std::next(I));
}
/// Decrement reverse ilist iterator.
template <class Iterator> static void decrement(Iterator &I) {
I = std::prev(getBundleFinal(I));
}
};
/// MachineBasicBlock iterator that automatically skips over MIs that are
/// inside bundles (i.e. walk top level MIs only).
template <typename Ty, bool IsReverse = false>
class MachineInstrBundleIterator : MachineInstrBundleIteratorHelper<IsReverse> {
using Traits = MachineInstrBundleIteratorTraits<Ty, IsReverse>;
using instr_iterator = typename Traits::instr_iterator;
instr_iterator MII;
public:
using value_type = typename instr_iterator::value_type;
using difference_type = typename instr_iterator::difference_type;
using pointer = typename instr_iterator::pointer;
using reference = typename instr_iterator::reference;
using const_pointer = typename instr_iterator::const_pointer;
using const_reference = typename instr_iterator::const_reference;
using iterator_category = std::bidirectional_iterator_tag;
private:
using nonconst_instr_iterator = typename Traits::nonconst_instr_iterator;
using const_instr_iterator = typename Traits::const_instr_iterator;
using nonconst_iterator =
MachineInstrBundleIterator<typename nonconst_instr_iterator::value_type,
IsReverse>;
using reverse_iterator = MachineInstrBundleIterator<Ty, !IsReverse>;
public:
MachineInstrBundleIterator(instr_iterator MI) : MII(MI) {
assert((!MI.getNodePtr() || MI.isEnd() || !MI->isBundledWithPred()) &&
"It's not legal to initialize MachineInstrBundleIterator with a "
"bundled MI");
}
MachineInstrBundleIterator(reference MI) : MII(MI) {
assert(!MI.isBundledWithPred() && "It's not legal to initialize "
"MachineInstrBundleIterator with a "
"bundled MI");
}
MachineInstrBundleIterator(pointer MI) : MII(MI) {
// FIXME: This conversion should be explicit.
assert((!MI || !MI->isBundledWithPred()) && "It's not legal to initialize "
"MachineInstrBundleIterator "
"with a bundled MI");
}
// Template allows conversion from const to nonconst.
template <class OtherTy>
MachineInstrBundleIterator(
const MachineInstrBundleIterator<OtherTy, IsReverse> &I,
typename std::enable_if<std::is_convertible<OtherTy *, Ty *>::value,
void *>::type = nullptr)
: MII(I.getInstrIterator()) {}
MachineInstrBundleIterator() : MII(nullptr) {}
/// Explicit conversion between forward/reverse iterators.
///
/// Translate between forward and reverse iterators without changing range
/// boundaries. The resulting iterator will dereference (and have a handle)
/// to the previous node, which is somewhat unexpected; but converting the
/// two endpoints in a range will give the same range in reverse.
///
/// This matches std::reverse_iterator conversions.
explicit MachineInstrBundleIterator(
const MachineInstrBundleIterator<Ty, !IsReverse> &I)
: MachineInstrBundleIterator(++I.getReverse()) {}
/// Get the bundle iterator for the given instruction's bundle.
static MachineInstrBundleIterator getAtBundleBegin(instr_iterator MI) {
return MachineInstrBundleIteratorHelper<IsReverse>::getBundleBegin(MI);
}
reference operator*() const { return *MII; }
pointer operator->() const { return &operator*(); }
/// Check for null.
bool isValid() const { return MII.getNodePtr(); }
friend bool operator==(const MachineInstrBundleIterator &L,
const MachineInstrBundleIterator &R) {
return L.MII == R.MII;
}
friend bool operator==(const MachineInstrBundleIterator &L,
const const_instr_iterator &R) {
return L.MII == R; // Avoid assertion about validity of R.
}
friend bool operator==(const const_instr_iterator &L,
const MachineInstrBundleIterator &R) {
return L == R.MII; // Avoid assertion about validity of L.
}
friend bool operator==(const MachineInstrBundleIterator &L,
const nonconst_instr_iterator &R) {
return L.MII == R; // Avoid assertion about validity of R.
}
friend bool operator==(const nonconst_instr_iterator &L,
const MachineInstrBundleIterator &R) {
return L == R.MII; // Avoid assertion about validity of L.
}
friend bool operator==(const MachineInstrBundleIterator &L, const_pointer R) {
return L == const_instr_iterator(R); // Avoid assertion about validity of R.
}
friend bool operator==(const_pointer L, const MachineInstrBundleIterator &R) {
return const_instr_iterator(L) == R; // Avoid assertion about validity of L.
}
friend bool operator==(const MachineInstrBundleIterator &L,
const_reference R) {
return L == &R; // Avoid assertion about validity of R.
}
friend bool operator==(const_reference L,
const MachineInstrBundleIterator &R) {
return &L == R; // Avoid assertion about validity of L.
}
friend bool operator!=(const MachineInstrBundleIterator &L,
const MachineInstrBundleIterator &R) {
return !(L == R);
}
friend bool operator!=(const MachineInstrBundleIterator &L,
const const_instr_iterator &R) {
return !(L == R);
}
friend bool operator!=(const const_instr_iterator &L,
const MachineInstrBundleIterator &R) {
return !(L == R);
}
friend bool operator!=(const MachineInstrBundleIterator &L,
const nonconst_instr_iterator &R) {
return !(L == R);
}
friend bool operator!=(const nonconst_instr_iterator &L,
const MachineInstrBundleIterator &R) {
return !(L == R);
}
friend bool operator!=(const MachineInstrBundleIterator &L, const_pointer R) {
return !(L == R);
}
friend bool operator!=(const_pointer L, const MachineInstrBundleIterator &R) {
return !(L == R);
}
friend bool operator!=(const MachineInstrBundleIterator &L,
const_reference R) {
return !(L == R);
}
friend bool operator!=(const_reference L,
const MachineInstrBundleIterator &R) {
return !(L == R);
}
// Increment and decrement operators...
MachineInstrBundleIterator &operator--() {
this->decrement(MII);
return *this;
}
MachineInstrBundleIterator &operator++() {
this->increment(MII);
return *this;
}
MachineInstrBundleIterator operator--(int) {
MachineInstrBundleIterator Temp = *this;
--*this;
return Temp;
}
MachineInstrBundleIterator operator++(int) {
MachineInstrBundleIterator Temp = *this;
++*this;
return Temp;
}
instr_iterator getInstrIterator() const { return MII; }
nonconst_iterator getNonConstIterator() const { return MII.getNonConst(); }
/// Get a reverse iterator to the same node.
///
/// Gives a reverse iterator that will dereference (and have a handle) to the
/// same node. Converting the endpoint iterators in a range will give a
/// different range; for range operations, use the explicit conversions.
reverse_iterator getReverse() const { return MII.getReverse(); }
};
} // end namespace llvm
#endif // LLVM_CODEGEN_MACHINEINSTRBUNDLEITERATOR_H
| [
"[email protected]"
] | |
cf1c490168fe8b5e6416c271b23336b0dc38ad68 | 7a9dd38a36ab4635f875e90e586fd2199e4594e5 | /examples/autodif/mixture/normsim.cpp | 0a074e4bf96bf13d983d4dcb2bb15dd011e987bd | [
"BSD-3-Clause",
"BSD-2-Clause"
] | permissive | johnrsibert/admb | 66c1af2beed685cf2f4d489cb0599b735b9e8210 | 063ec863a9f23f6c6afbc7d481af0476b8d63645 | refs/heads/master | 2021-01-17T17:40:50.106119 | 2019-08-10T16:30:41 | 2019-08-10T16:30:41 | 53,153,586 | 0 | 0 | NOASSERTION | 2019-08-10T16:30:43 | 2016-03-04T17:33:37 | C++ | UTF-8 | C++ | false | false | 4,135 | cpp | /**
* Copyright (c) 2008, 2009, 2010 Regents of the University of California
*
* ADModelbuilder and associated libraries and documentations are
* provided under the general terms of the "BSD" license.
*
* License:
*
* Redistribution and use in source and binary forms, with or without
* modification, are permitted provided that the following conditions are
* met:
*
* 1. Redistributions of source code must retain the above copyright
* notice, this list of conditions and the following disclaimer.
*
* 2. Redistributions in binary form must reproduce the above copyright
* notice, this list of conditions and the following disclaimer in the
* documentation and/or other materials provided with the distribution.
*
* 3. Neither the name of the University of California, Otter Research,
* nor the ADMB Foundation 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 <fvar.hpp>
#ifdef __BCPLUSPLUS__
extern unsigned _stklen = 20000;
#include <iomanip.h>
#endif
#ifdef __ZTC__
long _stack = 20000;
#include <iomanip.hpp>
#endif
int main()
{
using std::cout;
using std::endl;
// the file normsim.par contains the parameters used to simulate
// a mixture of distributions; exit this file to produce a different
// mixture
std::ifstream infile("normsim.par");
int ngroups;
int nsamp;
// first line of file contains the number of groups
infile >> ngroups;
// allocate containers for means, standard deviatons
// and proportions of each group
dvector mean(1,ngroups);
dvector sd(1,ngroups);
dvector p(1,ngroups);
// second line of file contains the proportion of the
// total sample in each group; note these sum to 1
infile >> p;
// third line contains the mean of each group
infile >> mean;
// fourth line contains the standard deviation of each group
infile >> sd;
// fifth line is the sample size
infile >> nsamp;
dvector lengths(1,nsamp);
lengths.fill_randn(213); // 213 is arbirtrary random number seed
// lengths has standard normal random variables
ivector choices(1,nsamp);
choices.fill_multinomial(101,p); // 101 is arbirtrary random number seed
// choices has multinomial dist
lengths= elem_prod(sd(choices),lengths)+mean(choices);
double maxlen=max(lengths);
double minlen=min(lengths);
ivector freq(1,int(maxlen-minlen+1));
freq.fill_seqadd(0,0);
std::ofstream dout("normsim.out");
dout << setw(15)<< std::ios::scientific << column_vector(lengths);
dout.close();
cout << "Sample of " << nsamp<< " lengths written to file 'normsim.out'.\n";
cout << "Copy this file to 'mixture.par' to run the mixture example.\n\n";
for (int i=lengths.indexmin();i<=lengths.indexmax(); i++)
{
freq[lengths(i)-minlen+1]+=1;
}
std::ofstream fout("normsim.frq");
for (i=freq.indexmin();i<=freq.indexmax(); i++)
{
fout << setw(10) << std::setprecision(4) << std::ios::fixed << minlen+i-1
<< setw(10) << freq(i) << "\n";
}
fout.close();
cout << "Frequency distributions written to file 'normsim.frq'.\n";
cout << "This file may be view graphically with a grapchis\n"
"utility or spreadsheet.\n";
return 0;
}
| [
"johnoel@6fd93cbc-6849-4d5d-bcfc-d3e1d932c95a"
] | johnoel@6fd93cbc-6849-4d5d-bcfc-d3e1d932c95a |
d87dd55e5c253eaeef0cec2bacc8a62c70ad6bf2 | 6c7520ea1c95f437ecde70fcdb202ab5cee54b17 | /WF_ash/AtCoder/nice_code.cpp | 13dbd6473bf8dae6d6b2ecd2f6258bcdb8229b5d | [] | no_license | Ashish-uzumaki/contests | 997a8288c63f1e834b7689c2ff97e29e965b6139 | 0084adfc3b1a9bf496146c6e4db429720a1ce98c | refs/heads/master | 2021-01-16T04:07:38.303987 | 2020-08-09T16:49:47 | 2020-08-09T16:49:47 | 242,972,066 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,658 | cpp | //#define NDEBUG
#include <algorithm>
#include <cstddef>
#include <cstdint>
#include <iostream>
#include <utility>
#include <vector>
namespace n91 {
using i8 = std::int_fast8_t;
using i32 = std::int_fast32_t;
using i64 = std::int_fast64_t;
using u8 = std::uint_fast8_t;
using u32 = std::uint_fast32_t;
using u64 = std::uint_fast64_t;
using isize = std::ptrdiff_t;
using usize = std::size_t;
struct rep {
struct itr {
usize i;
constexpr itr(const usize i) noexcept : i(i) {}
void operator++() noexcept { ++i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
const itr f, l;
constexpr rep(const usize f, const usize l) noexcept
: f(std::min(f, l)), l(l) {}
constexpr auto begin() const noexcept { return f; }
constexpr auto end() const noexcept { return l; }
};
struct revrep {
struct itr {
usize i;
constexpr itr(const usize i) noexcept : i(i) {}
void operator++() noexcept { --i; }
constexpr usize operator*() const noexcept { return i; }
constexpr bool operator!=(const itr x) const noexcept { return i != x.i; }
};
const itr f, l;
constexpr revrep(const usize f, const usize l) noexcept
: f(l - 1), l(std::min(f, l) - 1) {}
constexpr auto begin() const noexcept { return f; }
constexpr auto end() const noexcept { return l; }
};
template <class T> auto md_vec(const usize n, const T &value) {
return std::vector<T>(n, value);
}
template <class... Args> auto md_vec(const usize n, Args... args) {
return std::vector<decltype(md_vec(args...))>(n, md_vec(args...));
}
template <class T> constexpr T difference(const T &a, const T &b) noexcept {
if (a < b) {
return b - a;
} else {
return a - b;
}
}
template <class T> void chmin(T &a, const T &b) noexcept {
if (b < a) {
a = b;
}
}
template <class T> void chmax(T &a, const T &b) noexcept {
if (a < b) {
a = b;
}
}
template <class F> class fix_point : private F {
public:
explicit constexpr fix_point(F &&f) : F(std::forward<F>(f)) {}
template <class... Args>
constexpr decltype(auto) operator()(Args &&... args) const {
return F::operator()(*this, std::forward<Args>(args)...);
}
};
template <class F> constexpr decltype(auto) make_fix(F &&f) {
return fix_point<F>(std::forward<F>(f));
}
template <class T> T scan() {
T ret;
std::cin >> ret;
return ret;
}
} // namespace n91
#include <cassert>
#include <cstdint>
#include <iterator>
#include <vector>
namespace n91 {
class m61_rolling_hash {
private:
using u64 = std::uint_fast64_t;
using size_t = std::size_t;
public:
using value_type = u64;
private:
static constexpr u64 pow2(const int exp) noexcept {
return static_cast<u64>(1) << exp;
}
static constexpr u64 Mod = (static_cast<u64>(1) << 61) - 1;
static constexpr u64 multiplies_plus(const u64 l, const u64 r,
const u64 c) noexcept {
const u64 ld = l % pow2(31);
const u64 lu = l / pow2(31);
const u64 rd = r % pow2(31);
const u64 ru = r / pow2(31);
const u64 m = ld * ru + lu * rd;
u64 v = lu * ru * 2 + ld * rd + m % pow2(30) * pow2(31) + m / pow2(30) + c;
v = v % pow2(61) + v / pow2(61);
if (v >= Mod) {
v -= Mod;
}
return v;
}
std::vector<u64> prefix;
std::vector<u64> power;
public:
m61_rolling_hash() = default;
template <class C>
explicit m61_rolling_hash(const C &c, const u64 base = 91)
: prefix(), power() {
const size_t n = c.size();
prefix.reserve(n + 1);
prefix.push_back(0);
for (size_t i = 0; i != n; ++i) {
prefix.push_back(multiplies_plus(prefix.back(), base, c[i]));
}
power.reserve(n + 1);
power.push_back(Mod - 1);
for (size_t i = 0; i != n; ++i) {
power.push_back(multiplies_plus(power.back(), base, 0));
}
}
u64 get(const size_t first, const size_t last) const noexcept {
assert(first <= last);
assert(last < prefix.size());
return multiplies_plus(prefix[first], power[last - first], prefix[last]);
}
u64 operator()(const size_t first, const size_t last) const noexcept {
assert(first <= last);
assert(last < prefix.size());
return get(first, last);
}
};
} // namespace n91
#include <cstdint>
namespace n91 {
template <std::uint_fast64_t Modulus> class modint {
using u64 = std::uint_fast64_t;
public:
using value_type = u64;
static constexpr u64 mod = Modulus;
private:
static_assert(mod < static_cast<u64>(1) << 32,
"Modulus must be less than 2**32");
u64 v;
constexpr modint &negate() noexcept {
if (v != 0)
v = mod - v;
return *this;
}
public:
constexpr modint(const u64 x = 0) noexcept : v(x % mod) {}
constexpr u64 &value() noexcept { return v; }
constexpr const u64 &value() const noexcept { return v; }
constexpr modint operator+() const noexcept { return modint(*this); }
constexpr modint operator-() const noexcept { return modint(*this).negate(); }
constexpr modint operator+(const modint rhs) const noexcept {
return modint(*this) += rhs;
}
constexpr modint operator-(const modint rhs) const noexcept {
return modint(*this) -= rhs;
}
constexpr modint operator*(const modint rhs) const noexcept {
return modint(*this) *= rhs;
}
constexpr modint operator/(const modint rhs) const noexcept {
return modint(*this) /= rhs;
}
constexpr modint &operator+=(const modint rhs) noexcept {
v += rhs.v;
if (v >= mod)
v -= mod;
return *this;
}
constexpr modint &operator-=(const modint rhs) noexcept {
if (v < rhs.v)
v += mod;
v -= rhs.v;
return *this;
}
constexpr modint &operator*=(const modint rhs) noexcept {
v = v * rhs.v % mod;
return *this;
}
constexpr modint &operator/=(modint rhs) noexcept {
u64 exp = mod - 2;
while (exp) {
if (exp % 2 != 0)
*this *= rhs;
rhs *= rhs;
exp /= 2;
}
return *this;
}
constexpr bool operator==(const modint rhs) const noexcept {
return v == rhs.v;
}
constexpr bool operator!=(const modint rhs) const noexcept {
return v != rhs.v;
}
};
template <std::uint_fast64_t Modulus>
constexpr typename modint<Modulus>::u64 modint<Modulus>::mod;
} // namespace n91
#include <utility>
namespace n91 {
template <class T, class U, class Operate = std::multiplies<T>>
constexpr T power(T base, U exp, const Operate &oper = Operate(), T iden = 1) {
while (exp != 0) {
if (exp % 2 != 0) {
iden = oper(iden, base);
}
exp /= 2;
base = oper(base, base);
}
return iden;
}
} // namespace n91
#include <utility>
namespace n91 {
template <class T> constexpr T gcd(T m, T n) noexcept {
while (n != static_cast<T>(0)) {
m %= n;
std::swap(m, n);
}
return m;
}
template <class T> constexpr T lcm(const T &m, const T &n) noexcept {
return m / gcd(m, n) * n;
}
} // namespace n91
#include <algorithm>
#include <iostream>
#include <utility>
#include <vector>
namespace n91 {
void main_() {
/*
std::ios::sync_with_stdio(false);
std::cin.tie(nullptr);
//*/
const usize n = scan<usize>();
const u64 m = scan<u32>();
std::vector<u64> a(n);
for (auto &e : a)
std::cin >> e;
u64 cm = 1;
for (auto &e : a) {
e /= 2;
cm = lcm(cm, e);
if (cm > m) {
std::cout << 0 << std::endl;
return;
}
}
for (const auto e : a) {
if (cm / e % 2 == 0) {
std::cout << 0 << std::endl;
return;
}
}
std::cout << (m / cm) - (m / (2 * cm)) << std::endl;
}
} // namespace n91
int main() {
n91::main_();
return 0;
}
| [
"[email protected]"
] | |
46f56f09ec862aa8866ef8694110300c4a1c4114 | 1d0adb03725890fad103fc6946e8629ad68b03ac | /atcoder/ABC063/C/main.cpp | 37a1654fbb5e8a86bb9976a1f4c936d6325155a8 | [] | no_license | morix1500/atcoder | b4df0589dea93f69da9692c1712aabf2141a7e6d | 3183abe66fb19a1b258ea63223c3390cfaf972d1 | refs/heads/master | 2020-05-05T06:48:05.571434 | 2019-08-27T06:11:57 | 2019-08-27T06:11:57 | 179,801,951 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 449 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int main() {
int n;
cin >> n;
vector<int> s(n);
int sum = 0;
for (int i = 0; i < n; i++) {
cin >> s[i];
sum += s[i];
}
if (sum % 10 != 0) {
cout << sum << endl;
return 0;
}
sort(s.begin(), s.end());
for (int i = 0; i < n; i++) {
if ((sum - s[i]) % 10 != 0) {
cout << sum - s[i] << endl;
return 0;
}
}
cout << 0 << endl;
} | [
"[email protected]"
] | |
daa822a700a8be24fc4dd6633abe4148f6619694 | 918725cd82fbb56b7d8911c7c44dd6a26608e9b8 | /src/reasoning_node.cpp | 2f12d28fa1baa0d1cad89e26440337d74828971e | [] | no_license | emlozin/roboy_mind | efba1d2c8c23d9d02bc8efbb2feaf05a53a990f6 | d9a824008d07640aea512856ebda9768e37d5469 | refs/heads/master | 2021-01-09T05:22:46.115510 | 2017-03-21T22:27:48 | 2017-03-21T22:27:48 | 80,757,626 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 11,337 | cpp | /* ***************************************
Author: Emilia Lozinska
E-mail: [email protected]
*/
/*! @file
* \brief Main reasoning node.
* Storing all service and callback definitions.
*
* Storing all definitions of RoboyMin dclass methods.
*/
#include <roboy_mind/reasoning_node.h>
/* *******************
* Service functions
* *******************/
bool RoboyMind::assertPropertySRV(roboy_mind::srvAssertProperty::Request &req,roboy_mind::srvAssertProperty::Response &res)
{
// Query part for the object
string query = "rdf_assert('" + this->ontology_name;
query += req.object;
query += "','" + this->ontology_name;
query += req.property;
if (!req.data){
query += "','" + this->ontology_name;
query += req.instance;
}
else{
query += "','";
query += req.instance;
}
query += "')";
if (SHOW_QUERIES)
cout << query << endl;
PrologQueryProxy bdgs = pl.query(query);
res.result = true;
return true;
}
bool RoboyMind::callQuerySRV(roboy_mind::srvCallQuery::Request &req,roboy_mind::srvCallQuery::Response &res)
{
// Quering Prolog to see the instances
PrologQueryProxy bdgs = pl.query(req.query);
if (SHOW_QUERIES)
cout << req.query << endl;
res.result = false;
for(PrologQueryProxy::iterator it=bdgs.begin();it != bdgs.end(); it++)
{
PrologBindings bdg = *it;
//cout << "Query is : " << (bool)(it == bdgs.end()) << endl;
res.result = true;
}
return true;
}
bool RoboyMind::checkPropertySRV(roboy_mind::srvCheckProperty::Request &req,roboy_mind::srvCheckProperty::Response &res)
{
// Query part for the object
string query = "owl_has('" + this->ontology_name;
query += req.object;
query += "','" + this->ontology_name;
query += req.property;
if (!req.data)
query += "','" + this->ontology_name;
else
query += "','";
query += req.instance;
query += "')";
if (SHOW_QUERIES)
cout << query << endl;
PrologQueryProxy bdgs = pl.query(query);
res.result = false;
for(PrologQueryProxy::iterator it=bdgs.begin();it != bdgs.end(); it++)
{
PrologBindings bdg = *it;
//cout << "Real query is : " << (bool)(it == bdgs.end()) << endl;
res.result = true;
}
}
bool RoboyMind::checkQuerySRV(roboy_mind::srvCheckQuery::Request &req,roboy_mind::srvCheckQuery::Response &res)
{
// Quering Prolog to see the instances
PrologQueryProxy bdgs = pl.query(req.query);
if (SHOW_QUERIES)
cout << req.query << endl;
res.result = false;
for(PrologQueryProxy::iterator it=bdgs.begin();it != bdgs.end(); it++)
{
PrologBindings bdg = *it;
//cout << "Query is : " << (bool)(it == bdgs.end()) << endl;
res.result = true;
}
return true;
}
bool RoboyMind::createInstanceSRV(roboy_mind::srvCreateInstance::Request &req,roboy_mind::srvCreateInstance::Response &res)
{
// Building the query
string query = "create_instance_from_class('" + this->ontology_name;
query += req.object_class;
query += "',";
query += IntToStr(req.id);
query += ", ObjInst)";
if (SHOW_QUERIES)
cout << query << endl;
PrologQueryProxy bdgs = pl.query(query);
res.instance = req.object_class + "_" + IntToStr(req.id);
ROS_INFO("New instance created. \n Instance id: %d ", req.id);
return true;
}
bool RoboyMind::findInstancesSRV(roboy_mind::srvFindInstances::Request &req,roboy_mind::srvFindInstances::Response &res)
{
vector<string> result;
// Query part for the object
string query = "owl_has(A,'" + this->ontology_name;
query += req.property;
query += "','";
if (!req.data){
query += "" + this->ontology_name;
}
query += req.value;
query += "')";
if (SHOW_QUERIES)
cout << query << endl;
PrologQueryProxy bdgs = pl.query(query);
stringstream ss;
for(PrologQueryProxy::iterator it=bdgs.begin();it != bdgs.end(); it++)
{
PrologBindings bdg = *it;
//cout << "A : " << bdg["A"] << endl;
ss << bdg["A"];
result.push_back(ss.str());
ss.str(std::string());
}
res.instances = result;
return true;
}
bool RoboyMind::showInstancesSRV(roboy_mind::srvShowInstances::Request &req,roboy_mind::srvShowInstances::Response &res)
{
vector<string> result;
string query = "rdfs_individual_of(I, '" + this->ontology_name;
query += req.object_class;
query += "')";
if (SHOW_QUERIES)
cout << query << endl;
// Quering Prolog to see the instances
PrologQueryProxy bdgs = pl.query(query);
stringstream ss;
for(PrologQueryProxy::iterator it=bdgs.begin();it != bdgs.end(); it++)
{
PrologBindings bdg = *it;
//cout << "I : " << bdg["I"] << endl;
ss << bdg["I"];
result.push_back(ss.str());
ss.str(std::string());
}
res.instances = result;
return true;
}
bool RoboyMind::showPropertySRV(roboy_mind::srvShowProperty::Request &req,roboy_mind::srvShowProperty::Response &res)
{
vector<string> result;
// Query part for the object
string query = "owl_has('";
query += ontology_name;
query += req.object;
query += "',A,P)";
if (SHOW_QUERIES)
cout << query << endl;
// Quering Prolog to see the properties and values
PrologQueryProxy bdgs = pl.query(query);
stringstream ss;
for(PrologQueryProxy::iterator it=bdgs.begin();it != bdgs.end(); it++)
{
PrologBindings bdg = *it;
cout << "Property : " << bdg["A"] << endl;
cout << "Value : " << bdg["P"] << endl;
ss << bdg["A"];
result.push_back(ss.str());
ss.str(std::string());
}
res.property = result;
return true;
}
bool RoboyMind::showPropertyValueSRV(roboy_mind::srvShowPropertyValue::Request &req,roboy_mind::srvShowPropertyValue::Response &res)
{
vector<string> result;
// Query part for the object
string query = "owl_has('";
query += req.object;
query += "','" + this->ontology_name;
query += req.property;
query += "',P)";
if (SHOW_QUERIES)
cout << query << endl;
// Quering Prolog to see the properties and values
PrologQueryProxy bdgs = pl.query(query);
stringstream ss;
for(PrologQueryProxy::iterator it=bdgs.begin();it != bdgs.end(); it++)
{
PrologBindings bdg = *it;
cout << "Value : " << bdg["P"] << endl;
ss << bdg["P"];
result.push_back(ss.str());
ss.str(std::string());
}
res.value = result;
return true;
}
bool RoboyMind::saveObjectSRV(roboy_mind::srvSaveObject::Request &req,roboy_mind::srvSaveObject::Response &res)
{
// Query part for the object
// save_object(Class, ID, Properties, Values, Instance)
stringstream main, prop, val;
main << "save_object('" << req.class_name << "','" << req.id << "',['";
// Save names
for (int i = 0; i < req.properties.size(); i++)
{
if (i != req.properties.size() - 1)
{
prop << req.properties[i] << "','";
val << req.values[i] << "','";
}
else
{
prop << req.properties[i] << "'],['";
val << req.values[i] << "'],";
}
}
main << prop.str() << val.str() << " Instance)";
string query = main.str();
query.erase(std::remove(query.begin(), query.end(), '\n'), query.end());
if (SHOW_QUERIES)
cout << query << endl;
PrologQueryProxy bdgs = pl.query(query);
res.result = false;
string inst;
for(PrologQueryProxy::iterator it=bdgs.begin();it != bdgs.end(); it++)
{
PrologBindings bdg = *it;
inst = (bdg["Instance"].toString());
if (inst.find("#", 0) !=std::string::npos)
res.instance = inst.substr(inst.find("#", 0)+1);
else
res.instance = inst;
res.result = true;
}
return true;
}
bool RoboyMind::getObjectSRV(roboy_mind::srvGetObject::Request &req,roboy_mind::srvGetObject::Response &res)
{
// Query part for the object
// get_object(Properties, Values, Class, Instance)
stringstream main, prop, val;
main << "get_object(['";
// Save names
for (int i = 0; i < req.properties.size(); i++)
{
if (i != req.properties.size() - 1)
{
prop << req.properties[i] << "','";
val << req.values[i] << "','";
}
else
{
prop << req.properties[i] << "'],['";
val << req.values[i] << "'],";
}
}
main << prop.str() << val.str() << " Class, Instance)";
string query = main.str();
query.erase(std::remove(query.begin(), query.end(), '\n'), query.end());
if (SHOW_QUERIES)
cout << query << endl;
PrologQueryProxy bdgs = pl.query(query);
res.result = false;
string inst,cl;
for(PrologQueryProxy::iterator it=bdgs.begin();it != bdgs.end(); it++)
{
PrologBindings bdg = *it;
inst = (bdg["Instance"].toString());
if (inst.find("#", 0) !=std::string::npos)
res.instance = inst.substr(inst.find("#", 0)+1);
else
res.instance = inst;
cl = (bdg["Class"].toString());
if (cl.find("#", 0) !=std::string::npos)
res.class_name = cl.substr(cl.find("#", 0)+1);
else
res.instance = inst;
res.result = true;
}
return true;
}
// Constructor
RoboyMind::RoboyMind(ros::NodeHandle nh) : nh_(nh), priv_nh_("~")
{
// Service Servers
assert_property_service = nh_.advertiseService("/roboy_mind/assert_property",&RoboyMind::assertPropertySRV,this);
call_query_service = nh_.advertiseService("/roboy_mind/call_query",&RoboyMind::callQuerySRV,this);
check_property_service = nh_.advertiseService("/roboy_mind/check_property",&RoboyMind::checkPropertySRV,this);
check_query_service = nh_.advertiseService("/roboy_mind/check_query",&RoboyMind::checkQuerySRV,this);
create_instance_service = nh_.advertiseService("/roboy_mind/create_instance",&RoboyMind::createInstanceSRV,this);
find_instances_service = nh_.advertiseService("/roboy_mind/find_instances",&RoboyMind::findInstancesSRV,this);
show_instances_service = nh_.advertiseService("/roboy_mind/show_instances",&RoboyMind::showInstancesSRV,this);
show_properties_service = nh_.advertiseService("/roboy_mind/show_property",&RoboyMind::showPropertySRV,this);
show_property_value_service = nh_.advertiseService("/roboy_mind/show_property_value",&RoboyMind::showPropertyValueSRV,this);
save_object_service = nh_.advertiseService("/roboy_mind/save_object",&RoboyMind::saveObjectSRV,this);
get_object_service = nh_.advertiseService("/roboy_mind/get_object",&RoboyMind::getObjectSRV,this);
//nh.param<std::string>("/knowrob", knowrob, "http://knowrob.org/kb/knowrob.owl#");
nh.param<std::string>("/ontology_name", ontology_name, "http://knowrob.org/kb/knowrob.owl#");//"http://knowrob.org/kb/semRoom_semantic_map.owl#");
};
int main(int argc, char** argv)
{
ros::init(argc, argv, "reasoning_node");
ros::NodeHandle nh;
RoboyMind node(nh);
ROS_INFO("Reasoning node init successful");
ros::spin();
return 0;
} | [
"[email protected]"
] | |
ed64f45c28f951de479c33e460a48e64bb166e21 | d6b97209dce858d887937c787dead5c1a611724a | /treewidgetapp/main.cpp | 8b39f22bc87eddb217a0337aa2457d4ca4421868 | [] | no_license | ration/tdriver_tests | 9cef45479c0e18869b3172391f2c0e5e8a26f3fb | a5dba44ad8aeae668fef2c86d18489013ac37ad8 | refs/heads/master | 2021-01-16T00:18:00.301605 | 2012-04-26T04:43:25 | 2012-04-26T04:43:25 | 31,655,475 | 0 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 2,680 | cpp | /***************************************************************************
**
** Copyright (C) 2010 Nokia Corporation and/or its subsidiary(-ies).
** All rights reserved.
** Contact: Nokia Corporation ([email protected])
**
** This file is part of TDriver.
**
** If you have questions regarding the use of this file, please contact
** Nokia at [email protected] .
**
** This library is free software; you can redistribute it and/or
** modify it under the terms of the GNU Lesser General Public
** License version 2.1 as published by the Free Software Foundation
** and appearing in the file LICENSE.LGPL included in the packaging
** of this file.
**
****************************************************************************/
#include <QApplication>
/*Add following libraries to enable testabilityloading and testailiby if not already included */
#include <QtPlugin>
#include <QPluginLoader>
#include <QLibraryInfo>
#include "testabilityinterface.h" //this file needs to be copied to inc folder from qttas package
/*Endof adding files */
#include "mainwindow.h"
int main(int argc, char *argv[])
{
QApplication app(argc, argv);
TestabilityInterface* testabilityInterface;
/* In beginning of main file: activate testailiby plugin if available */
QString testabilityPlugin = "testability/testability";
QString testabilityPluginPostfix = ".dll";
#ifdef Q_OS_LINUX
testabilityPluginPostfix = ".so";
testabilityPlugin = "testability/libtestability";
#endif
#ifdef Q_WS_MAC
testabilityPluginPostfix = ".dylib";
testabilityPlugin = "testability/libtestability";
#endif
testabilityPlugin = QLibraryInfo::location(QLibraryInfo::PluginsPath)
+ QObject::tr("/") + testabilityPlugin + testabilityPluginPostfix;
QPluginLoader loader(testabilityPlugin.toLatin1().data());
QObject *plugin = loader.instance();
if (plugin) {
qDebug("Testability plugin loaded successfully!");
testabilityInterface = qobject_cast<TestabilityInterface *>(plugin);
if (testabilityInterface) {
qDebug("Testability interface obtained!");
testabilityInterface->Initialize();
} else {
qDebug("Failed to get testability interface!");
}
} else {
qDebug("Testability plugin %s load failed with error:%s",
testabilityPlugin.toLatin1().data(), loader.errorString().toLatin1().data());
}
/* Endof activate testailiby plugin if available */
MainWindow window;
#ifdef Q_OS_SYMBIAN
window.showFullScreen();
#else
window.show();
#endif //Q_OS_SYMBIAN
return app.exec();
}
| [
"[email protected]"
] | |
948b687793556797aa822c346f855c9749f61fc7 | 0874d0d24b689af0a30c5c7e37cf6993453bc3a5 | /Source/Library/Common/TextFile.class.cpp | 040e2d7c02a1b5f3263bdfbaa271d860578d8e79 | [
"LicenseRef-scancode-public-domain"
] | permissive | Alexis211/Melon | 908fcee95184f39b5cf3444994cd2e78fe17281d | 35de150f189ae7d5ec19f31eb32379e1ee389867 | refs/heads/master | 2016-09-06T01:35:39.565022 | 2014-10-28T12:30:56 | 2014-10-28T12:30:56 | 284,352 | 12 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 601 | cpp | #include "TextFile.class.h"
bool TextFile::write(String str, bool addnl) {
ByteArray a(str, m_encoding);
if (addnl) a += (u8int)'\n';
return File::write(a);
}
String TextFile::readLine(char separator) {
const u32int bufflen = 512;
String ret;
ByteArray temp;
while (1) {
temp.resize(bufflen);
u32int r = read(temp);
u32int l = r;
for (u32int i = 0; i < r; i++) {
if (temp[i] == separator) {
l = i;
temp.resize(i);
break;
}
}
ret += temp.toString(m_encoding);
if (l != r or r != bufflen) {
if (l != r) seek((r - l) - 1, SM_BACKWARD);
return ret;
}
}
}
| [
"[email protected]"
] | |
be21a758d63c8eb467983da43644f00a9838152f | cbe5a741d51e0290c0f225c85cbe7576c8c74c83 | /Dothi_Buoi2/chu_trinh_hamitor/Source.cpp | 99e4d020666462edef370b58d44a8f0dedc2fe53 | [] | no_license | nguyenthihaik61/thuat_toan_ung_dung | 48adce1b9acc1a23e028e3fd5441492dca29c58a | 4b8075619f8e84a9af93801925f75821251041ed | refs/heads/master | 2021-06-22T15:56:53.734562 | 2021-05-12T13:47:48 | 2021-05-12T13:47:48 | 217,668,010 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,030 | cpp |
#define _CRT_SECURE_NO_WARNINGS
#include<iostream>
#include<vector>
using namespace std;
vector <int> A[10001];
int N, M;
bool visited[10001];
int X[10001];
void input()
{
cin >> N >> M;
for (int i = 1; i <=M; i++)
{
int u, v;
cin >> u >> v;
A[u].push_back(v);
A[v].push_back(u);
}
}
void init()
{
for (int v = 1; v <=N ; v++)
{
visited[v] = false;
}
}
void solution()
{
for (int i = 1; i <= N; i++)
{
cout << X[i] << " ";
}
cout << endl;
}
bool checkAdj(int u, int v)
{
for (int i = 0; i < A[u].size(); i++)
{
if (A[u][i] == v) return true;
}
return false;
}
void TRY(int k)
{
for (int i = 0; i < A[X[k-1]].size(); i++)
{
int v = A[X[k - 1]][i];
if (!visited[v])
{
X[k] = v;
visited[v] = true;
if (k == N)
{
if (checkAdj(X[N], X[1]))
solution();
}
else
{
TRY(k + 1);
}
visited[v] = false;
}
}
}
void solve()
{
input();
init();
X[1] = 1;
visited[1] = true;
TRY(2);
}
int main()
{
freopen("input.txt", "r", stdin);
solve();
return 0;
} | [
"[email protected]"
] | |
b5d70f5d09da9bcf3b44cf4f9e3f5e9d06c3df5a | 6dadbe750a219f36f93bfe9822c36374eecad821 | /Library/Bee/artifacts/WebGL/il2cppOutput/cpp/GenericMethods7.cpp | 5cb6c579108a9d598542fa6b6b55e2913274ea2d | [] | no_license | pkrawat1/unity-exp | 017d15ddcc60b1a4622c4f2fac03776c172a8b4f | 2ceec4f03f954fe911dabb7fcfcd58a310c525a5 | refs/heads/master | 2023-08-12T22:16:02.628115 | 2021-10-19T13:12:34 | 2021-10-19T13:12:34 | 418,317,113 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,061,279 | cpp | #include "pch-cpp.hpp"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
#include <limits>
template <typename R>
struct VirtualFuncInvoker0
{
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);
}
};
struct InterfaceActionInvoker0
{
typedef void (*Action)(void*, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
((Action)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename T1>
struct InterfaceActionInvoker1
{
typedef void (*Action)(void*, T1, const RuntimeMethod*);
static inline void Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj, T1 p1)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
((Action)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename R>
struct InterfaceFuncInvoker0
{
typedef R (*Func)(void*, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
return ((Func)invokeData.methodPtr)(obj, invokeData.method);
}
};
template <typename R, typename T1>
struct InterfaceFuncInvoker1
{
typedef R (*Func)(void*, T1, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj, T1 p1)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
return ((Func)invokeData.methodPtr)(obj, p1, invokeData.method);
}
};
template <typename R, typename T1, typename T2>
struct InterfaceFuncInvoker2
{
typedef R (*Func)(void*, T1, T2, const RuntimeMethod*);
static inline R Invoke (Il2CppMethodSlot slot, RuntimeClass* declaringInterface, RuntimeObject* obj, T1 p1, T2 p2)
{
const VirtualInvokeData& invokeData = il2cpp_codegen_get_interface_invoke_data(slot, obj, declaringInterface);
return ((Func)invokeData.methodPtr)(obj, p1, p2, invokeData.method);
}
};
// UnityEngine.UIElements.UQueryState`1/ActionQueryMatcher<System.Object>
struct ActionQueryMatcher_tB76860A856401075A2CF71D45AC72A9C0F1BB99E;
// UnityEngine.UIElements.UQueryState`1/ActionQueryMatcher<UnityEngine.UIElements.VisualElement>
struct ActionQueryMatcher_tBA08813774EDD8920F40BFFC2F27B8329C7923DD;
// System.Action`1<UnityEngine.UIElements.BaseVisualElementPanel>
struct Action_1_tF0C1AFCCE9CE63382F43540DC0DA04A8939A8A53;
// System.Action`1<System.Boolean>
struct Action_1_t10DCB0C07D0D3C565CEACADC80D1152B35A45F6C;
// System.Action`1<UnityEngine.Camera>
struct Action_1_t268986DA4CF361AC17B40338506A83AFB35832EA;
// System.Action`1<UnityEngine.UIElements.IPanel>
struct Action_1_tE55F8AC1EEC45D0C976E56B2950D65EC814C06E6;
// System.Action`1<System.IntPtr>
struct Action_1_t2DF1ED40E3084E997390FF52F462390882271FE2;
// System.Action`1<UnityEngine.Material>
struct Action_1_t996DFD52B4BDA6CBE8058C13167C4D2B8C612CAA;
// System.Action`1<UnityEngine.UIElements.MeshGenerationContext>
struct Action_1_t3DC3411926243F1DB9C330F8E105B904E38C1A0B;
// System.Action`1<System.Object>
struct Action_1_t6F9EB113EB3F16226AEF811A2744F4111C116C87;
// System.Action`2<UnityEngine.UIElements.VisualElement,System.Object>
struct Action_2_t481D6C6BCDB085CB7BE1AA1DBD81F4DC0C04D1F2;
// System.Action`2<UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.Experimental.StyleValues>
struct Action_2_tCFAD9DC5CF83678682A1102DCD1B12DE9FCA395A;
// System.Action`3<UnityEngine.Timeline.TimelineClip,UnityEngine.GameObject,UnityEngine.Playables.Playable>
struct Action_3_t3638A0A401CA68AF6FECFB956B602BBF7B9EFA72;
// System.Action`3<UnityEngine.Timeline.TrackAsset,UnityEngine.GameObject,UnityEngine.Playables.Playable>
struct Action_3_t8A9161BC98843636E3BF066B37CBCC15C593B73E;
// UnityEngine.UIElements.UIR.BasicNode`1<UnityEngine.UIElements.UIR.TextureEntry>
struct BasicNode_1_t7B4D545DCD6949B2E1C85D63DF038E44602F7DDB;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Globalization.CultureInfo>
struct Dictionary_2_t9FA6D82CAFC18769F7515BB51D1C56DAE09381C3;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Threading.Tasks.Task>
struct Dictionary_2_t403063CE4960B4F46C688912237C6A27E550FF55;
// System.Collections.Generic.Dictionary`2<System.Int32Enum,System.Object>
struct Dictionary_2_t514396B90715EDD83BB0470C76C2F426F9381C71;
// System.Collections.Generic.Dictionary`2<System.String,System.Globalization.CultureInfo>
struct Dictionary_2_tE1603CE612C16451D1E56FF4D4859D4FE4087C28;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.UIElements.StyleComplexSelector>
struct Dictionary_2_t00B3CBC13D1439C8660D9FC33442C5620590706F;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.UIElements.StyleSheets.StylePropertyValue>
struct Dictionary_2_t645C7B1DAE2D839B52A5E387C165CE13D5465B00;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.UIElements.VisualElement>
struct Dictionary_2_t41165BF747F041590086BE39A59BE164430A3CEF;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.UIElements.StyleComplexSelector/PseudoStateData>
struct Dictionary_2_t29D782BF5D0A26D11A04865B4306B86575506834;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StyleSheets.StylePropertyId,UnityEngine.UIElements.StylePropertyAnimationSystem/Values>
struct Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7;
// System.Collections.Generic.Dictionary`2<System.Type,UnityEngine.Timeline.TrackBindingTypeAttribute>
struct Dictionary_2_tF0368534E8881FC0469B58E4901741C5B0CC1D79;
// System.Collections.Generic.Dictionary`2<System.Type,UnityEngine.UIElements.VisualElement/TypeData>
struct Dictionary_2_t4055F6540F36F21F9FEDAFB92D8E0089B38EBBC8;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32>
struct Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574;
// System.Func`1<System.Threading.Tasks.Task/ContingentProperties>
struct Func_1_tD59A12717D79BFB403BF973694B1BE5B85474BD1;
// System.Func`2<System.Single,System.Single>
struct Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2;
// System.Func`2<UnityEngine.UIElements.VisualElement,System.Object>
struct Func_2_t9AAA83BE20528E7FBB1DCCFF8E9640E7061D5BE3;
// System.Func`2<UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.Experimental.StyleValues>
struct Func_2_t87FB5A45506EB8DF671CF8BEB31A0FD5A00FA227;
// System.Func`3<System.String,System.Boolean,System.Boolean>
struct Func_3_t62BC9D925DCAC8F5784BA97C793F4E593496CDA7;
// System.Func`3<System.String,System.Int32,System.Int32>
struct Func_3_t0620ECF6AB73866242850ABCE518B069D201DA79;
// System.Func`3<System.String,System.Int32Enum,System.Int32Enum>
struct Func_3_t538A8E697534A282316BC2DF71DE83E68360C8B9;
// System.Func`3<System.String,System.Int64,System.Int64>
struct Func_3_tD3C5141B184A528ABF7649D429906DA08C68E4A7;
// System.Func`3<System.String,System.Object,System.Object>
struct Func_3_tBFBF2C1D5A7EE5485A61C55BA580F7AF50AABBF0;
// System.Func`3<System.String,System.Single,System.Single>
struct Func_3_t5328A430FC4208B44C52E4E89DC5F686DE6A6A1B;
// System.Func`4<System.Object,System.Object,System.Single,System.Object>
struct Func_4_t20528E18B451AECBBF66363BFFF0BE47D521318F;
// System.Func`4<UnityEngine.UIElements.Experimental.StyleValues,UnityEngine.UIElements.Experimental.StyleValues,System.Single,UnityEngine.UIElements.Experimental.StyleValues>
struct Func_4_t93A2D1B3300415C1167923C629725F6A8758E6B5;
// UnityEngine.UIElements.UIR.Utility/GPUBuffer`1<System.UInt16>
struct GPUBuffer_1_tA865630D1AFA976A50A92C4ACE0243A78520BDC7;
// UnityEngine.UIElements.UIR.Utility/GPUBuffer`1<UnityEngine.UIElements.Vertex>
struct GPUBuffer_1_tD1DC0573556845223680E17430EFF317DDA4A5AC;
// System.Collections.Generic.IComparer`1<UnityEngine.UIElements.VisualTreeAsset/UsingEntry>
struct IComparer_1_tFAD3AE9FE3CE1FB3CBB781C55DC57C986D71521E;
// System.Collections.Generic.IEnumerable`1<UnityEngine.Timeline.TrackAsset>
struct IEnumerable_1_tCF360FA8155395D7F2E3092E355BE18C4A37F7E0;
// System.Collections.Generic.IEqualityComparer`1<UnityEngine.UIElements.StyleSheets.StylePropertyId>
struct IEqualityComparer_1_t341DBC625B94A179D2F2C3E3CF45C76E281F4612;
// UnityEngine.UIElements.IStyleValue`1<UnityEngine.Color>
struct IStyleValue_1_t8E602724F08CCD09684BFAB341CE20B029B90C61;
// UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Cursor>
struct IStyleValue_1_t1774C3328C4606BECAC1D6AC39FE101AAD09A588;
// UnityEngine.UIElements.IStyleValue`1<System.Int32>
struct IStyleValue_1_t759DE12491F28A1314E1391C054C0751E6F2AE5D;
// UnityEngine.UIElements.IStyleValue`1<System.Int32Enum>
struct IStyleValue_1_tA5FD40262C6FAE001F449A254109EE92CF34C82F;
// UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Length>
struct IStyleValue_1_t108FCAA674CEF45D92E496EA3B258DD2D3BC2950;
// UnityEngine.UIElements.IStyleValue`1<System.Object>
struct IStyleValue_1_t16A5DC766A6291B26C6C37FE5183C62625136585;
// UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Rotate>
struct IStyleValue_1_tE245E2034FAF975F9107DAA3D480DABD36D065DE;
// UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Scale>
struct IStyleValue_1_t60B64B8F2AABFE93E9F980903FA235A25EEE6AC2;
// UnityEngine.UIElements.IStyleValue`1<System.Single>
struct IStyleValue_1_t1DB43353EC06ED52600D61657BBD26EF81CE5B6D;
// UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.TextShadow>
struct IStyleValue_1_tA3635C4407421A9C31ECDFD4F63804EE7D57AF43;
// UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.TransformOrigin>
struct IStyleValue_1_t824116821CB88294640F85D02E205AC5F157F4FF;
// UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Translate>
struct IStyleValue_1_t75C345274538150C05DDA28E113AD0B691730A17;
// System.Collections.Generic.Dictionary`2/KeyCollection<UnityEngine.UIElements.StyleSheets.StylePropertyId,UnityEngine.UIElements.StylePropertyAnimationSystem/Values>
struct KeyCollection_tAE1CD1CE327D07F072532A89E6854F2C33EB014A;
// System.Collections.Generic.LinkedList`1<UnityEngine.UIElements.UIR.UIRenderDevice/DeviceToFree>
struct LinkedList_1_t09F6FB09C766455615BBF59716D285304C49E0E7;
// UnityEngine.UIElements.UIR.LinkedPool`1<UnityEngine.UIElements.UIR.MeshHandle>
struct LinkedPool_1_tD8A175EE023C8220138E51E722F4A20ACE9CA851;
// UnityEngine.UIElements.UQueryState`1/ListQueryMatcher`1<System.Object,System.Object>
struct ListQueryMatcher_1_t4D10BEF648526B008BEB75C8576A7D1EBFD73A83;
// UnityEngine.UIElements.UQueryState`1/ListQueryMatcher`1<System.Object,UnityEngine.UIElements.VisualElement>
struct ListQueryMatcher_1_tC447E3396770813CE332360F6EECEEFB6B51FA69;
// UnityEngine.UIElements.UQueryState`1/ListQueryMatcher`1<UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.VisualElement>
struct ListQueryMatcher_1_t7F21A0BB6BC47F1797366366A8E33731906C2940;
// System.Collections.Generic.List`1<System.Collections.Generic.KeyValuePair`2<UnityEngine.PropertyName,System.Object>>
struct List_1_t60F39D768DAD2345527AD3EE73FAB2667DF4F260;
// System.Collections.Generic.List`1<System.Collections.Generic.List`1<ClipperLib.IntPoint>>
struct List_1_t5FC3329744B133EEDF6D1F91F711F3DB16EBD13D;
// System.Collections.Generic.List`1<System.Collections.Generic.List`1<UnityEngine.UIElements.UIR.UIRenderDevice/AllocToFree>>
struct List_1_tB86898E2E533634C35EC58EC5DAE3353038A9210;
// System.Collections.Generic.List`1<System.Collections.Generic.List`1<UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate>>
struct List_1_tA79C35FB5E50135962B53960CB758B9262700632;
// System.Collections.Generic.List`1<UnityEngine.UIElements.EasingFunction>
struct List_1_tE7FB077B3CEA6371A27F72CC60962491AB71490B;
// System.Collections.Generic.List`1<UnityEngine.Timeline.IMarker>
struct List_1_tB481045C42962DD282E8A89B2AF0246A4042EADF;
// System.Collections.Generic.List`1<UnityEngine.UIElements.Experimental.IValueAnimationUpdate>
struct List_1_t96E9133B70FB6765E6B138E810D33E18901715DA;
// System.Collections.Generic.List`1<System.Object>
struct List_1_tA239CB83DE5615F348BB0507E45F490F4F7C9A8D;
// System.Collections.Generic.List`1<UnityEngine.UIElements.UIR.RenderChainTextEntry>
struct List_1_t3ADC2CEE608F7E0043EBE4FD425E6C9AE43E19CC;
// System.Collections.Generic.List`1<UnityEngine.UIElements.RuleMatcher>
struct List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC;
// System.Collections.Generic.List`1<UnityEngine.ScriptableObject>
struct List_1_tF941E9C3FEB6F1C2D20E73A90AA7F6319EB3F828;
// System.Collections.Generic.List`1<System.String>
struct List_1_tF470A3BE5C1B5B68E1325EF3F109D172E60BD7CD;
// System.Collections.Generic.List`1<UnityEngine.UIElements.StylePropertyName>
struct List_1_tD6F1685FEE5A196B3002ACC649A1DF5C65162268;
// System.Collections.Generic.List`1<UnityEngine.UIElements.StyleSelectorPart>
struct List_1_t85FF16594D5F70EECC5855882558F8E26EF6BAFF;
// System.Collections.Generic.List`1<UnityEngine.UIElements.StyleSheet>
struct List_1_tEA16F82F7871418E28EB6F551D77A8AD9F2E337F;
// System.Collections.Generic.List`1<UnityEngine.UIElements.TimeValue>
struct List_1_t437B6C3879E969156A381BDC3C459CF809D39DDF;
// System.Collections.Generic.List`1<UnityEngine.Timeline.TimelineClip>
struct List_1_tD78196B4DE777C4B74ADAD24051A9978F5191506;
// System.Collections.Generic.List`1<UnityEngine.Timeline.TrackAsset>
struct List_1_t6908BEEFB57470CB30420983896AA06BFB8796F0;
// System.Collections.Generic.List`1<UnityEngine.UIElements.VisualElement>
struct List_1_t6115BBE78FE9310B180A2027321DF46F2A06AC95;
// System.Collections.Generic.List`1<UnityEngine.UIElements.StylePropertyAnimationSystem/Values>
struct List_1_t491E344573B9D6F61E36AF56132B7412453928C9;
// System.Collections.Generic.List`1<UnityEngine.UIElements.TemplateAsset/AttributeOverride>
struct List_1_t70EE7982F45810D4B024CF720D910E67974A3094;
// UnityEngine.UIElements.ObjectPool`1<UnityEngine.UIElements.Experimental.ValueAnimation`1<System.Object>>
struct ObjectPool_1_t8AC25F7642B86DC900C1E5BB4FF5DDB43900D6F4;
// UnityEngine.UIElements.ObjectPool`1<UnityEngine.UIElements.Experimental.ValueAnimation`1<UnityEngine.UIElements.Experimental.StyleValues>>
struct ObjectPool_1_t048E004E7532AED8FD10569876C6065B7527D2AE;
// System.Predicate`1<System.Object>
struct Predicate_1_t8342C85FF4E41CD1F7024AC0CDC3E5312A32CB12;
// System.Predicate`1<System.Threading.Tasks.Task>
struct Predicate_1_t7F48518B008C1472339EEEBABA3DE203FE1F26ED;
// UnityEngine.UIElements.StyleDataRef`1/RefCounted<UnityEngine.UIElements.InheritedData>
struct RefCounted_t6B975CD3D06E8D955346FC0D66E8F6E449D49A44;
// UnityEngine.UIElements.StyleDataRef`1/RefCounted<UnityEngine.UIElements.LayoutData>
struct RefCounted_t0E133AD36715877AE1CE72539A0199B4D3AA8CD1;
// UnityEngine.UIElements.StyleDataRef`1/RefCounted<UnityEngine.UIElements.RareData>
struct RefCounted_t81BCBAE57D930C934CF7A439452D65303AC6A8CD;
// UnityEngine.UIElements.StyleDataRef`1/RefCounted<UnityEngine.UIElements.TransformData>
struct RefCounted_t78303B1CD3D08C664ABB15EBD7C882DA3E06CF7D;
// UnityEngine.UIElements.StyleDataRef`1/RefCounted<UnityEngine.UIElements.TransitionData>
struct RefCounted_tA9FB4D63A1064BD322AFDFCD70319CB384C057D9;
// UnityEngine.UIElements.StyleDataRef`1/RefCounted<UnityEngine.UIElements.VisualData>
struct RefCounted_t812D790A2C787F18230F9234F6C9B84D4AC1A85A;
// System.Buffers.SpanAction`2<System.Char,System.ValueTuple`3<System.Object,System.Int32,System.Int32>>
struct SpanAction_2_t65B015FEFE1F64814AC2EFA0E19A38B1CFC53178;
// System.Buffers.SpanAction`2<System.Char,System.ValueTuple`5<System.IntPtr,System.Int32,System.IntPtr,System.Int32,System.Boolean>>
struct SpanAction_2_t84FDFFEECCC96A9A407DCB490E60340E38185947;
// System.Buffers.SpanAction`2<System.Char,System.Object>
struct SpanAction_2_t0CB19FBAD63F42C01432B842C5169FC10C1777E3;
// System.Threading.Tasks.Task`1<System.Boolean>
struct Task_1_t824317F4B958F7512E8F7300511752937A6C6043;
// System.Threading.Tasks.Task`1<System.Int32>
struct Task_1_t4C228DE57804012969575431CFF12D57C875552D;
// System.Threading.Tasks.Task`1<System.Object>
struct Task_1_t0C4CD3A5BB93A184420D73218644C56C70FDA7E2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<UnityEngine.UIElements.Background>
struct TransitionEventsFrameState_tE3B03C5A4D3A9B62395A67012747638ADE7B8D2D;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<UnityEngine.Color>
struct TransitionEventsFrameState_tC1DACCA9274641DD267223338E7C026D4CF520AC;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<UnityEngine.UIElements.Cursor>
struct TransitionEventsFrameState_tE02BB17F313986E594A2CEC2FFE45236E28672B2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<UnityEngine.UIElements.FontDefinition>
struct TransitionEventsFrameState_t2B8264420B693D76C74F99F305197870C62C10F4;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<System.Int32>
struct TransitionEventsFrameState_tC8FEB488506DC99B874A454BED371793598879E9;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<UnityEngine.UIElements.Length>
struct TransitionEventsFrameState_tFBFEC4A6BE1900A8D6115CD438F3CCC15A0DBCE9;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<System.Object>
struct TransitionEventsFrameState_tE30358B7263E3BE53EB8E856D7B0E1980F1AD855;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<UnityEngine.UIElements.Rotate>
struct TransitionEventsFrameState_t9DC16C7535A4271EA0FD763A64CD7CF84670EC64;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<UnityEngine.UIElements.Scale>
struct TransitionEventsFrameState_t25D5D3420391A40A0B978B0D5CA13F775283274E;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<System.Single>
struct TransitionEventsFrameState_t864A52D0F7726A4F4C2C667BCB56E8A745F7340C;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<UnityEngine.UIElements.TextShadow>
struct TransitionEventsFrameState_t896507B4A758D8F131A06984765BA0F57C8939A2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<UnityEngine.UIElements.TransformOrigin>
struct TransitionEventsFrameState_t7FB3FD474018D429F5F1EE705EF9ADA6F197EDEF;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<UnityEngine.UIElements.Translate>
struct TransitionEventsFrameState_t3F9A8EB2B33780D3F2037BFEED0A3C6A03B03FEC;
// UnityEngine.UIElements.Experimental.ValueAnimation`1<System.Object>
struct ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B;
// UnityEngine.UIElements.Experimental.ValueAnimation`1<UnityEngine.UIElements.Experimental.StyleValues>
struct ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC;
// System.Collections.Generic.Dictionary`2/ValueCollection<UnityEngine.UIElements.StyleSheets.StylePropertyId,UnityEngine.UIElements.StylePropertyAnimationSystem/Values>
struct ValueCollection_t04D5F77EBC72D81BB7FE7199D6C9DC65DEB60064;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.Background>
struct Values_1_t19A1E2B4752BCDF06B5D68597FF7E74704C6F99F;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.Color>
struct Values_1_t49C0EEE75C4A46F518DA157D93141A5AA673B5E0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.Cursor>
struct Values_1_t669A6AFCA17FE6CB7D673FED4589CEDC1F145A98;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.FontDefinition>
struct Values_1_t45BEBFF589B2E0FB589C839603CF54DAFA8EE2B7;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<System.Int32>
struct Values_1_tF2422B8F8347145D2FE398C58F2EF1EAB96567A5;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.Length>
struct Values_1_t988DC70C892CC8E803830C5C3A4370F5177CD9A6;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<System.Object>
struct Values_1_t34227637D0C93F730700DFD895768AF8F8C7FF8D;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.Rotate>
struct Values_1_t1B84258FDB622ABECA26BA9E2E8F638E1B6B213F;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.Scale>
struct Values_1_tD710D214E4D407A033AE57CE091D4C4FBB293714;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<System.Single>
struct Values_1_t0E31EAA5A590859BBD863FE74A3208C8F5722AA1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.TextShadow>
struct Values_1_tFB112CD52331C038F6B928FEAFAB19A06FD2F62C;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.TransformOrigin>
struct Values_1_t4B3725FE6B9D8A60439FC42ABC27E2FAE91ACBA5;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.Translate>
struct Values_1_tF515CA326AF84CBBA1A40F1C76BC6D39AA409215;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.Background>[]
struct EmptyDataU5BU5D_t4FC6419C796BBADFEC77D9CB97A3FB7B1C6D5CB8;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.Color>[]
struct EmptyDataU5BU5D_tDFE3104887D7AEB406BC646123D7C8AA698EB58A;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.Cursor>[]
struct EmptyDataU5BU5D_t86ACC6560CF2B91DD5D368119A8F1F939BBF272D;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.FontDefinition>[]
struct EmptyDataU5BU5D_t568C72D6625FA05F854FF86F02910C531D98B72E;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<System.Int32>[]
struct EmptyDataU5BU5D_t920355EC41DECEE4E1D5688CEA971923802FC9A3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.Length>[]
struct EmptyDataU5BU5D_tE2C14BF5968870FDDD993014F93FDE3FC5572837;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<System.Object>[]
struct EmptyDataU5BU5D_t543192ACC732EF0DB4B419407C24CD12260A485B;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.Rotate>[]
struct EmptyDataU5BU5D_t4EA7859B72A26B20006E0BD02EC63611C4C71485;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.Scale>[]
struct EmptyDataU5BU5D_tF2D26ADE6FCC1E97FB2FFC1DC56D63F08E711A3C;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<System.Single>[]
struct EmptyDataU5BU5D_t60D6EDC5438323017497721F3A8E4A0376F2B741;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.TextShadow>[]
struct EmptyDataU5BU5D_t8EE2FFAAC9B7C301CF4690109183A2EFDFC5A20F;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.TransformOrigin>[]
struct EmptyDataU5BU5D_tB3A736D4DE7E747B7C1B6CA7B36EB41FA6207653;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.Translate>[]
struct EmptyDataU5BU5D_tFD0240910F0FF75CC94A141EDE346043BD9C179C;
// System.Collections.Generic.Dictionary`2/Entry<UnityEngine.UIElements.StyleSheets.StylePropertyId,UnityEngine.UIElements.StylePropertyAnimationSystem/Values>[]
struct EntryU5BU5D_t524C33EA8D08013B8734724ABCA925485CF3B799;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.Background>[]
struct StyleDataU5BU5D_tF87CDE51588E78D4C87C144731581FB5284776E0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.Color>[]
struct StyleDataU5BU5D_t73BFD33363F897414B879236BE0A0DCA6962B9AB;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.Cursor>[]
struct StyleDataU5BU5D_t686F1C6A6AF575A38AF7C9CB30E2EDA62E0A3F2E;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.FontDefinition>[]
struct StyleDataU5BU5D_tD406BDE6B313334D7A7241DDEA636226CC9C0043;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<System.Int32>[]
struct StyleDataU5BU5D_tDA10AD1016A9574B39F73BE1DBE2E3A55720EAA9;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.Length>[]
struct StyleDataU5BU5D_t8ACFC9D6C572747CB5326B98E34DEE3AC989D876;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<System.Object>[]
struct StyleDataU5BU5D_t93B88656D82161E5A58053D74E6C823720B88361;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.Rotate>[]
struct StyleDataU5BU5D_tBB18CE54D6B9B54229E01AFF7CCB44B8305F2386;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.Scale>[]
struct StyleDataU5BU5D_t988DBB7FAB3D7D4E114C94A5CF2E305E3FFB2A7F;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<System.Single>[]
struct StyleDataU5BU5D_t73D276E94B9F65AFF0A22B0D465D05D5E9438F5E;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.TextShadow>[]
struct StyleDataU5BU5D_t597C3C3BF0BFFC87AB6037E85E0829D999602263;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.TransformOrigin>[]
struct StyleDataU5BU5D_tDCCCED3D71A0A84CDB77E5222463121D4EB611CC;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.Translate>[]
struct StyleDataU5BU5D_tAD21796096D8CBCE199118430F1C659AA1DFB822;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.Background>[]
struct TimingDataU5BU5D_t0DDECCB612303E94B577E5978AB4B36B5192AFB1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.Color>[]
struct TimingDataU5BU5D_t03C8C38B8DBF52B9A23FB2B77BEC41E63D4A3994;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.Cursor>[]
struct TimingDataU5BU5D_t69EAE6B456DFA123ADF7DEAA56717BEFA7407C31;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.FontDefinition>[]
struct TimingDataU5BU5D_t45DAD27FEA03547B7581715461816FA37E7EC651;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<System.Int32>[]
struct TimingDataU5BU5D_t9253C6811381B1932706D115D067841C7175C077;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.Length>[]
struct TimingDataU5BU5D_tA5BE0E019AB587A0072682D5535D2295EC6F04B9;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<System.Object>[]
struct TimingDataU5BU5D_t86A2877F21E58289C845548B2244BFCA090918B1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.Rotate>[]
struct TimingDataU5BU5D_tE963FB40D15F6761CC687300F7A3EFCD58A8505A;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.Scale>[]
struct TimingDataU5BU5D_t0BCD78985159E6EF1D974E34B209EDE880E06269;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<System.Single>[]
struct TimingDataU5BU5D_t370B0476A79A76456F04BA6664A963CC579E9CD0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.TextShadow>[]
struct TimingDataU5BU5D_tE92E1403336542C4CF4B76824A22545D0EB14E14;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.TransformOrigin>[]
struct TimingDataU5BU5D_t1C0E9B6D937D57C27438BFA33BC2DB905EE4973E;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.Translate>[]
struct TimingDataU5BU5D_t634CA6261A1EDA23867D38722881D8D9610065E3;
// UnityEngine.UIElements.Background[]
struct BackgroundU5BU5D_t29762095DD694E79A85A59135735FF02E54C4B46;
// System.Byte[]
struct ByteU5BU5D_tA6237BF417AE52AD70CFB4EF24A7A82613DF9031;
// System.Char[]
struct CharU5BU5D_t799905CF001DD5F13F7DBB310181FC4D8B7D0AAB;
// UnityEngine.Color[]
struct ColorU5BU5D_t612261CF293F6FFC3D80AB52259FF0DC2B2CC389;
// UnityEngine.Color32[]
struct Color32U5BU5D_t38116C3E91765C4C5726CE12C77FAD7F9F737259;
// UnityEngine.UIElements.ComputedTransitionProperty[]
struct ComputedTransitionPropertyU5BU5D_t25B9E78F5276CDA297C8215C316452CAB8219E82;
// UnityEngine.UIElements.Cursor[]
struct CursorU5BU5D_t56D2D31C350B8CE5B9398F24B50E81B7842D309C;
// System.Delegate[]
struct DelegateU5BU5D_tC5AB7E8F745616680F337909D3A8E6C722CDF771;
// UnityEngine.UIElements.StyleSheets.Dimension[]
struct DimensionU5BU5D_t1EE1B3F9368D444E779CAB3E1CBD9959F8762F4B;
// System.Double[]
struct DoubleU5BU5D_tCC308475BD3B8229DB2582938669EF2F9ECC1FEE;
// UnityEngine.UIElements.EasingFunction[]
struct EasingFunctionU5BU5D_t3EEBBFFAD92EA74C3960D5F78D2A98BCEEA62E49;
// System.Enum[]
struct EnumU5BU5D_t6106A94708E3435454078BF14FA50152B7301912;
// UnityEngine.UIElements.FontDefinition[]
struct FontDefinitionU5BU5D_t31BDC3E2D72918B36F815F95F7CBA1F057E3DA39;
// UnityEngine.UIElements.IVisualTreeUpdater[]
struct IVisualTreeUpdaterU5BU5D_t9E9D948BC4F327DA519FEB2BCEC12FB7FD7C59E8;
// System.Int32[]
struct Int32U5BU5D_t19C97395396A72ECAF310612F0760F165060314C;
// System.IntPtr[]
struct IntPtrU5BU5D_tFD177F8C806A6921AD7150264CCC62FA00CAD832;
// UnityEngine.UIElements.Length[]
struct LengthU5BU5D_t6E92E14664BA86924824C32A0BBE10AEC53C7FAE;
// UnityEngine.TextCore.Text.LineInfo[]
struct LineInfoU5BU5D_t37598F2175B291797270D1161DC29B6296FB169D;
// UnityEngine.TextCore.Text.LinkInfo[]
struct LinkInfoU5BU5D_tB7EB23E47AF29CCBEC884F9D0DB95BC97F62AE51;
// UnityEngine.TextCore.Text.MeshInfo[]
struct MeshInfoU5BU5D_t3DF8B75BF4A213334EED197AD25E432212894AC6;
// System.Object[]
struct ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918;
// UnityEngine.Object[]
struct ObjectU5BU5D_tD4BF1BEC72A31DF6611C0B8FA3112AF128FC3F8A;
// UnityEngine.TextCore.Text.PageInfo[]
struct PageInfoU5BU5D_tFEA2CF88695491CFC2F2A2EF6BDCC56E52B0A6D4;
// UnityEngine.Playables.PlayableBinding[]
struct PlayableBindingU5BU5D_tC50C3F27A8E4246488F7A5998CAABAC4811A92CD;
// UnityEngine.UIElements.Rotate[]
struct RotateU5BU5D_tD482C518713DEC5763C34C827A9B6DB565776772;
// UnityEngine.UIElements.RuleMatcher[]
struct RuleMatcherU5BU5D_t0135EA06151E72D04414F3EAF9420CB85EE2236C;
// UnityEngine.UIElements.StyleSheets.ScalableImage[]
struct ScalableImageU5BU5D_t8C989174900062AED19A057FDCF0529F8C594A52;
// UnityEngine.UIElements.Scale[]
struct ScaleU5BU5D_tE608175710457D7343DD849244BF59B58157F0EF;
// System.Single[]
struct SingleU5BU5D_t89DEFE97BCEDB5857010E79ECE0F52CF6E93B87C;
// System.Diagnostics.StackTrace[]
struct StackTraceU5BU5D_t32FBCB20930EAF5BAE3F450FF75228E5450DA0DF;
// System.String[]
struct StringU5BU5D_t7674CD946EC0CE7B3AE0BE70E6EE85F2ECD9F248;
// UnityEngine.UIElements.StyleComplexSelector[]
struct StyleComplexSelectorU5BU5D_tF7B5239DE9BF477DECF97EFBA7CB1D71C45DB857;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[]
struct StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359;
// UnityEngine.UIElements.StylePropertyName[]
struct StylePropertyNameU5BU5D_t531626CF806E3F3D348D1F38A9109767014C35F8;
// UnityEngine.UIElements.StyleRule[]
struct StyleRuleU5BU5D_t7897A39D88CA043B2BFB5B28C53B41564EBA3AF3;
// UnityEngine.UIElements.StyleSelector[]
struct StyleSelectorU5BU5D_t11A633455FC601606B3DF3CEDDDAB1625B54708D;
// UnityEngine.UIElements.StyleSelectorPart[]
struct StyleSelectorPartU5BU5D_tBA574FB3E75E94E52874FDB7B05B9048E8A5421B;
// UnityEngine.UIElements.StyleValueHandle[]
struct StyleValueHandleU5BU5D_t66B7732469E9E30B1FB9A6E386315DAB36914ADE;
// UnityEngine.TextCore.Text.TextElementInfo[]
struct TextElementInfoU5BU5D_tEC28C9B72883EE21AA798913497C69E179A15C4E;
// UnityEngine.UIElements.TextShadow[]
struct TextShadowU5BU5D_tF37C87EBD3D8745BEDABCE2EA499DE16C15B5D8C;
// UnityEngine.UIElements.TimeValue[]
struct TimeValueU5BU5D_t3EB79C5975D39A0E711250FD8A9547F5312746DE;
// UnityEngine.Timeline.TimelineClip[]
struct TimelineClipU5BU5D_t37945156A55BC896C442C4FE59198216769A4E64;
// UnityEngine.Timeline.TrackAsset[]
struct TrackAssetU5BU5D_tE6935AFD32D0BE4B0C69D1CCE96B55D383BCF88C;
// UnityEngine.UIElements.TransformOrigin[]
struct TransformOriginU5BU5D_t0BDBC9C8F1888009152284DC2903B3C289F826DA;
// UnityEngine.UIElements.Translate[]
struct TranslateU5BU5D_t9199DFD72A8EC5FA4C33D75E5F85242F9F97E358;
// System.Type[]
struct TypeU5BU5D_t97234E1129B564EB38B8D85CAC2AD8B5B9522FFB;
// System.UInt32[]
struct UInt32U5BU5D_t02FBD658AD156A17574ECE6106CF1FBFCC9807FA;
// System.UInt64[]
struct UInt64U5BU5D_tAB1A62450AC0899188486EDB9FC066B8BEED9299;
// UnityEngine.Vector2[]
struct Vector2U5BU5D_tFEBBC94BCC6C9C88277BA04047D2B3FDB6ED7FDA;
// UnityEngine.Vector3[]
struct Vector3U5BU5D_tFF1859CCE176131B909E2044F76443064254679C;
// UnityEngine.UIElements.VisualElement[]
struct VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF;
// UnityEngine.TextCore.Text.WordInfo[]
struct WordInfoU5BU5D_tAD74C9720883D7BB229A20FFAE9EFD2CF9963F7B;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values[]
struct ValuesU5BU5D_t5332999C48416329B2A447FCD8C71113DDB459EA;
// UnityEngine.UIElements.StyleSheet/ImportStruct[]
struct ImportStructU5BU5D_t42D231FD5BB4B620965D7BED87D56D531B4C7AE9;
// System.Decimal/DecCalc/PowerOvfl[]
struct PowerOvflU5BU5D_t8BB6F43AF19F1F7C7558815B4684875BC320735B;
// System.Action
struct Action_tD00B0A84D7945E50C2DFFC28EFEE6ED44ED2AD07;
// UnityEngine.AnimationClip
struct AnimationClip_t00BD2F131D308A4AD2C6B0BF66644FC25FECE712;
// UnityEngine.AnimationCurve
struct AnimationCurve_tCBFFAAD05CEBB35EF8D8631BD99914BE1A6BB354;
// System.ArgumentNullException
struct ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129;
// System.ArgumentOutOfRangeException
struct ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F;
// UnityEngine.EventSystems.BaseRaycaster
struct BaseRaycaster_t7DC8158FD3CA0193455344379DD5FF7CD5F1F832;
// UnityEngine.UIElements.BaseVisualElementPanel
struct BaseVisualElementPanel_tE3811F3D1474B72CB6CD5BCEECFF5B5CBEC1E303;
// System.Reflection.Binder
struct Binder_t91BFCE95A7057FADF4D8A1A342AFE52872246235;
// System.Byte
struct Byte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3;
// System.Globalization.Calendar
struct Calendar_t0A117CC7532A54C17188C2EFEA1F79DB20DF3A3B;
// System.Threading.CancellationTokenSource
struct CancellationTokenSource_tAAE1E0033BCFC233801F8CB4CED5C852B350CB7B;
// System.Globalization.CompareInfo
struct CompareInfo_t1B1A6AC3486B570C76ABA52149C9BD4CD82F9E57;
// System.Threading.ContextCallback
struct ContextCallback_tE8AFBDBFCC040FDA8DA8C1EEFE9BD66B16BDA007;
// UnityEngine.UIElements.ContextualMenuManager
struct ContextualMenuManager_tEE3B1F33FFFD180705467CA625AEBA0F5D63154B;
// System.Globalization.CultureData
struct CultureData_tEEFDCF4ECA1BBF6C0C8C94EB3541657245598F9D;
// System.Globalization.CultureInfo
struct CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0;
// System.Globalization.DateTimeFormatInfo
struct DateTimeFormatInfo_t0457520F9FA7B5C8EAAEB3AD50413B6AEEB7458A;
// System.Delegate
struct Delegate_t;
// System.DelegateData
struct DelegateData_t9B286B493293CD2D23A5B2B5EF0E5B1324C2B77E;
// UnityEngine.UIElements.UIR.DrawParams
struct DrawParams_t523864F415D78BD8BB14E8B7BD349594D6187443;
// UnityEngine.UIElements.ElementUnderPointer
struct ElementUnderPointer_tB43AD64F79C6F06829D8B90318AF1A6BBE9C1904;
// UnityEngine.UIElements.EventCallbackRegistry
struct EventCallbackRegistry_tE18297C3F7E535BD82EDA83EC6D6DAA386226B85;
// UnityEngine.UIElements.Focusable
struct Focusable_t39F2BAF0AF6CA465BC2BEDAF9B5B2CF379B846D0;
// UnityEngine.Font
struct Font_tC95270EA3198038970422D78B74A7F2E218A96B6;
// UnityEngine.TextCore.Text.FontAsset
struct FontAsset_t61A6446D934E582651044E33D250EA8D306AB958;
// UnityEngine.GameObject
struct GameObject_t76FEDD663AB33C991A9C9A23129337651094216F;
// UnityEngine.UIElements.HierarchyEvent
struct HierarchyEvent_tB23E4347BC47656A014CA104A5B1DDC172A2A705;
// UnityEngine.UIElements.ICursorManager
struct ICursorManager_t78B026DED2559C62810B21C54C5F882457073A8B;
// System.Collections.IDictionary
struct IDictionary_t6D03155AF1FA9083817AA5B6AD7DEEACC26AB220;
// System.IFormatProvider
struct IFormatProvider_tC202922D43BFF3525109ABF3FB79625F5646AB52;
// UnityEngine.Timeline.IMarker
struct IMarker_t56D4AC9FC0C2FA104A18211FF74D707C03FCDB8D;
// UnityEngine.Playables.INotification
struct INotification_tEF630287442F0A66470493068A5D158E3C2D3C6B;
// UnityEngine.UIElements.ITreeViewItem
struct ITreeViewItem_t0C5908872EA2842688BFFB2055D5096EC1EA9EFC;
// UnityEngine.UIElements.IUxmlAttributes
struct IUxmlAttributes_t9B6679F04874117C59014DE49C35B1841F9A1DDE;
// UnityEngine.UIElements.IVisualTreeUpdater
struct IVisualTreeUpdater_t4AF1E0B23A6AEFF024F1AC23815089B2495C7F06;
// UnityEngine.UIElements.InlineStyleAccess
struct InlineStyleAccess_t5CA7877999C9442491A220AE50D605C84D09A165;
// System.Threading.ManualResetEvent
struct ManualResetEvent_t63959486AA41A113A4353D0BF4A68E77EBA0A158;
// UnityEngine.Timeline.MarkerTrack
struct MarkerTrack_tE18594CE52CCC412606B1B5A147DD3A4F7D056C2;
// UnityEngine.Material
struct Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3;
// UnityEngine.MaterialPropertyBlock
struct MaterialPropertyBlock_t2308669579033A857EFE6E4831909F638B27411D;
// System.Reflection.MemberFilter
struct MemberFilter_tF644F1AE82F611B677CE1964D5A3277DDA21D553;
// UnityEngine.UIElements.UIR.MeshHandle
struct MeshHandle_tC1E9A7ECCFDAEFDE064B8D58B35B9CEE5A70A22E;
// System.Reflection.MethodInfo
struct MethodInfo_t;
// System.Globalization.NumberFormatInfo
struct NumberFormatInfo_t8E26808B202927FEBF9064FCFEEA4D6E076E6472;
// UnityEngine.Object
struct Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C;
// UnityEngine.UIElements.UIR.Page
struct Page_tB4EA8095DF85BAF22AB8FCA71400121E721B57C9;
// UnityEngine.Playables.PlayableAsset
struct PlayableAsset_t6964211C3DAE503FEEDD04089ED6B962945D271E;
// System.Text.RegularExpressions.Regex
struct Regex_tE773142C2BE45C5D362B0F815AFF831707A51772;
// UnityEngine.UIElements.UIR.RenderChainCommand
struct RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727;
// UnityEngine.RenderTexture
struct RenderTexture_tBA90C4C3AD9EECCFDDCC632D97C29FAB80D60D27;
// UnityEngine.UIElements.RepaintData
struct RepaintData_t90534752135661579EC254884F550545D001B5EA;
// System.Runtime.Serialization.SafeSerializationManager
struct SafeSerializationManager_tCBB85B95DFD1634237140CD892E82D06ECB3F5E6;
// System.Threading.SendOrPostCallback
struct SendOrPostCallback_t5C292A12062F24027A98492F52ECFE9802AA6F0E;
// UnityEngine.Sprite
struct Sprite_tAFF74BC83CD68037494CB0B4F28CBDF8971CAB99;
// UnityEngine.TextCore.Text.SpriteAsset
struct SpriteAsset_t1D3CF1D9DC350A4690CB09DE228A8B59F2F02313;
// System.Threading.Tasks.StackGuard
struct StackGuard_tACE063A1B7374BDF4AD472DE4585D05AD8745352;
// System.String
struct String_t;
// System.Text.StringBuilder
struct StringBuilder_t;
// UnityEngine.UIElements.StyleComplexSelector
struct StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD;
// UnityEngine.UIElements.StylePropertyAnimationSystem
struct StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718;
// UnityEngine.UIElements.StyleRule
struct StyleRule_t69F0C0989004F85BBD9C72BC7A73F79BFE61651E;
// UnityEngine.UIElements.StyleSelector
struct StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362;
// UnityEngine.UIElements.StyleSheet
struct StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428;
// UnityEngine.UIElements.StyleValueCollection
struct StyleValueCollection_t5ADC08D23E648FBE78F2C161494786E6C83E1377;
// UnityEngine.UIElements.StyleVariableContext
struct StyleVariableContext_tF74F2787CE1F6BEBBFBFF0771CF493AC9E403527;
// System.Threading.Tasks.TaskFactory
struct TaskFactory_tF781BD37BE23917412AD83424D1497C7C1509DF0;
// System.Threading.Tasks.TaskScheduler
struct TaskScheduler_t3F0550EBEF7C41F74EC8C08FF4BED0D8CE66006E;
// UnityEngine.TextCore.Text.TextElement
struct TextElement_tCEF567A8810788262275B39DC39CBA6EBE7472DA;
// System.Globalization.TextInfo
struct TextInfo_tD3BAFCFD77418851E7D5CB8D2588F47019E414B4;
// UnityEngine.Texture
struct Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700;
// UnityEngine.Texture2D
struct Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4;
// UnityEngine.UIElements.UIR.TextureSlotManager
struct TextureSlotManager_tB1F8E620AE296DE3728FAAFBE3CC85D2A176928D;
// UnityEngine.Timeline.TimelineAsset
struct TimelineAsset_tE400C944B07CA9D1349BAD84545E24075ADB3496;
// UnityEngine.Timeline.TimelineClip
struct TimelineClip_t003008F08E56A75F3A47FD9ADE7C066988A3371D;
// UnityEngine.Timeline.TrackAsset
struct TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96;
// System.Type
struct Type_t;
// UnityEngine.UIElements.UIR.UIRenderDevice
struct UIRenderDevice_t59628CBA89B4617E832C2B270E1C1A3931D01302;
// UnityEngine.Events.UnityAction
struct UnityAction_t11A1F3B953B365C072A5DCC32677EE1796A962A7;
// UnityEngine.UnityException
struct UnityException_tA1EC1E95ADE689CF6EB7FAFF77C160AE1F559067;
// UnityEngine.UIElements.UxmlAttributeDescription
struct UxmlAttributeDescription_t742D021489DB2B564142146CAAAC3F9191825EF2;
// UnityEngine.UIElements.UxmlTypeRestriction
struct UxmlTypeRestriction_t2C4CE1ED76502CDF80010880E058AF0582910A92;
// UnityEngine.UIElements.VectorImage
struct VectorImage_t7BD8CE948377FFE95FCA0C48014ACDFC13B8F8FC;
// UnityEngine.UIElements.VisualElement
struct VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115;
// UnityEngine.UIElements.VisualTreeAsset
struct VisualTreeAsset_tFB5BF81F0780A412AE5A7C2C552B3EEA64EA2EEB;
// UnityEngine.UIElements.VisualTreeUpdater
struct VisualTreeUpdater_tFDE7D9F9A146A26B2ED69565B7BD142B416AB9C9;
// System.Void
struct Void_t4861ACF8F4594C3437BB48B6E56783494B843915;
// UnityEngine.Yoga.YogaConfig
struct YogaConfig_tE8B56F99460C291C1F7F46DBD8BAC9F0B653A345;
// UnityEngine.Yoga.YogaNode
struct YogaNode_t4B5B593220CCB315B5A60CB48BA4795636F04DDA;
// UnityEngine.Playables.PlayableBinding/CreateOutputMethod
struct CreateOutputMethod_tD18AFE3B69E6DDD913D82D5FA1D5D909CEEC8509;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values
struct Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesBackground
struct ValuesBackground_tFF4533C18E78BDA24210ECA0967C209A2FD2FB34;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesColor
struct ValuesColor_tDE4E373E9165A21D96B77B831D7663BE93073904;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesCursor
struct ValuesCursor_t2BD94C6247CDFB2DA1668DF09C7D35CE6DD1CE2D;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesFloat
struct ValuesFloat_t79D7FFC3D96EA35AFBCE6E41A84C30186FFFF0C2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesFont
struct ValuesFont_tD9B58EA95F0D99292A54C9C6C879318BBE3B02A4;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesFontDefinition
struct ValuesFontDefinition_t4D0C2DECA9435D3EB901FE70837AD878111678F7;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesInt
struct ValuesInt_t2D0093355274C731BB6DF9C8933EEEDA42276367;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesLength
struct ValuesLength_tCE4AE0723109EE10076DBD46F7A853F202AF5915;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesRotate
struct ValuesRotate_t90582D6825FCBEF3C2A68160CCEC275C51217C63;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesScale
struct ValuesScale_t21E6FC5B09789CB4974FC2ED15C3F83B863FCF8A;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesTextShadow
struct ValuesTextShadow_t50CB05DF0E7770164252616605C61B37DB4A966C;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesTransformOrigin
struct ValuesTransformOrigin_tB46EC0F073E360E1431CCD4E580BA675D716823F;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesTranslate
struct ValuesTranslate_tFB5B432755E0DAA7DD8C95E78FDCC78C4885940B;
// System.Threading.Tasks.Task/ContingentProperties
struct ContingentProperties_t3FA59480914505CEA917B1002EC675F29D0CB540;
// UnityEngine.Timeline.TimelineAsset/EditorSettings
struct EditorSettings_t3A8D02A80F57944B75911D9692FECDF6B7081DFF;
// UnityEngine.UIElements.VisualElement/CustomStyleAccess
struct CustomStyleAccess_t170C852102B4D09FB478B620A75B14D096F9F2B1;
// UnityEngine.UIElements.VisualElement/TypeData
struct TypeData_t01D670B4E71B5571B38C7412B1E652A47D6AF66A;
// UnityEngine.UIElements.VisualTreeUpdater/UpdaterArray
struct UpdaterArray_tF8D43D2A3598E7C17ABB5308E83FDECF1F36A449;
IL2CPP_EXTERN_C RuntimeClass* ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* IDisposable_t030E0496B4E0E4E4F086825007979AF51F7248C5_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* IFormattable_t235A539BD9771E1E118DB99384BA8385D2F971CA_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* IVisualTreeUpdater_t4AF1E0B23A6AEFF024F1AC23815089B2495C7F06_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* String_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Type_t_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C RuntimeClass* Utility_t8BCC393462C6270211734BE47CF5350F05EC97AD_il2cpp_TypeInfo_var;
IL2CPP_EXTERN_C String_t* _stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207;
IL2CPP_EXTERN_C String_t* _stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94;
IL2CPP_EXTERN_C String_t* _stringLiteralBF44A05DB008A507A463F2A13F1907FEB2E4B19F;
IL2CPP_EXTERN_C String_t* _stringLiteralC472776C9180B19630B6E4112538D935B62E3F35;
IL2CPP_EXTERN_C String_t* _stringLiteralC4ADC60D7B4D387FB421586A9B670B3D4B8A0775;
IL2CPP_EXTERN_C String_t* _stringLiteralE8744A8B8BD390EB66CA0CAE2376C973E6904FFB;
IL2CPP_EXTERN_C String_t* _stringLiteralF9010398F7F524C05AB19445BDCE02E617A3E267;
IL2CPP_EXTERN_C const RuntimeMethod* Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* NativeSliceUnsafeUtility_GetUnsafePtr_TisDrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4_m5682E2958E30CCCFB6477FB04847917857BEFAFA_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* NativeSlice_1_get_Length_m2566843C81FEFDDF6407962D4E34F13C3133028D_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Span_1__ctor_mC9BE2938B716B46BB6B9070B94DBE5CE814BC0E2_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* String_Create_TisRuntimeObject_m4B49E10375F1BE32439BE26CBBB4F960EDD45B05_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* String_Create_TisValueTuple_3_tFD2ADB3DA89E958885034AAFEF1ABDA8C814D987_m5E409288A7637C431B8D0248F411CC1378386DE4_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* String_Create_TisValueTuple_5_t558B9F95CA55DE5694FC58A3BEAE441BF728FB57_mF676274E492719C5208121DF9AB97D732DEC1E06_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Task_FromCancellation_TisBoolean_t09A6377A54BE2F9E6985A8149F19234FD7DDFE22_m00F2302E3E462922A07E7B2F02F8E7A965EE45B2_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Task_FromCancellation_TisRuntimeObject_m67B91E1DC1B473B7D61E3E95256FD1269E307143_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Texture2D_GetRawTextureData_TisColor32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B_m3F258FE3486B29D798DCFECF41E9845382EF5CC2_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* Texture2D_GetRawTextureData_TisColor_tD001788D726C3A7F1379BEED0260B9591F440C1F_m3B133F38C7E43266DCD025BC599C24C187E779B3_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UIRenderDevice_DrawRanges_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_TisVertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7_m9B1A0575B3B8487DBF5674BC961D048217F113E2_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UQueryState_1_First_m0E66C612BCBDFFA32D636D936B37CF56C0C2BA94_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UQueryState_1_RebuildOn_m6A44E1618AB0FD0EDCBEEF093B74FDEA03723004_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UxmlAttributeDescription_GetValueFromBag_TisBoolean_t09A6377A54BE2F9E6985A8149F19234FD7DDFE22_m22751CE4DF8B8DDEFEBE8E79FDBB271B3B7AF62D_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UxmlAttributeDescription_GetValueFromBag_TisInt32Enum_tCBAC8BA2BFF3A845FA599F303093BBBA374B6F0C_mB8752E3FCFBE10C58F06DF6F6275C822C4850645_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UxmlAttributeDescription_GetValueFromBag_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_mE6407D384CA016BA1904AE558D480299827A91F0_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UxmlAttributeDescription_GetValueFromBag_TisInt64_t092CFB123BE63C28ACDAF65C68F21A526050DBA3_mD5D06E5828505FB5AC84B2EF9D0FDD2494C4ABA4_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UxmlAttributeDescription_GetValueFromBag_TisRuntimeObject_m068CFD3292450E7E40FB2498A6ABDD4A0B7F9FDC_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeMethod* UxmlAttributeDescription_GetValueFromBag_TisSingle_t4530F2FF86FCB0DC29F35385CA1BD21BE294761C_m3B483191ED592442A1ACF14EC0700E03ECDB4F8D_RuntimeMethod_var;
IL2CPP_EXTERN_C const RuntimeType* VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115_0_0_0_var;
struct Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B;
struct ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1_marshaled_com;
struct ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1_marshaled_pinvoke;
struct CultureData_tEEFDCF4ECA1BBF6C0C8C94EB3541657245598F9D_marshaled_com;
struct CultureData_tEEFDCF4ECA1BBF6C0C8C94EB3541657245598F9D_marshaled_pinvoke;
struct CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0_marshaled_com;
struct CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0_marshaled_pinvoke;
struct Delegate_t_marshaled_com;
struct Delegate_t_marshaled_pinvoke;
struct Exception_t_marshaled_com;
struct Exception_t_marshaled_pinvoke;
struct Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C_marshaled_com;
struct StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D;
struct Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7;
struct Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2;
struct ColorU5BU5D_t612261CF293F6FFC3D80AB52259FF0DC2B2CC389;
struct DimensionU5BU5D_t1EE1B3F9368D444E779CAB3E1CBD9959F8762F4B;
struct Int32U5BU5D_t19C97395396A72ECAF310612F0760F165060314C;
struct LinkInfoU5BU5D_tB7EB23E47AF29CCBEC884F9D0DB95BC97F62AE51;
struct MeshInfoU5BU5D_t3DF8B75BF4A213334EED197AD25E432212894AC6;
struct ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918;
struct PageInfoU5BU5D_tFEA2CF88695491CFC2F2A2EF6BDCC56E52B0A6D4;
struct ScalableImageU5BU5D_t8C989174900062AED19A057FDCF0529F8C594A52;
struct SingleU5BU5D_t89DEFE97BCEDB5857010E79ECE0F52CF6E93B87C;
struct StyleSelectorU5BU5D_t11A633455FC601606B3DF3CEDDDAB1625B54708D;
struct StyleSelectorPartU5BU5D_tBA574FB3E75E94E52874FDB7B05B9048E8A5421B;
struct TextElementInfoU5BU5D_tEC28C9B72883EE21AA798913497C69E179A15C4E;
struct WordInfoU5BU5D_tAD74C9720883D7BB229A20FFAE9EFD2CF9963F7B;
IL2CPP_EXTERN_C_BEGIN
IL2CPP_EXTERN_C_END
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StyleSheets.StylePropertyId,UnityEngine.UIElements.StylePropertyAnimationSystem/Values>
struct Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7 : public RuntimeObject
{
// System.Int32[] System.Collections.Generic.Dictionary`2::_buckets
Int32U5BU5D_t19C97395396A72ECAF310612F0760F165060314C* ____buckets_0;
// System.Collections.Generic.Dictionary`2/Entry<TKey,TValue>[] System.Collections.Generic.Dictionary`2::_entries
EntryU5BU5D_t524C33EA8D08013B8734724ABCA925485CF3B799* ____entries_1;
// System.Int32 System.Collections.Generic.Dictionary`2::_count
int32_t ____count_2;
// System.Int32 System.Collections.Generic.Dictionary`2::_freeList
int32_t ____freeList_3;
// System.Int32 System.Collections.Generic.Dictionary`2::_freeCount
int32_t ____freeCount_4;
// System.Int32 System.Collections.Generic.Dictionary`2::_version
int32_t ____version_5;
// System.Collections.Generic.IEqualityComparer`1<TKey> System.Collections.Generic.Dictionary`2::_comparer
RuntimeObject* ____comparer_6;
// System.Collections.Generic.Dictionary`2/KeyCollection<TKey,TValue> System.Collections.Generic.Dictionary`2::_keys
KeyCollection_tAE1CD1CE327D07F072532A89E6854F2C33EB014A* ____keys_7;
// System.Collections.Generic.Dictionary`2/ValueCollection<TKey,TValue> System.Collections.Generic.Dictionary`2::_values
ValueCollection_t04D5F77EBC72D81BB7FE7199D6C9DC65DEB60064* ____values_8;
// System.Object System.Collections.Generic.Dictionary`2::_syncRoot
RuntimeObject* ____syncRoot_9;
};
// UnityEngine.UIElements.UQuery/IsOfType`1<System.Object>
struct IsOfType_1_tAD57152B527BA8DDBDA8E8C388140620049ADBE4 : public RuntimeObject
{
};
struct IsOfType_1_tAD57152B527BA8DDBDA8E8C388140620049ADBE4_StaticFields
{
// UnityEngine.UIElements.UQuery/IsOfType`1<T> UnityEngine.UIElements.UQuery/IsOfType`1::s_Instance
IsOfType_1_tAD57152B527BA8DDBDA8E8C388140620049ADBE4* ___s_Instance_0;
};
// System.Collections.Generic.List`1<UnityEngine.UIElements.EasingFunction>
struct List_1_tE7FB077B3CEA6371A27F72CC60962491AB71490B : public RuntimeObject
{
// T[] System.Collections.Generic.List`1::_items
EasingFunctionU5BU5D_t3EEBBFFAD92EA74C3960D5F78D2A98BCEEA62E49* ____items_1;
// System.Int32 System.Collections.Generic.List`1::_size
int32_t ____size_2;
// System.Int32 System.Collections.Generic.List`1::_version
int32_t ____version_3;
// System.Object System.Collections.Generic.List`1::_syncRoot
RuntimeObject* ____syncRoot_4;
};
struct List_1_tE7FB077B3CEA6371A27F72CC60962491AB71490B_StaticFields
{
// T[] System.Collections.Generic.List`1::s_emptyArray
EasingFunctionU5BU5D_t3EEBBFFAD92EA74C3960D5F78D2A98BCEEA62E49* ___s_emptyArray_5;
};
// System.Collections.Generic.List`1<System.Object>
struct List_1_tA239CB83DE5615F348BB0507E45F490F4F7C9A8D : public RuntimeObject
{
// T[] System.Collections.Generic.List`1::_items
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* ____items_1;
// System.Int32 System.Collections.Generic.List`1::_size
int32_t ____size_2;
// System.Int32 System.Collections.Generic.List`1::_version
int32_t ____version_3;
// System.Object System.Collections.Generic.List`1::_syncRoot
RuntimeObject* ____syncRoot_4;
};
struct List_1_tA239CB83DE5615F348BB0507E45F490F4F7C9A8D_StaticFields
{
// T[] System.Collections.Generic.List`1::s_emptyArray
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* ___s_emptyArray_5;
};
// System.Collections.Generic.List`1<UnityEngine.UIElements.RuleMatcher>
struct List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC : public RuntimeObject
{
// T[] System.Collections.Generic.List`1::_items
RuleMatcherU5BU5D_t0135EA06151E72D04414F3EAF9420CB85EE2236C* ____items_1;
// System.Int32 System.Collections.Generic.List`1::_size
int32_t ____size_2;
// System.Int32 System.Collections.Generic.List`1::_version
int32_t ____version_3;
// System.Object System.Collections.Generic.List`1::_syncRoot
RuntimeObject* ____syncRoot_4;
};
struct List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC_StaticFields
{
// T[] System.Collections.Generic.List`1::s_emptyArray
RuleMatcherU5BU5D_t0135EA06151E72D04414F3EAF9420CB85EE2236C* ___s_emptyArray_5;
};
// System.Collections.Generic.List`1<UnityEngine.UIElements.StylePropertyName>
struct List_1_tD6F1685FEE5A196B3002ACC649A1DF5C65162268 : public RuntimeObject
{
// T[] System.Collections.Generic.List`1::_items
StylePropertyNameU5BU5D_t531626CF806E3F3D348D1F38A9109767014C35F8* ____items_1;
// System.Int32 System.Collections.Generic.List`1::_size
int32_t ____size_2;
// System.Int32 System.Collections.Generic.List`1::_version
int32_t ____version_3;
// System.Object System.Collections.Generic.List`1::_syncRoot
RuntimeObject* ____syncRoot_4;
};
struct List_1_tD6F1685FEE5A196B3002ACC649A1DF5C65162268_StaticFields
{
// T[] System.Collections.Generic.List`1::s_emptyArray
StylePropertyNameU5BU5D_t531626CF806E3F3D348D1F38A9109767014C35F8* ___s_emptyArray_5;
};
// System.Collections.Generic.List`1<UnityEngine.UIElements.TimeValue>
struct List_1_t437B6C3879E969156A381BDC3C459CF809D39DDF : public RuntimeObject
{
// T[] System.Collections.Generic.List`1::_items
TimeValueU5BU5D_t3EB79C5975D39A0E711250FD8A9547F5312746DE* ____items_1;
// System.Int32 System.Collections.Generic.List`1::_size
int32_t ____size_2;
// System.Int32 System.Collections.Generic.List`1::_version
int32_t ____version_3;
// System.Object System.Collections.Generic.List`1::_syncRoot
RuntimeObject* ____syncRoot_4;
};
struct List_1_t437B6C3879E969156A381BDC3C459CF809D39DDF_StaticFields
{
// T[] System.Collections.Generic.List`1::s_emptyArray
TimeValueU5BU5D_t3EB79C5975D39A0E711250FD8A9547F5312746DE* ___s_emptyArray_5;
};
// System.Collections.Generic.List`1<UnityEngine.UIElements.StylePropertyAnimationSystem/Values>
struct List_1_t491E344573B9D6F61E36AF56132B7412453928C9 : public RuntimeObject
{
// T[] System.Collections.Generic.List`1::_items
ValuesU5BU5D_t5332999C48416329B2A447FCD8C71113DDB459EA* ____items_1;
// System.Int32 System.Collections.Generic.List`1::_size
int32_t ____size_2;
// System.Int32 System.Collections.Generic.List`1::_version
int32_t ____version_3;
// System.Object System.Collections.Generic.List`1::_syncRoot
RuntimeObject* ____syncRoot_4;
};
struct List_1_t491E344573B9D6F61E36AF56132B7412453928C9_StaticFields
{
// T[] System.Collections.Generic.List`1::s_emptyArray
ValuesU5BU5D_t5332999C48416329B2A447FCD8C71113DDB459EA* ___s_emptyArray_5;
};
// UnityEngine.UIElements.Experimental.ValueAnimation`1<System.Object>
struct ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B : public RuntimeObject
{
// System.Int64 UnityEngine.UIElements.Experimental.ValueAnimation`1::m_StartTimeMs
int64_t ___m_StartTimeMs_0;
// System.Int32 UnityEngine.UIElements.Experimental.ValueAnimation`1::m_DurationMs
int32_t ___m_DurationMs_1;
// System.Func`2<System.Single,System.Single> UnityEngine.UIElements.Experimental.ValueAnimation`1::<easingCurve>k__BackingField
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___U3CeasingCurveU3Ek__BackingField_2;
// System.Boolean UnityEngine.UIElements.Experimental.ValueAnimation`1::<isRunning>k__BackingField
bool ___U3CisRunningU3Ek__BackingField_3;
// System.Action UnityEngine.UIElements.Experimental.ValueAnimation`1::<onAnimationCompleted>k__BackingField
Action_tD00B0A84D7945E50C2DFFC28EFEE6ED44ED2AD07* ___U3ConAnimationCompletedU3Ek__BackingField_4;
// System.Boolean UnityEngine.UIElements.Experimental.ValueAnimation`1::<autoRecycle>k__BackingField
bool ___U3CautoRecycleU3Ek__BackingField_5;
// System.Boolean UnityEngine.UIElements.Experimental.ValueAnimation`1::<recycled>k__BackingField
bool ___U3CrecycledU3Ek__BackingField_6;
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.Experimental.ValueAnimation`1::<owner>k__BackingField
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___U3CownerU3Ek__BackingField_8;
// System.Action`2<UnityEngine.UIElements.VisualElement,T> UnityEngine.UIElements.Experimental.ValueAnimation`1::<valueUpdated>k__BackingField
Action_2_t481D6C6BCDB085CB7BE1AA1DBD81F4DC0C04D1F2* ___U3CvalueUpdatedU3Ek__BackingField_9;
// System.Func`2<UnityEngine.UIElements.VisualElement,T> UnityEngine.UIElements.Experimental.ValueAnimation`1::<initialValue>k__BackingField
Func_2_t9AAA83BE20528E7FBB1DCCFF8E9640E7061D5BE3* ___U3CinitialValueU3Ek__BackingField_10;
// System.Func`4<T,T,System.Single,T> UnityEngine.UIElements.Experimental.ValueAnimation`1::<interpolator>k__BackingField
Func_4_t20528E18B451AECBBF66363BFFF0BE47D521318F* ___U3CinterpolatorU3Ek__BackingField_11;
// T UnityEngine.UIElements.Experimental.ValueAnimation`1::_from
RuntimeObject* ____from_12;
// System.Boolean UnityEngine.UIElements.Experimental.ValueAnimation`1::fromValueSet
bool ___fromValueSet_13;
// T UnityEngine.UIElements.Experimental.ValueAnimation`1::<to>k__BackingField
RuntimeObject* ___U3CtoU3Ek__BackingField_14;
};
struct ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B_StaticFields
{
// UnityEngine.UIElements.ObjectPool`1<UnityEngine.UIElements.Experimental.ValueAnimation`1<T>> UnityEngine.UIElements.Experimental.ValueAnimation`1::sObjectPool
ObjectPool_1_t8AC25F7642B86DC900C1E5BB4FF5DDB43900D6F4* ___sObjectPool_7;
};
// UnityEngine.UIElements.CallbackEventHandler
struct CallbackEventHandler_t99E35735225B4ACEAD1BA981632FD2D46E9CB2B4 : public RuntimeObject
{
// UnityEngine.UIElements.EventCallbackRegistry UnityEngine.UIElements.CallbackEventHandler::m_CallbackRegistry
EventCallbackRegistry_tE18297C3F7E535BD82EDA83EC6D6DAA386226B85* ___m_CallbackRegistry_0;
};
// System.Globalization.CultureInfo
struct CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0 : public RuntimeObject
{
// System.Boolean System.Globalization.CultureInfo::m_isReadOnly
bool ___m_isReadOnly_3;
// System.Int32 System.Globalization.CultureInfo::cultureID
int32_t ___cultureID_4;
// System.Int32 System.Globalization.CultureInfo::parent_lcid
int32_t ___parent_lcid_5;
// System.Int32 System.Globalization.CultureInfo::datetime_index
int32_t ___datetime_index_6;
// System.Int32 System.Globalization.CultureInfo::number_index
int32_t ___number_index_7;
// System.Int32 System.Globalization.CultureInfo::default_calendar_type
int32_t ___default_calendar_type_8;
// System.Boolean System.Globalization.CultureInfo::m_useUserOverride
bool ___m_useUserOverride_9;
// System.Globalization.NumberFormatInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.CultureInfo::numInfo
NumberFormatInfo_t8E26808B202927FEBF9064FCFEEA4D6E076E6472* ___numInfo_10;
// System.Globalization.DateTimeFormatInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.CultureInfo::dateTimeInfo
DateTimeFormatInfo_t0457520F9FA7B5C8EAAEB3AD50413B6AEEB7458A* ___dateTimeInfo_11;
// System.Globalization.TextInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.CultureInfo::textInfo
TextInfo_tD3BAFCFD77418851E7D5CB8D2588F47019E414B4* ___textInfo_12;
// System.String System.Globalization.CultureInfo::m_name
String_t* ___m_name_13;
// System.String System.Globalization.CultureInfo::englishname
String_t* ___englishname_14;
// System.String System.Globalization.CultureInfo::nativename
String_t* ___nativename_15;
// System.String System.Globalization.CultureInfo::iso3lang
String_t* ___iso3lang_16;
// System.String System.Globalization.CultureInfo::iso2lang
String_t* ___iso2lang_17;
// System.String System.Globalization.CultureInfo::win3lang
String_t* ___win3lang_18;
// System.String System.Globalization.CultureInfo::territory
String_t* ___territory_19;
// System.String[] System.Globalization.CultureInfo::native_calendar_names
StringU5BU5D_t7674CD946EC0CE7B3AE0BE70E6EE85F2ECD9F248* ___native_calendar_names_20;
// System.Globalization.CompareInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.CultureInfo::compareInfo
CompareInfo_t1B1A6AC3486B570C76ABA52149C9BD4CD82F9E57* ___compareInfo_21;
// System.Void* System.Globalization.CultureInfo::textinfo_data
void* ___textinfo_data_22;
// System.Int32 System.Globalization.CultureInfo::m_dataItem
int32_t ___m_dataItem_23;
// System.Globalization.Calendar System.Globalization.CultureInfo::calendar
Calendar_t0A117CC7532A54C17188C2EFEA1F79DB20DF3A3B* ___calendar_24;
// System.Globalization.CultureInfo System.Globalization.CultureInfo::parent_culture
CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0* ___parent_culture_25;
// System.Boolean System.Globalization.CultureInfo::constructed
bool ___constructed_26;
// System.Byte[] System.Globalization.CultureInfo::cached_serialized_form
ByteU5BU5D_tA6237BF417AE52AD70CFB4EF24A7A82613DF9031* ___cached_serialized_form_27;
// System.Globalization.CultureData System.Globalization.CultureInfo::m_cultureData
CultureData_tEEFDCF4ECA1BBF6C0C8C94EB3541657245598F9D* ___m_cultureData_28;
// System.Boolean System.Globalization.CultureInfo::m_isInherited
bool ___m_isInherited_29;
};
struct CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0_StaticFields
{
// System.Globalization.CultureInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.CultureInfo::invariant_culture_info
CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0* ___invariant_culture_info_0;
// System.Object System.Globalization.CultureInfo::shared_table_lock
RuntimeObject* ___shared_table_lock_1;
// System.Globalization.CultureInfo System.Globalization.CultureInfo::default_current_culture
CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0* ___default_current_culture_2;
// System.Globalization.CultureInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.CultureInfo::s_DefaultThreadCurrentUICulture
CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0* ___s_DefaultThreadCurrentUICulture_34;
// System.Globalization.CultureInfo modreq(System.Runtime.CompilerServices.IsVolatile) System.Globalization.CultureInfo::s_DefaultThreadCurrentCulture
CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0* ___s_DefaultThreadCurrentCulture_35;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Globalization.CultureInfo> System.Globalization.CultureInfo::shared_by_number
Dictionary_2_t9FA6D82CAFC18769F7515BB51D1C56DAE09381C3* ___shared_by_number_36;
// System.Collections.Generic.Dictionary`2<System.String,System.Globalization.CultureInfo> System.Globalization.CultureInfo::shared_by_name
Dictionary_2_tE1603CE612C16451D1E56FF4D4859D4FE4087C28* ___shared_by_name_37;
// System.Globalization.CultureInfo System.Globalization.CultureInfo::s_UserPreferredCultureInfoInAppX
CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0* ___s_UserPreferredCultureInfoInAppX_38;
// System.Boolean System.Globalization.CultureInfo::IsTaiwanSku
bool ___IsTaiwanSku_39;
};
// Native definition for P/Invoke marshalling of System.Globalization.CultureInfo
struct CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0_marshaled_pinvoke
{
int32_t ___m_isReadOnly_3;
int32_t ___cultureID_4;
int32_t ___parent_lcid_5;
int32_t ___datetime_index_6;
int32_t ___number_index_7;
int32_t ___default_calendar_type_8;
int32_t ___m_useUserOverride_9;
NumberFormatInfo_t8E26808B202927FEBF9064FCFEEA4D6E076E6472* ___numInfo_10;
DateTimeFormatInfo_t0457520F9FA7B5C8EAAEB3AD50413B6AEEB7458A* ___dateTimeInfo_11;
TextInfo_tD3BAFCFD77418851E7D5CB8D2588F47019E414B4* ___textInfo_12;
char* ___m_name_13;
char* ___englishname_14;
char* ___nativename_15;
char* ___iso3lang_16;
char* ___iso2lang_17;
char* ___win3lang_18;
char* ___territory_19;
char** ___native_calendar_names_20;
CompareInfo_t1B1A6AC3486B570C76ABA52149C9BD4CD82F9E57* ___compareInfo_21;
void* ___textinfo_data_22;
int32_t ___m_dataItem_23;
Calendar_t0A117CC7532A54C17188C2EFEA1F79DB20DF3A3B* ___calendar_24;
CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0_marshaled_pinvoke* ___parent_culture_25;
int32_t ___constructed_26;
Il2CppSafeArray/*NONE*/* ___cached_serialized_form_27;
CultureData_tEEFDCF4ECA1BBF6C0C8C94EB3541657245598F9D_marshaled_pinvoke* ___m_cultureData_28;
int32_t ___m_isInherited_29;
};
// Native definition for COM marshalling of System.Globalization.CultureInfo
struct CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0_marshaled_com
{
int32_t ___m_isReadOnly_3;
int32_t ___cultureID_4;
int32_t ___parent_lcid_5;
int32_t ___datetime_index_6;
int32_t ___number_index_7;
int32_t ___default_calendar_type_8;
int32_t ___m_useUserOverride_9;
NumberFormatInfo_t8E26808B202927FEBF9064FCFEEA4D6E076E6472* ___numInfo_10;
DateTimeFormatInfo_t0457520F9FA7B5C8EAAEB3AD50413B6AEEB7458A* ___dateTimeInfo_11;
TextInfo_tD3BAFCFD77418851E7D5CB8D2588F47019E414B4* ___textInfo_12;
Il2CppChar* ___m_name_13;
Il2CppChar* ___englishname_14;
Il2CppChar* ___nativename_15;
Il2CppChar* ___iso3lang_16;
Il2CppChar* ___iso2lang_17;
Il2CppChar* ___win3lang_18;
Il2CppChar* ___territory_19;
Il2CppChar** ___native_calendar_names_20;
CompareInfo_t1B1A6AC3486B570C76ABA52149C9BD4CD82F9E57* ___compareInfo_21;
void* ___textinfo_data_22;
int32_t ___m_dataItem_23;
Calendar_t0A117CC7532A54C17188C2EFEA1F79DB20DF3A3B* ___calendar_24;
CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0_marshaled_com* ___parent_culture_25;
int32_t ___constructed_26;
Il2CppSafeArray/*NONE*/* ___cached_serialized_form_27;
CultureData_tEEFDCF4ECA1BBF6C0C8C94EB3541657245598F9D_marshaled_com* ___m_cultureData_28;
int32_t ___m_isInherited_29;
};
// System.Reflection.MemberInfo
struct MemberInfo_t : public RuntimeObject
{
};
// System.SpanHelpers
struct SpanHelpers_tCA85E2BE495D0EC31B7D20D20E9FC3309265176A : public RuntimeObject
{
};
// System.String
struct String_t : public RuntimeObject
{
// System.Int32 System.String::_stringLength
int32_t ____stringLength_4;
// System.Char System.String::_firstChar
Il2CppChar ____firstChar_5;
};
struct String_t_StaticFields
{
// System.String System.String::Empty
String_t* ___Empty_6;
};
// System.Text.StringBuilder
struct StringBuilder_t : public RuntimeObject
{
// System.Char[] System.Text.StringBuilder::m_ChunkChars
CharU5BU5D_t799905CF001DD5F13F7DBB310181FC4D8B7D0AAB* ___m_ChunkChars_0;
// System.Text.StringBuilder System.Text.StringBuilder::m_ChunkPrevious
StringBuilder_t* ___m_ChunkPrevious_1;
// System.Int32 System.Text.StringBuilder::m_ChunkLength
int32_t ___m_ChunkLength_2;
// System.Int32 System.Text.StringBuilder::m_ChunkOffset
int32_t ___m_ChunkOffset_3;
// System.Int32 System.Text.StringBuilder::m_MaxCapacity
int32_t ___m_MaxCapacity_4;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem
struct StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718 : public RuntimeObject
{
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem::m_CurrentTimeMs
int64_t ___m_CurrentTimeMs_0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesFloat UnityEngine.UIElements.StylePropertyAnimationSystem::m_Floats
ValuesFloat_t79D7FFC3D96EA35AFBCE6E41A84C30186FFFF0C2* ___m_Floats_1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesInt UnityEngine.UIElements.StylePropertyAnimationSystem::m_Ints
ValuesInt_t2D0093355274C731BB6DF9C8933EEEDA42276367* ___m_Ints_2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesLength UnityEngine.UIElements.StylePropertyAnimationSystem::m_Lengths
ValuesLength_tCE4AE0723109EE10076DBD46F7A853F202AF5915* ___m_Lengths_3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesColor UnityEngine.UIElements.StylePropertyAnimationSystem::m_Colors
ValuesColor_tDE4E373E9165A21D96B77B831D7663BE93073904* ___m_Colors_4;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesBackground UnityEngine.UIElements.StylePropertyAnimationSystem::m_Backgrounds
ValuesBackground_tFF4533C18E78BDA24210ECA0967C209A2FD2FB34* ___m_Backgrounds_5;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesFontDefinition UnityEngine.UIElements.StylePropertyAnimationSystem::m_FontDefinitions
ValuesFontDefinition_t4D0C2DECA9435D3EB901FE70837AD878111678F7* ___m_FontDefinitions_6;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesFont UnityEngine.UIElements.StylePropertyAnimationSystem::m_Fonts
ValuesFont_tD9B58EA95F0D99292A54C9C6C879318BBE3B02A4* ___m_Fonts_7;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesCursor UnityEngine.UIElements.StylePropertyAnimationSystem::m_Cursors
ValuesCursor_t2BD94C6247CDFB2DA1668DF09C7D35CE6DD1CE2D* ___m_Cursors_8;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesTextShadow UnityEngine.UIElements.StylePropertyAnimationSystem::m_TextShadows
ValuesTextShadow_t50CB05DF0E7770164252616605C61B37DB4A966C* ___m_TextShadows_9;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesScale UnityEngine.UIElements.StylePropertyAnimationSystem::m_Scale
ValuesScale_t21E6FC5B09789CB4974FC2ED15C3F83B863FCF8A* ___m_Scale_10;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesRotate UnityEngine.UIElements.StylePropertyAnimationSystem::m_Rotate
ValuesRotate_t90582D6825FCBEF3C2A68160CCEC275C51217C63* ___m_Rotate_11;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesTranslate UnityEngine.UIElements.StylePropertyAnimationSystem::m_Translate
ValuesTranslate_tFB5B432755E0DAA7DD8C95E78FDCC78C4885940B* ___m_Translate_12;
// UnityEngine.UIElements.StylePropertyAnimationSystem/ValuesTransformOrigin UnityEngine.UIElements.StylePropertyAnimationSystem::m_TransformOrigin
ValuesTransformOrigin_tB46EC0F073E360E1431CCD4E580BA675D716823F* ___m_TransformOrigin_13;
// System.Collections.Generic.List`1<UnityEngine.UIElements.StylePropertyAnimationSystem/Values> UnityEngine.UIElements.StylePropertyAnimationSystem::m_AllValues
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* ___m_AllValues_14;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StyleSheets.StylePropertyId,UnityEngine.UIElements.StylePropertyAnimationSystem/Values> UnityEngine.UIElements.StylePropertyAnimationSystem::m_PropertyToValues
Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* ___m_PropertyToValues_15;
};
// UnityEngine.UIElements.StyleValueExtensions
struct StyleValueExtensions_t726B74FF15FD6E36DAD4BF0C34078437975FF358 : public RuntimeObject
{
};
// System.ThrowHelper
struct ThrowHelper_tDAFF1075E5B21B120EF09F3F2EAD51037DAB6F73 : public RuntimeObject
{
};
// System.Runtime.CompilerServices.Unsafe
struct Unsafe_t013486CBD5A88F5F394651AB34F2AC5AE97E71E4 : public RuntimeObject
{
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility
struct UnsafeUtility_tC3E6B7D52A973A81739E8BD97D6E757BA8371D46 : public RuntimeObject
{
};
// System.ValueType
struct ValueType_t6D9B272BD21782F0A9A14F2E41F85A50E97A986F : public RuntimeObject
{
};
// Native definition for P/Invoke marshalling of System.ValueType
struct ValueType_t6D9B272BD21782F0A9A14F2E41F85A50E97A986F_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.ValueType
struct ValueType_t6D9B272BD21782F0A9A14F2E41F85A50E97A986F_marshaled_com
{
};
// System.Numerics.Vector
struct Vector_t246EF05F1CA5F494FB8B48AB2724DFCD2C2C5A9A : public RuntimeObject
{
};
// UnityEngine.UIElements.VisualTreeUpdater
struct VisualTreeUpdater_tFDE7D9F9A146A26B2ED69565B7BD142B416AB9C9 : public RuntimeObject
{
// UnityEngine.UIElements.BaseVisualElementPanel UnityEngine.UIElements.VisualTreeUpdater::m_Panel
BaseVisualElementPanel_tE3811F3D1474B72CB6CD5BCEECFF5B5CBEC1E303* ___m_Panel_0;
// UnityEngine.UIElements.VisualTreeUpdater/UpdaterArray UnityEngine.UIElements.VisualTreeUpdater::m_UpdaterArray
UpdaterArray_tF8D43D2A3598E7C17ABB5308E83FDECF1F36A449* ___m_UpdaterArray_1;
};
// System.Threading.Volatile
struct Volatile_tC26FEDFD254742AD25E4B908FA81293FBBF4ECB0 : public RuntimeObject
{
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values
struct Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24 : public RuntimeObject
{
};
// UnityEngine.UIElements.VisualTreeUpdater/UpdaterArray
struct UpdaterArray_tF8D43D2A3598E7C17ABB5308E83FDECF1F36A449 : public RuntimeObject
{
// UnityEngine.UIElements.IVisualTreeUpdater[] UnityEngine.UIElements.VisualTreeUpdater/UpdaterArray::m_VisualTreeUpdaters
IVisualTreeUpdaterU5BU5D_t9E9D948BC4F327DA519FEB2BCEC12FB7FD7C59E8* ___m_VisualTreeUpdaters_0;
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<System.Byte>
struct AlignOfHelper_1_t31AECFF735259A0FDFB7AA894944339927FD14A2
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
uint8_t ___data_1;
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<System.Int32>
struct AlignOfHelper_1_tDEDE36731BCA4BBF0A258F5E9A0155E556B11BB3
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
int32_t ___data_1;
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<System.UInt16>
struct AlignOfHelper_1_t82117C0F9F1FB124A9CEB4215A5BB62387D6E5D2
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
uint16_t ___data_1;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.Background>,UnityEngine.UIElements.Background>
struct AnimationDataSet_2_t07C050B2EAC67E726A0EDE08E5279AEDE10CD2E1
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
EmptyDataU5BU5D_t4FC6419C796BBADFEC77D9CB97A3FB7B1C6D5CB8* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
BackgroundU5BU5D_t29762095DD694E79A85A59135735FF02E54C4B46* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.Color>,UnityEngine.Color>
struct AnimationDataSet_2_t5C2C52995428480EE498ED27BBDAFCCE55045703
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
EmptyDataU5BU5D_tDFE3104887D7AEB406BC646123D7C8AA698EB58A* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
ColorU5BU5D_t612261CF293F6FFC3D80AB52259FF0DC2B2CC389* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.Cursor>,UnityEngine.UIElements.Cursor>
struct AnimationDataSet_2_tD9DDD28AA56350E42A0698BF7B9BAF02785C90B5
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
EmptyDataU5BU5D_t86ACC6560CF2B91DD5D368119A8F1F939BBF272D* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
CursorU5BU5D_t56D2D31C350B8CE5B9398F24B50E81B7842D309C* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.FontDefinition>,UnityEngine.UIElements.FontDefinition>
struct AnimationDataSet_2_t484294514C51AC5E0E440CDA5AF2A1043C53E0FC
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
EmptyDataU5BU5D_t568C72D6625FA05F854FF86F02910C531D98B72E* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
FontDefinitionU5BU5D_t31BDC3E2D72918B36F815F95F7CBA1F057E3DA39* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<System.Int32>,System.Int32>
struct AnimationDataSet_2_t4DB9D41C1AF8039FC6D44B76F29446F2BEC85A14
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
EmptyDataU5BU5D_t920355EC41DECEE4E1D5688CEA971923802FC9A3* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
Int32U5BU5D_t19C97395396A72ECAF310612F0760F165060314C* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.Length>,UnityEngine.UIElements.Length>
struct AnimationDataSet_2_tC6CE5153E3EAA98BB106BC6F00B2A9DE6FD23D69
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
EmptyDataU5BU5D_tE2C14BF5968870FDDD993014F93FDE3FC5572837* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
LengthU5BU5D_t6E92E14664BA86924824C32A0BBE10AEC53C7FAE* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<System.Object>,System.Object>
struct AnimationDataSet_2_t2AB6B1DCEF83474EFD60DF81EB5AC7788DA9AEE1
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
EmptyDataU5BU5D_t543192ACC732EF0DB4B419407C24CD12260A485B* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.Rotate>,UnityEngine.UIElements.Rotate>
struct AnimationDataSet_2_tC89D9008D3FFA8DFDC3145842EFEC11F9D8EBEAC
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
EmptyDataU5BU5D_t4EA7859B72A26B20006E0BD02EC63611C4C71485* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
RotateU5BU5D_tD482C518713DEC5763C34C827A9B6DB565776772* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.Scale>,UnityEngine.UIElements.Scale>
struct AnimationDataSet_2_tF4CF89DB617BD2ACE24400B864B2FB32EADB9D04
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
EmptyDataU5BU5D_tF2D26ADE6FCC1E97FB2FFC1DC56D63F08E711A3C* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
ScaleU5BU5D_tE608175710457D7343DD849244BF59B58157F0EF* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<System.Single>,System.Single>
struct AnimationDataSet_2_t37FCD741F1DDE73FBF7D33FB969BB39D5F0EB530
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
EmptyDataU5BU5D_t60D6EDC5438323017497721F3A8E4A0376F2B741* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
SingleU5BU5D_t89DEFE97BCEDB5857010E79ECE0F52CF6E93B87C* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.TextShadow>,UnityEngine.UIElements.TextShadow>
struct AnimationDataSet_2_t41E105586D98932D715A57A47A3E21B5C3A7B340
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
EmptyDataU5BU5D_t8EE2FFAAC9B7C301CF4690109183A2EFDFC5A20F* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
TextShadowU5BU5D_tF37C87EBD3D8745BEDABCE2EA499DE16C15B5D8C* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.TransformOrigin>,UnityEngine.UIElements.TransformOrigin>
struct AnimationDataSet_2_t4532152E7A78B3E14F61FA9CA7C80BC1C3269D33
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
EmptyDataU5BU5D_tB3A736D4DE7E747B7C1B6CA7B36EB41FA6207653* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
TransformOriginU5BU5D_t0BDBC9C8F1888009152284DC2903B3C289F826DA* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<UnityEngine.UIElements.Translate>,UnityEngine.UIElements.Translate>
struct AnimationDataSet_2_t9D395E96FBE02DA4D17B2E175F9B5C297C1BBAA8
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
EmptyDataU5BU5D_tFD0240910F0FF75CC94A141EDE346043BD9C179C* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
TranslateU5BU5D_t9199DFD72A8EC5FA4C33D75E5F85242F9F97E358* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.Background>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.Background>>
struct AnimationDataSet_2_tA243970D144368E3CCB216CDCA976F7B00517D50
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
TimingDataU5BU5D_t0DDECCB612303E94B577E5978AB4B36B5192AFB1* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
StyleDataU5BU5D_tF87CDE51588E78D4C87C144731581FB5284776E0* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.Color>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.Color>>
struct AnimationDataSet_2_t05E5B46314C503F32CE3258CA1AF9DF73160F79D
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
TimingDataU5BU5D_t03C8C38B8DBF52B9A23FB2B77BEC41E63D4A3994* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
StyleDataU5BU5D_t73BFD33363F897414B879236BE0A0DCA6962B9AB* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.Cursor>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.Cursor>>
struct AnimationDataSet_2_t6BC396B0B5FF985F629D1C8295796EBE26A30B48
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
TimingDataU5BU5D_t69EAE6B456DFA123ADF7DEAA56717BEFA7407C31* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
StyleDataU5BU5D_t686F1C6A6AF575A38AF7C9CB30E2EDA62E0A3F2E* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.FontDefinition>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.FontDefinition>>
struct AnimationDataSet_2_tEF417861004C34C4652386FBC8E77254726BA9AC
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
TimingDataU5BU5D_t45DAD27FEA03547B7581715461816FA37E7EC651* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
StyleDataU5BU5D_tD406BDE6B313334D7A7241DDEA636226CC9C0043* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<System.Int32>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<System.Int32>>
struct AnimationDataSet_2_t85603CE9660948961D59A0333F6A6309C7BB17FF
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
TimingDataU5BU5D_t9253C6811381B1932706D115D067841C7175C077* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
StyleDataU5BU5D_tDA10AD1016A9574B39F73BE1DBE2E3A55720EAA9* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.Length>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.Length>>
struct AnimationDataSet_2_t45555A77E9CCB1712AFAC90FC398811D0DFC89D0
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
TimingDataU5BU5D_tA5BE0E019AB587A0072682D5535D2295EC6F04B9* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
StyleDataU5BU5D_t8ACFC9D6C572747CB5326B98E34DEE3AC989D876* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<System.Object>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<System.Object>>
struct AnimationDataSet_2_t1BF178588B6708AE2B0B1E189EA53A67F8B421FB
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
TimingDataU5BU5D_t86A2877F21E58289C845548B2244BFCA090918B1* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
StyleDataU5BU5D_t93B88656D82161E5A58053D74E6C823720B88361* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.Rotate>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.Rotate>>
struct AnimationDataSet_2_t0C85CDF29C591FFB68A31A73E030182698C727FA
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
TimingDataU5BU5D_tE963FB40D15F6761CC687300F7A3EFCD58A8505A* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
StyleDataU5BU5D_tBB18CE54D6B9B54229E01AFF7CCB44B8305F2386* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.Scale>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.Scale>>
struct AnimationDataSet_2_t295398C1274FE0EB846F0554EBF4EF36A80BCDBE
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
TimingDataU5BU5D_t0BCD78985159E6EF1D974E34B209EDE880E06269* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
StyleDataU5BU5D_t988DBB7FAB3D7D4E114C94A5CF2E305E3FFB2A7F* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<System.Single>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<System.Single>>
struct AnimationDataSet_2_t6CCD1B60CF99FF9003A6D1D5C5902EC074711A32
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
TimingDataU5BU5D_t370B0476A79A76456F04BA6664A963CC579E9CD0* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
StyleDataU5BU5D_t73D276E94B9F65AFF0A22B0D465D05D5E9438F5E* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.TextShadow>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.TextShadow>>
struct AnimationDataSet_2_t9B3435A0C6251F2602B478702F4F7EC8CEDBC437
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
TimingDataU5BU5D_tE92E1403336542C4CF4B76824A22545D0EB14E14* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
StyleDataU5BU5D_t597C3C3BF0BFFC87AB6037E85E0829D999602263* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.TransformOrigin>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.TransformOrigin>>
struct AnimationDataSet_2_t51062A50DDCEFF7458A164F033D211C9E0701513
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
TimingDataU5BU5D_t1C0E9B6D937D57C27438BFA33BC2DB905EE4973E* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
StyleDataU5BU5D_tDCCCED3D71A0A84CDB77E5222463121D4EB611CC* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<UnityEngine.UIElements.Translate>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<UnityEngine.UIElements.Translate>>
struct AnimationDataSet_2_t22FC41AC7166F393727321C212FD541AA7DC4880
{
// UnityEngine.UIElements.VisualElement[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::elements
VisualElementU5BU5D_tCAE8038767BF0FBEE26B3470C0FC4AE60E5229DF* ___elements_0;
// UnityEngine.UIElements.StyleSheets.StylePropertyId[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::properties
StylePropertyIdU5BU5D_t6A118EB2D7976A5AE0C4E89D3F53D4454EC7E359* ___properties_1;
// TTimingData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::timing
TimingDataU5BU5D_t634CA6261A1EDA23867D38722881D8D9610065E3* ___timing_2;
// TStyleData[] UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::style
StyleDataU5BU5D_tAD21796096D8CBCE199118430F1C659AA1DFB822* ___style_3;
// System.Int32 UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::count
int32_t ___count_4;
// System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StylePropertyAnimationSystem/ElementPropertyPair,System.Int32> UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2::indices
Dictionary_2_tF099D849028F7351B6B99091102D4A3417711574* ___indices_5;
};
// UnityEngine.Timeline.IntervalTree`1/Entry<System.Object>
struct Entry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E
{
// System.Int64 UnityEngine.Timeline.IntervalTree`1/Entry::intervalStart
int64_t ___intervalStart_0;
// System.Int64 UnityEngine.Timeline.IntervalTree`1/Entry::intervalEnd
int64_t ___intervalEnd_1;
// T UnityEngine.Timeline.IntervalTree`1/Entry::item
RuntimeObject* ___item_2;
};
// Unity.Collections.NativeSlice`1<UnityEngine.UIElements.UIR.DrawBufferRange>
struct NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974
{
// System.Byte* Unity.Collections.NativeSlice`1::m_Buffer
uint8_t* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeSlice`1::m_Stride
int32_t ___m_Stride_1;
// System.Int32 Unity.Collections.NativeSlice`1::m_Length
int32_t ___m_Length_2;
};
// Unity.Collections.NativeSlice`1<UnityEngine.UIElements.UIR.Transform3x4>
struct NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370
{
// System.Byte* Unity.Collections.NativeSlice`1::m_Buffer
uint8_t* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeSlice`1::m_Stride
int32_t ___m_Stride_1;
// System.Int32 Unity.Collections.NativeSlice`1::m_Length
int32_t ___m_Length_2;
};
// Unity.Collections.NativeSlice`1<System.UInt16>
struct NativeSlice_1_t0D1A1AB7A9C4768B84EB7420D04A90920533C78A
{
// System.Byte* Unity.Collections.NativeSlice`1::m_Buffer
uint8_t* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeSlice`1::m_Stride
int32_t ___m_Stride_1;
// System.Int32 Unity.Collections.NativeSlice`1::m_Length
int32_t ___m_Length_2;
};
// Unity.Collections.NativeSlice`1<UnityEngine.Vector4>
struct NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F
{
// System.Byte* Unity.Collections.NativeSlice`1::m_Buffer
uint8_t* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeSlice`1::m_Stride
int32_t ___m_Stride_1;
// System.Int32 Unity.Collections.NativeSlice`1::m_Length
int32_t ___m_Length_2;
};
// Unity.Collections.NativeSlice`1<UnityEngine.UIElements.Vertex>
struct NativeSlice_1_t66375568C4FF313931F4D2F646D64FE6A406BAD2
{
// System.Byte* Unity.Collections.NativeSlice`1::m_Buffer
uint8_t* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeSlice`1::m_Stride
int32_t ___m_Stride_1;
// System.Int32 Unity.Collections.NativeSlice`1::m_Length
int32_t ___m_Length_2;
};
// System.Nullable`1<System.Boolean>
struct Nullable_1_t78F453FADB4A9F50F267A4E349019C34410D1A01
{
// System.Boolean System.Nullable`1::hasValue
bool ___hasValue_0;
// T System.Nullable`1::value
bool ___value_1;
};
// UnityEngine.UIElements.StyleDataRef`1<UnityEngine.UIElements.InheritedData>
struct StyleDataRef_1_tBB9987581539847AE5CCA2EA2349E05CDC9127FA
{
// UnityEngine.UIElements.StyleDataRef`1/RefCounted<T> UnityEngine.UIElements.StyleDataRef`1::m_Ref
RefCounted_t6B975CD3D06E8D955346FC0D66E8F6E449D49A44* ___m_Ref_0;
};
// UnityEngine.UIElements.StyleDataRef`1<UnityEngine.UIElements.LayoutData>
struct StyleDataRef_1_t5330A6F4EAC0EAB88E3B9849D866AA23BB6BE5F4
{
// UnityEngine.UIElements.StyleDataRef`1/RefCounted<T> UnityEngine.UIElements.StyleDataRef`1::m_Ref
RefCounted_t0E133AD36715877AE1CE72539A0199B4D3AA8CD1* ___m_Ref_0;
};
// UnityEngine.UIElements.StyleDataRef`1<UnityEngine.UIElements.RareData>
struct StyleDataRef_1_tF773E9CBC6DC0FEB38DF95A6F3F47AC49AE045B3
{
// UnityEngine.UIElements.StyleDataRef`1/RefCounted<T> UnityEngine.UIElements.StyleDataRef`1::m_Ref
RefCounted_t81BCBAE57D930C934CF7A439452D65303AC6A8CD* ___m_Ref_0;
};
// UnityEngine.UIElements.StyleDataRef`1<UnityEngine.UIElements.TransformData>
struct StyleDataRef_1_t1D59CCAB740BE6B330D5B5FDA9F67391800200B3
{
// UnityEngine.UIElements.StyleDataRef`1/RefCounted<T> UnityEngine.UIElements.StyleDataRef`1::m_Ref
RefCounted_t78303B1CD3D08C664ABB15EBD7C882DA3E06CF7D* ___m_Ref_0;
};
// UnityEngine.UIElements.StyleDataRef`1<UnityEngine.UIElements.TransitionData>
struct StyleDataRef_1_t6A7B146DD79EDF7F42CD8CCF3E411B40AA729B8E
{
// UnityEngine.UIElements.StyleDataRef`1/RefCounted<T> UnityEngine.UIElements.StyleDataRef`1::m_Ref
RefCounted_tA9FB4D63A1064BD322AFDFCD70319CB384C057D9* ___m_Ref_0;
};
// UnityEngine.UIElements.StyleDataRef`1<UnityEngine.UIElements.VisualData>
struct StyleDataRef_1_t9CB834B90E638D92A3BE5123B0D3989697AA87FC
{
// UnityEngine.UIElements.StyleDataRef`1/RefCounted<T> UnityEngine.UIElements.StyleDataRef`1::m_Ref
RefCounted_t812D790A2C787F18230F9234F6C9B84D4AC1A85A* ___m_Ref_0;
};
// UnityEngine.UIElements.UQueryState`1<System.Object>
struct UQueryState_1_tDA47936DEF27643350186CA4E1DED7053A3D02B2
{
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.UQueryState`1::m_Element
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___m_Element_1;
// System.Collections.Generic.List`1<UnityEngine.UIElements.RuleMatcher> UnityEngine.UIElements.UQueryState`1::m_Matchers
List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC* ___m_Matchers_2;
};
struct UQueryState_1_tDA47936DEF27643350186CA4E1DED7053A3D02B2_StaticFields
{
// UnityEngine.UIElements.UQueryState`1/ActionQueryMatcher<T> UnityEngine.UIElements.UQueryState`1::s_Action
ActionQueryMatcher_tB76860A856401075A2CF71D45AC72A9C0F1BB99E* ___s_Action_0;
// UnityEngine.UIElements.UQueryState`1/ListQueryMatcher`1<T,T> UnityEngine.UIElements.UQueryState`1::s_List
ListQueryMatcher_1_t4D10BEF648526B008BEB75C8576A7D1EBFD73A83* ___s_List_3;
// UnityEngine.UIElements.UQueryState`1/ListQueryMatcher`1<T,UnityEngine.UIElements.VisualElement> UnityEngine.UIElements.UQueryState`1::s_EnumerationList
ListQueryMatcher_1_tC447E3396770813CE332360F6EECEEFB6B51FA69* ___s_EnumerationList_4;
};
// UnityEngine.UIElements.UQueryState`1<UnityEngine.UIElements.VisualElement>
struct UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA
{
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.UQueryState`1::m_Element
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___m_Element_1;
// System.Collections.Generic.List`1<UnityEngine.UIElements.RuleMatcher> UnityEngine.UIElements.UQueryState`1::m_Matchers
List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC* ___m_Matchers_2;
};
struct UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA_StaticFields
{
// UnityEngine.UIElements.UQueryState`1/ActionQueryMatcher<T> UnityEngine.UIElements.UQueryState`1::s_Action
ActionQueryMatcher_tBA08813774EDD8920F40BFFC2F27B8329C7923DD* ___s_Action_0;
// UnityEngine.UIElements.UQueryState`1/ListQueryMatcher`1<T,T> UnityEngine.UIElements.UQueryState`1::s_List
ListQueryMatcher_1_t7F21A0BB6BC47F1797366366A8E33731906C2940* ___s_List_3;
// UnityEngine.UIElements.UQueryState`1/ListQueryMatcher`1<T,UnityEngine.UIElements.VisualElement> UnityEngine.UIElements.UQueryState`1::s_EnumerationList
ListQueryMatcher_1_t7F21A0BB6BC47F1797366366A8E33731906C2940* ___s_EnumerationList_4;
};
// System.ValueTuple`3<System.Object,System.Int32,System.Int32>
struct ValueTuple_3_tFD2ADB3DA89E958885034AAFEF1ABDA8C814D987
{
// T1 System.ValueTuple`3::Item1
RuntimeObject* ___Item1_0;
// T2 System.ValueTuple`3::Item2
int32_t ___Item2_1;
// T3 System.ValueTuple`3::Item3
int32_t ___Item3_2;
};
// UnityEngine.UIElements.UIR.Alloc
struct Alloc_t78312CFE58F38082281E80E297AE6176BD2BD8AE
{
// System.UInt32 UnityEngine.UIElements.UIR.Alloc::start
uint32_t ___start_0;
// System.UInt32 UnityEngine.UIElements.UIR.Alloc::size
uint32_t ___size_1;
// System.Object UnityEngine.UIElements.UIR.Alloc::handle
RuntimeObject* ___handle_2;
// System.Boolean UnityEngine.UIElements.UIR.Alloc::shortLived
bool ___shortLived_3;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.UIR.Alloc
struct Alloc_t78312CFE58F38082281E80E297AE6176BD2BD8AE_marshaled_pinvoke
{
uint32_t ___start_0;
uint32_t ___size_1;
Il2CppIUnknown* ___handle_2;
int32_t ___shortLived_3;
};
// Native definition for COM marshalling of UnityEngine.UIElements.UIR.Alloc
struct Alloc_t78312CFE58F38082281E80E297AE6176BD2BD8AE_marshaled_com
{
uint32_t ___start_0;
uint32_t ___size_1;
Il2CppIUnknown* ___handle_2;
int32_t ___shortLived_3;
};
// UnityEngine.AnimatorClipInfo
struct AnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03
{
// System.Int32 UnityEngine.AnimatorClipInfo::m_ClipInstanceID
int32_t ___m_ClipInstanceID_0;
// System.Single UnityEngine.AnimatorClipInfo::m_Weight
float ___m_Weight_1;
};
// UnityEngine.UIElements.Background
struct Background_t3C720DED4FAF016332D29FB86C9BE8D5D0D8F0C8
{
// UnityEngine.Texture2D UnityEngine.UIElements.Background::m_Texture
Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* ___m_Texture_0;
// UnityEngine.Sprite UnityEngine.UIElements.Background::m_Sprite
Sprite_tAFF74BC83CD68037494CB0B4F28CBDF8971CAB99* ___m_Sprite_1;
// UnityEngine.RenderTexture UnityEngine.UIElements.Background::m_RenderTexture
RenderTexture_tBA90C4C3AD9EECCFDDCC632D97C29FAB80D60D27* ___m_RenderTexture_2;
// UnityEngine.UIElements.VectorImage UnityEngine.UIElements.Background::m_VectorImage
VectorImage_t7BD8CE948377FFE95FCA0C48014ACDFC13B8F8FC* ___m_VectorImage_3;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.Background
struct Background_t3C720DED4FAF016332D29FB86C9BE8D5D0D8F0C8_marshaled_pinvoke
{
Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* ___m_Texture_0;
Sprite_tAFF74BC83CD68037494CB0B4F28CBDF8971CAB99* ___m_Sprite_1;
RenderTexture_tBA90C4C3AD9EECCFDDCC632D97C29FAB80D60D27* ___m_RenderTexture_2;
VectorImage_t7BD8CE948377FFE95FCA0C48014ACDFC13B8F8FC* ___m_VectorImage_3;
};
// Native definition for COM marshalling of UnityEngine.UIElements.Background
struct Background_t3C720DED4FAF016332D29FB86C9BE8D5D0D8F0C8_marshaled_com
{
Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* ___m_Texture_0;
Sprite_tAFF74BC83CD68037494CB0B4F28CBDF8971CAB99* ___m_Sprite_1;
RenderTexture_tBA90C4C3AD9EECCFDDCC632D97C29FAB80D60D27* ___m_RenderTexture_2;
VectorImage_t7BD8CE948377FFE95FCA0C48014ACDFC13B8F8FC* ___m_VectorImage_3;
};
// UnityEngine.Rendering.BatchVisibility
struct BatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA
{
// System.Int32 UnityEngine.Rendering.BatchVisibility::offset
int32_t ___offset_0;
// System.Int32 UnityEngine.Rendering.BatchVisibility::instancesCount
int32_t ___instancesCount_1;
// System.Int32 UnityEngine.Rendering.BatchVisibility::visibleCount
int32_t ___visibleCount_2;
};
// System.Boolean
struct Boolean_t09A6377A54BE2F9E6985A8149F19234FD7DDFE22
{
// System.Boolean System.Boolean::m_value
bool ___m_value_0;
};
struct Boolean_t09A6377A54BE2F9E6985A8149F19234FD7DDFE22_StaticFields
{
// System.String System.Boolean::TrueString
String_t* ___TrueString_5;
// System.String System.Boolean::FalseString
String_t* ___FalseString_6;
};
// System.Byte
struct Byte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3
{
// System.Byte System.Byte::m_value
uint8_t ___m_value_0;
};
// System.Threading.CancellationToken
struct CancellationToken_t51142D9C6D7C02D314DA34A6A7988C528992FFED
{
// System.Threading.CancellationTokenSource System.Threading.CancellationToken::_source
CancellationTokenSource_tAAE1E0033BCFC233801F8CB4CED5C852B350CB7B* ____source_0;
};
struct CancellationToken_t51142D9C6D7C02D314DA34A6A7988C528992FFED_StaticFields
{
// System.Action`1<System.Object> System.Threading.CancellationToken::s_actionToActionObjShunt
Action_1_t6F9EB113EB3F16226AEF811A2744F4111C116C87* ___s_actionToActionObjShunt_1;
};
// Native definition for P/Invoke marshalling of System.Threading.CancellationToken
struct CancellationToken_t51142D9C6D7C02D314DA34A6A7988C528992FFED_marshaled_pinvoke
{
CancellationTokenSource_tAAE1E0033BCFC233801F8CB4CED5C852B350CB7B* ____source_0;
};
// Native definition for COM marshalling of System.Threading.CancellationToken
struct CancellationToken_t51142D9C6D7C02D314DA34A6A7988C528992FFED_marshaled_com
{
CancellationTokenSource_tAAE1E0033BCFC233801F8CB4CED5C852B350CB7B* ____source_0;
};
// System.Char
struct Char_t521A6F19B456D956AF452D926C32709DC03D6B17
{
// System.Char System.Char::m_value
Il2CppChar ___m_value_0;
};
struct Char_t521A6F19B456D956AF452D926C32709DC03D6B17_StaticFields
{
// System.Byte[] System.Char::s_categoryForLatin1
ByteU5BU5D_tA6237BF417AE52AD70CFB4EF24A7A82613DF9031* ___s_categoryForLatin1_3;
};
// UnityEngine.Color
struct Color_tD001788D726C3A7F1379BEED0260B9591F440C1F
{
// System.Single UnityEngine.Color::r
float ___r_0;
// System.Single UnityEngine.Color::g
float ___g_1;
// System.Single UnityEngine.Color::b
float ___b_2;
// System.Single UnityEngine.Color::a
float ___a_3;
};
// UnityEngine.Color32
struct Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B
{
union
{
#pragma pack(push, tp, 1)
struct
{
// System.Int32 UnityEngine.Color32::rgba
int32_t ___rgba_0;
};
#pragma pack(pop, tp)
struct
{
int32_t ___rgba_0_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
// System.Byte UnityEngine.Color32::r
uint8_t ___r_1;
};
#pragma pack(pop, tp)
struct
{
uint8_t ___r_1_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___g_2_OffsetPadding[1];
// System.Byte UnityEngine.Color32::g
uint8_t ___g_2;
};
#pragma pack(pop, tp)
struct
{
char ___g_2_OffsetPadding_forAlignmentOnly[1];
uint8_t ___g_2_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___b_3_OffsetPadding[2];
// System.Byte UnityEngine.Color32::b
uint8_t ___b_3;
};
#pragma pack(pop, tp)
struct
{
char ___b_3_OffsetPadding_forAlignmentOnly[2];
uint8_t ___b_3_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___a_4_OffsetPadding[3];
// System.Byte UnityEngine.Color32::a
uint8_t ___a_4;
};
#pragma pack(pop, tp)
struct
{
char ___a_4_OffsetPadding_forAlignmentOnly[3];
uint8_t ___a_4_forAlignmentOnly;
};
};
};
// UnityEngine.UIElements.CreationContext
struct CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257
{
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.CreationContext::<target>k__BackingField
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___U3CtargetU3Ek__BackingField_1;
// UnityEngine.UIElements.VisualTreeAsset UnityEngine.UIElements.CreationContext::<visualTreeAsset>k__BackingField
VisualTreeAsset_tFB5BF81F0780A412AE5A7C2C552B3EEA64EA2EEB* ___U3CvisualTreeAssetU3Ek__BackingField_2;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.UIElements.VisualElement> UnityEngine.UIElements.CreationContext::<slotInsertionPoints>k__BackingField
Dictionary_2_t41165BF747F041590086BE39A59BE164430A3CEF* ___U3CslotInsertionPointsU3Ek__BackingField_3;
// System.Collections.Generic.List`1<UnityEngine.UIElements.TemplateAsset/AttributeOverride> UnityEngine.UIElements.CreationContext::<attributeOverrides>k__BackingField
List_1_t70EE7982F45810D4B024CF720D910E67974A3094* ___U3CattributeOverridesU3Ek__BackingField_4;
};
struct CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257_StaticFields
{
// UnityEngine.UIElements.CreationContext UnityEngine.UIElements.CreationContext::Default
CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 ___Default_0;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.CreationContext
struct CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257_marshaled_pinvoke
{
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___U3CtargetU3Ek__BackingField_1;
VisualTreeAsset_tFB5BF81F0780A412AE5A7C2C552B3EEA64EA2EEB* ___U3CvisualTreeAssetU3Ek__BackingField_2;
Dictionary_2_t41165BF747F041590086BE39A59BE164430A3CEF* ___U3CslotInsertionPointsU3Ek__BackingField_3;
List_1_t70EE7982F45810D4B024CF720D910E67974A3094* ___U3CattributeOverridesU3Ek__BackingField_4;
};
// Native definition for COM marshalling of UnityEngine.UIElements.CreationContext
struct CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257_marshaled_com
{
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___U3CtargetU3Ek__BackingField_1;
VisualTreeAsset_tFB5BF81F0780A412AE5A7C2C552B3EEA64EA2EEB* ___U3CvisualTreeAssetU3Ek__BackingField_2;
Dictionary_2_t41165BF747F041590086BE39A59BE164430A3CEF* ___U3CslotInsertionPointsU3Ek__BackingField_3;
List_1_t70EE7982F45810D4B024CF720D910E67974A3094* ___U3CattributeOverridesU3Ek__BackingField_4;
};
// System.Decimal
struct Decimal_tDA6C877282B2D789CF97C0949661CC11D643969F
{
union
{
#pragma pack(push, tp, 1)
struct
{
// System.Int32 System.Decimal::flags
int32_t ___flags_5;
};
#pragma pack(pop, tp)
struct
{
int32_t ___flags_5_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___hi_6_OffsetPadding[4];
// System.Int32 System.Decimal::hi
int32_t ___hi_6;
};
#pragma pack(pop, tp)
struct
{
char ___hi_6_OffsetPadding_forAlignmentOnly[4];
int32_t ___hi_6_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___lo_7_OffsetPadding[8];
// System.Int32 System.Decimal::lo
int32_t ___lo_7;
};
#pragma pack(pop, tp)
struct
{
char ___lo_7_OffsetPadding_forAlignmentOnly[8];
int32_t ___lo_7_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___mid_8_OffsetPadding[12];
// System.Int32 System.Decimal::mid
int32_t ___mid_8;
};
#pragma pack(pop, tp)
struct
{
char ___mid_8_OffsetPadding_forAlignmentOnly[12];
int32_t ___mid_8_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___ulomidLE_9_OffsetPadding[8];
// System.UInt64 System.Decimal::ulomidLE
uint64_t ___ulomidLE_9;
};
#pragma pack(pop, tp)
struct
{
char ___ulomidLE_9_OffsetPadding_forAlignmentOnly[8];
uint64_t ___ulomidLE_9_forAlignmentOnly;
};
};
};
struct Decimal_tDA6C877282B2D789CF97C0949661CC11D643969F_StaticFields
{
// System.Decimal System.Decimal::Zero
Decimal_tDA6C877282B2D789CF97C0949661CC11D643969F ___Zero_0;
// System.Decimal System.Decimal::One
Decimal_tDA6C877282B2D789CF97C0949661CC11D643969F ___One_1;
// System.Decimal System.Decimal::MinusOne
Decimal_tDA6C877282B2D789CF97C0949661CC11D643969F ___MinusOne_2;
// System.Decimal System.Decimal::MaxValue
Decimal_tDA6C877282B2D789CF97C0949661CC11D643969F ___MaxValue_3;
// System.Decimal System.Decimal::MinValue
Decimal_tDA6C877282B2D789CF97C0949661CC11D643969F ___MinValue_4;
};
// UnityEngine.Timeline.DiscreteTime
struct DiscreteTime_t1598D60B0B2432F702E2A6120D04369EE54600A6
{
// System.Int64 UnityEngine.Timeline.DiscreteTime::m_DiscreteTime
int64_t ___m_DiscreteTime_2;
};
struct DiscreteTime_t1598D60B0B2432F702E2A6120D04369EE54600A6_StaticFields
{
// UnityEngine.Timeline.DiscreteTime UnityEngine.Timeline.DiscreteTime::kMaxTime
DiscreteTime_t1598D60B0B2432F702E2A6120D04369EE54600A6 ___kMaxTime_1;
};
// System.Double
struct Double_tE150EF3D1D43DEE85D533810AB4C742307EEDE5F
{
// System.Double System.Double::m_value
double ___m_value_0;
};
// ClipperLib.DoublePoint
struct DoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001
{
// System.Double ClipperLib.DoublePoint::X
double ___X_0;
// System.Double ClipperLib.DoublePoint::Y
double ___Y_1;
};
// UnityEngine.UIElements.UIR.DrawBufferRange
struct DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4
{
// System.Int32 UnityEngine.UIElements.UIR.DrawBufferRange::firstIndex
int32_t ___firstIndex_0;
// System.Int32 UnityEngine.UIElements.UIR.DrawBufferRange::indexCount
int32_t ___indexCount_1;
// System.Int32 UnityEngine.UIElements.UIR.DrawBufferRange::minIndexVal
int32_t ___minIndexVal_2;
// System.Int32 UnityEngine.UIElements.UIR.DrawBufferRange::vertsReferenced
int32_t ___vertsReferenced_3;
};
// System.Enum
struct Enum_t2A1A94B24E3B776EEF4E5E485E290BB9D4D072E2 : public ValueType_t6D9B272BD21782F0A9A14F2E41F85A50E97A986F
{
};
struct Enum_t2A1A94B24E3B776EEF4E5E485E290BB9D4D072E2_StaticFields
{
// System.Char[] System.Enum::enumSeperatorCharArray
CharU5BU5D_t799905CF001DD5F13F7DBB310181FC4D8B7D0AAB* ___enumSeperatorCharArray_0;
};
// Native definition for P/Invoke marshalling of System.Enum
struct Enum_t2A1A94B24E3B776EEF4E5E485E290BB9D4D072E2_marshaled_pinvoke
{
};
// Native definition for COM marshalling of System.Enum
struct Enum_t2A1A94B24E3B776EEF4E5E485E290BB9D4D072E2_marshaled_com
{
};
// UnityEngine.EnumData
struct EnumData_tB9520C9179D9D6C57B2BF70E76FE4EB4DC94A6F8
{
// System.Enum[] UnityEngine.EnumData::values
EnumU5BU5D_t6106A94708E3435454078BF14FA50152B7301912* ___values_0;
// System.Int32[] UnityEngine.EnumData::flagValues
Int32U5BU5D_t19C97395396A72ECAF310612F0760F165060314C* ___flagValues_1;
// System.String[] UnityEngine.EnumData::displayNames
StringU5BU5D_t7674CD946EC0CE7B3AE0BE70E6EE85F2ECD9F248* ___displayNames_2;
// System.String[] UnityEngine.EnumData::tooltip
StringU5BU5D_t7674CD946EC0CE7B3AE0BE70E6EE85F2ECD9F248* ___tooltip_3;
// System.Boolean UnityEngine.EnumData::flags
bool ___flags_4;
// System.Type UnityEngine.EnumData::underlyingType
Type_t* ___underlyingType_5;
// System.Boolean UnityEngine.EnumData::unsigned
bool ___unsigned_6;
// System.Boolean UnityEngine.EnumData::serializable
bool ___serializable_7;
};
// Native definition for P/Invoke marshalling of UnityEngine.EnumData
struct EnumData_tB9520C9179D9D6C57B2BF70E76FE4EB4DC94A6F8_marshaled_pinvoke
{
EnumU5BU5D_t6106A94708E3435454078BF14FA50152B7301912* ___values_0;
Il2CppSafeArray/*NONE*/* ___flagValues_1;
char** ___displayNames_2;
char** ___tooltip_3;
int32_t ___flags_4;
Type_t* ___underlyingType_5;
int32_t ___unsigned_6;
int32_t ___serializable_7;
};
// Native definition for COM marshalling of UnityEngine.EnumData
struct EnumData_tB9520C9179D9D6C57B2BF70E76FE4EB4DC94A6F8_marshaled_com
{
EnumU5BU5D_t6106A94708E3435454078BF14FA50152B7301912* ___values_0;
Il2CppSafeArray/*NONE*/* ___flagValues_1;
Il2CppChar** ___displayNames_2;
Il2CppChar** ___tooltip_3;
int32_t ___flags_4;
Type_t* ___underlyingType_5;
int32_t ___unsigned_6;
int32_t ___serializable_7;
};
// UnityEngine.UIElements.Focusable
struct Focusable_t39F2BAF0AF6CA465BC2BEDAF9B5B2CF379B846D0 : public CallbackEventHandler_t99E35735225B4ACEAD1BA981632FD2D46E9CB2B4
{
// System.Boolean UnityEngine.UIElements.Focusable::<focusable>k__BackingField
bool ___U3CfocusableU3Ek__BackingField_3;
// System.Int32 UnityEngine.UIElements.Focusable::<tabIndex>k__BackingField
int32_t ___U3CtabIndexU3Ek__BackingField_4;
// System.Boolean UnityEngine.UIElements.Focusable::m_DelegatesFocus
bool ___m_DelegatesFocus_5;
// System.Boolean UnityEngine.UIElements.Focusable::m_ExcludeFromFocusRing
bool ___m_ExcludeFromFocusRing_6;
// System.Boolean UnityEngine.UIElements.Focusable::isIMGUIContainer
bool ___isIMGUIContainer_7;
};
// UnityEngine.UIElements.FontDefinition
struct FontDefinition_t65281B0E106365C28AD3F2525DE148719AEEA30C
{
// UnityEngine.Font UnityEngine.UIElements.FontDefinition::m_Font
Font_tC95270EA3198038970422D78B74A7F2E218A96B6* ___m_Font_0;
// UnityEngine.TextCore.Text.FontAsset UnityEngine.UIElements.FontDefinition::m_FontAsset
FontAsset_t61A6446D934E582651044E33D250EA8D306AB958* ___m_FontAsset_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.FontDefinition
struct FontDefinition_t65281B0E106365C28AD3F2525DE148719AEEA30C_marshaled_pinvoke
{
Font_tC95270EA3198038970422D78B74A7F2E218A96B6* ___m_Font_0;
FontAsset_t61A6446D934E582651044E33D250EA8D306AB958* ___m_FontAsset_1;
};
// Native definition for COM marshalling of UnityEngine.UIElements.FontDefinition
struct FontDefinition_t65281B0E106365C28AD3F2525DE148719AEEA30C_marshaled_com
{
Font_tC95270EA3198038970422D78B74A7F2E218A96B6* ___m_Font_0;
FontAsset_t61A6446D934E582651044E33D250EA8D306AB958* ___m_FontAsset_1;
};
// UnityEngine.TextCore.Text.GlyphAnchorPoint
struct GlyphAnchorPoint_t5B67FFC3E40D32105FADE04ED0A705F66C992A24
{
// System.Single UnityEngine.TextCore.Text.GlyphAnchorPoint::m_XCoordinate
float ___m_XCoordinate_0;
// System.Single UnityEngine.TextCore.Text.GlyphAnchorPoint::m_YCoordinate
float ___m_YCoordinate_1;
};
// UnityEngine.TextCore.GlyphRect
struct GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D
{
// System.Int32 UnityEngine.TextCore.GlyphRect::m_X
int32_t ___m_X_0;
// System.Int32 UnityEngine.TextCore.GlyphRect::m_Y
int32_t ___m_Y_1;
// System.Int32 UnityEngine.TextCore.GlyphRect::m_Width
int32_t ___m_Width_2;
// System.Int32 UnityEngine.TextCore.GlyphRect::m_Height
int32_t ___m_Height_3;
};
struct GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D_StaticFields
{
// UnityEngine.TextCore.GlyphRect UnityEngine.TextCore.GlyphRect::s_ZeroGlyphRect
GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D ___s_ZeroGlyphRect_4;
};
// UnityEngine.TextCore.LowLevel.GlyphValueRecord
struct GlyphValueRecord_t780927A39D46924E0D546A2AE5DDF1BB2B5A9C8E
{
// System.Single UnityEngine.TextCore.LowLevel.GlyphValueRecord::m_XPlacement
float ___m_XPlacement_0;
// System.Single UnityEngine.TextCore.LowLevel.GlyphValueRecord::m_YPlacement
float ___m_YPlacement_1;
// System.Single UnityEngine.TextCore.LowLevel.GlyphValueRecord::m_XAdvance
float ___m_XAdvance_2;
// System.Single UnityEngine.TextCore.LowLevel.GlyphValueRecord::m_YAdvance
float ___m_YAdvance_3;
};
// System.Int32
struct Int32_t680FF22E76F6EFAD4375103CBBFFA0421349384C
{
// System.Int32 System.Int32::m_value
int32_t ___m_value_0;
};
// System.Int64
struct Int64_t092CFB123BE63C28ACDAF65C68F21A526050DBA3
{
// System.Int64 System.Int64::m_value
int64_t ___m_value_0;
};
// ClipperLib.IntPoint
struct IntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B
{
// System.Int64 ClipperLib.IntPoint::X
int64_t ___X_0;
// System.Int64 ClipperLib.IntPoint::Y
int64_t ___Y_1;
};
// System.IntPtr
struct IntPtr_t
{
// System.Void* System.IntPtr::m_value
void* ___m_value_0;
};
struct IntPtr_t_StaticFields
{
// System.IntPtr System.IntPtr::Zero
intptr_t ___Zero_1;
};
// UnityEngine.Timeline.IntervalTreeNode
struct IntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC
{
// System.Int64 UnityEngine.Timeline.IntervalTreeNode::center
int64_t ___center_0;
// System.Int32 UnityEngine.Timeline.IntervalTreeNode::first
int32_t ___first_1;
// System.Int32 UnityEngine.Timeline.IntervalTreeNode::last
int32_t ___last_2;
// System.Int32 UnityEngine.Timeline.IntervalTreeNode::left
int32_t ___left_3;
// System.Int32 UnityEngine.Timeline.IntervalTreeNode::right
int32_t ___right_4;
};
// UnityEngine.TextCore.Text.LigatureSubstitutionRecord
struct LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27
{
// System.UInt32[] UnityEngine.TextCore.Text.LigatureSubstitutionRecord::m_ComponentGlyphIDs
UInt32U5BU5D_t02FBD658AD156A17574ECE6106CF1FBFCC9807FA* ___m_ComponentGlyphIDs_0;
// System.UInt32 UnityEngine.TextCore.Text.LigatureSubstitutionRecord::m_LigatureGlyphID
uint32_t ___m_LigatureGlyphID_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.TextCore.Text.LigatureSubstitutionRecord
struct LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27_marshaled_pinvoke
{
Il2CppSafeArray/*NONE*/* ___m_ComponentGlyphIDs_0;
uint32_t ___m_LigatureGlyphID_1;
};
// Native definition for COM marshalling of UnityEngine.TextCore.Text.LigatureSubstitutionRecord
struct LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27_marshaled_com
{
Il2CppSafeArray/*NONE*/* ___m_ComponentGlyphIDs_0;
uint32_t ___m_LigatureGlyphID_1;
};
// UnityEngine.Experimental.GlobalIllumination.LinearColor
struct LinearColor_t60964F15C567D7FE5442C29298DCF20ABD8816C7
{
// System.Single UnityEngine.Experimental.GlobalIllumination.LinearColor::m_red
float ___m_red_0;
// System.Single UnityEngine.Experimental.GlobalIllumination.LinearColor::m_green
float ___m_green_1;
// System.Single UnityEngine.Experimental.GlobalIllumination.LinearColor::m_blue
float ___m_blue_2;
// System.Single UnityEngine.Experimental.GlobalIllumination.LinearColor::m_intensity
float ___m_intensity_3;
};
// UnityEngine.TextCore.Text.LinkInfo
struct LinkInfo_tE85DDAFDFBDA635E6405C88EE4FD5941A9243DD8
{
// System.Int32 UnityEngine.TextCore.Text.LinkInfo::hashCode
int32_t ___hashCode_0;
// System.Int32 UnityEngine.TextCore.Text.LinkInfo::linkIdFirstCharacterIndex
int32_t ___linkIdFirstCharacterIndex_1;
// System.Int32 UnityEngine.TextCore.Text.LinkInfo::linkIdLength
int32_t ___linkIdLength_2;
// System.Int32 UnityEngine.TextCore.Text.LinkInfo::linkTextfirstCharacterIndex
int32_t ___linkTextfirstCharacterIndex_3;
// System.Int32 UnityEngine.TextCore.Text.LinkInfo::linkTextLength
int32_t ___linkTextLength_4;
// System.Char[] UnityEngine.TextCore.Text.LinkInfo::linkId
CharU5BU5D_t799905CF001DD5F13F7DBB310181FC4D8B7D0AAB* ___linkId_5;
};
// Native definition for P/Invoke marshalling of UnityEngine.TextCore.Text.LinkInfo
struct LinkInfo_tE85DDAFDFBDA635E6405C88EE4FD5941A9243DD8_marshaled_pinvoke
{
int32_t ___hashCode_0;
int32_t ___linkIdFirstCharacterIndex_1;
int32_t ___linkIdLength_2;
int32_t ___linkTextfirstCharacterIndex_3;
int32_t ___linkTextLength_4;
uint8_t* ___linkId_5;
};
// Native definition for COM marshalling of UnityEngine.TextCore.Text.LinkInfo
struct LinkInfo_tE85DDAFDFBDA635E6405C88EE4FD5941A9243DD8_marshaled_com
{
int32_t ___hashCode_0;
int32_t ___linkIdFirstCharacterIndex_1;
int32_t ___linkIdLength_2;
int32_t ___linkTextfirstCharacterIndex_3;
int32_t ___linkTextLength_4;
uint8_t* ___linkId_5;
};
// UnityEngine.TextCore.Text.MarkPositionAdjustment
struct MarkPositionAdjustment_t437B0951674D336156DE28F420A9DE902978D639
{
// System.Single UnityEngine.TextCore.Text.MarkPositionAdjustment::m_XPositionAdjustment
float ___m_XPositionAdjustment_0;
// System.Single UnityEngine.TextCore.Text.MarkPositionAdjustment::m_YPositionAdjustment
float ___m_YPositionAdjustment_1;
};
// UnityEngine.Timeline.MarkerList
struct MarkerList_tD4B632EBA98CE678EB8D108A1AF559F734FA7698
{
// System.Collections.Generic.List`1<UnityEngine.ScriptableObject> UnityEngine.Timeline.MarkerList::m_Objects
List_1_tF941E9C3FEB6F1C2D20E73A90AA7F6319EB3F828* ___m_Objects_0;
// System.Collections.Generic.List`1<UnityEngine.Timeline.IMarker> UnityEngine.Timeline.MarkerList::m_Cache
List_1_tB481045C42962DD282E8A89B2AF0246A4042EADF* ___m_Cache_1;
// System.Boolean UnityEngine.Timeline.MarkerList::m_CacheDirty
bool ___m_CacheDirty_2;
// System.Boolean UnityEngine.Timeline.MarkerList::m_HasNotifications
bool ___m_HasNotifications_3;
};
// Native definition for P/Invoke marshalling of UnityEngine.Timeline.MarkerList
struct MarkerList_tD4B632EBA98CE678EB8D108A1AF559F734FA7698_marshaled_pinvoke
{
List_1_tF941E9C3FEB6F1C2D20E73A90AA7F6319EB3F828* ___m_Objects_0;
List_1_tB481045C42962DD282E8A89B2AF0246A4042EADF* ___m_Cache_1;
int32_t ___m_CacheDirty_2;
int32_t ___m_HasNotifications_3;
};
// Native definition for COM marshalling of UnityEngine.Timeline.MarkerList
struct MarkerList_tD4B632EBA98CE678EB8D108A1AF559F734FA7698_marshaled_com
{
List_1_tF941E9C3FEB6F1C2D20E73A90AA7F6319EB3F828* ___m_Objects_0;
List_1_tB481045C42962DD282E8A89B2AF0246A4042EADF* ___m_Cache_1;
int32_t ___m_CacheDirty_2;
int32_t ___m_HasNotifications_3;
};
// UnityEngine.Matrix4x4
struct Matrix4x4_tDB70CF134A14BA38190C59AA700BCE10E2AED3E6
{
// System.Single UnityEngine.Matrix4x4::m00
float ___m00_0;
// System.Single UnityEngine.Matrix4x4::m10
float ___m10_1;
// System.Single UnityEngine.Matrix4x4::m20
float ___m20_2;
// System.Single UnityEngine.Matrix4x4::m30
float ___m30_3;
// System.Single UnityEngine.Matrix4x4::m01
float ___m01_4;
// System.Single UnityEngine.Matrix4x4::m11
float ___m11_5;
// System.Single UnityEngine.Matrix4x4::m21
float ___m21_6;
// System.Single UnityEngine.Matrix4x4::m31
float ___m31_7;
// System.Single UnityEngine.Matrix4x4::m02
float ___m02_8;
// System.Single UnityEngine.Matrix4x4::m12
float ___m12_9;
// System.Single UnityEngine.Matrix4x4::m22
float ___m22_10;
// System.Single UnityEngine.Matrix4x4::m32
float ___m32_11;
// System.Single UnityEngine.Matrix4x4::m03
float ___m03_12;
// System.Single UnityEngine.Matrix4x4::m13
float ___m13_13;
// System.Single UnityEngine.Matrix4x4::m23
float ___m23_14;
// System.Single UnityEngine.Matrix4x4::m33
float ___m33_15;
};
struct Matrix4x4_tDB70CF134A14BA38190C59AA700BCE10E2AED3E6_StaticFields
{
// UnityEngine.Matrix4x4 UnityEngine.Matrix4x4::zeroMatrix
Matrix4x4_tDB70CF134A14BA38190C59AA700BCE10E2AED3E6 ___zeroMatrix_16;
// UnityEngine.Matrix4x4 UnityEngine.Matrix4x4::identityMatrix
Matrix4x4_tDB70CF134A14BA38190C59AA700BCE10E2AED3E6 ___identityMatrix_17;
};
// UnityEngine.TextCore.Text.MultipleSubstitutionRecord
struct MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC
{
// System.UInt32 UnityEngine.TextCore.Text.MultipleSubstitutionRecord::m_TargetGlyphID
uint32_t ___m_TargetGlyphID_0;
// System.UInt32[] UnityEngine.TextCore.Text.MultipleSubstitutionRecord::m_SubstituteGlyphIDs
UInt32U5BU5D_t02FBD658AD156A17574ECE6106CF1FBFCC9807FA* ___m_SubstituteGlyphIDs_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.TextCore.Text.MultipleSubstitutionRecord
struct MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC_marshaled_pinvoke
{
uint32_t ___m_TargetGlyphID_0;
Il2CppSafeArray/*NONE*/* ___m_SubstituteGlyphIDs_1;
};
// Native definition for COM marshalling of UnityEngine.TextCore.Text.MultipleSubstitutionRecord
struct MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC_marshaled_com
{
uint32_t ___m_TargetGlyphID_0;
Il2CppSafeArray/*NONE*/* ___m_SubstituteGlyphIDs_1;
};
// UnityEngine.TextCore.Text.PageInfo
struct PageInfo_tFFF6B289E9A37E4D69353B32F941421180DA5909
{
// System.Int32 UnityEngine.TextCore.Text.PageInfo::firstCharacterIndex
int32_t ___firstCharacterIndex_0;
// System.Int32 UnityEngine.TextCore.Text.PageInfo::lastCharacterIndex
int32_t ___lastCharacterIndex_1;
// System.Single UnityEngine.TextCore.Text.PageInfo::ascender
float ___ascender_2;
// System.Single UnityEngine.TextCore.Text.PageInfo::baseLine
float ___baseLine_3;
// System.Single UnityEngine.TextCore.Text.PageInfo::descender
float ___descender_4;
};
// UnityEngine.PropertyName
struct PropertyName_tE4B4AAA58AF3BF2C0CD95509EB7B786F096901C2
{
// System.Int32 UnityEngine.PropertyName::id
int32_t ___id_0;
};
// UnityEngine.Quaternion
struct Quaternion_tDA59F214EF07D7700B26E40E562F267AF7306974
{
// System.Single UnityEngine.Quaternion::x
float ___x_0;
// System.Single UnityEngine.Quaternion::y
float ___y_1;
// System.Single UnityEngine.Quaternion::z
float ___z_2;
// System.Single UnityEngine.Quaternion::w
float ___w_3;
};
struct Quaternion_tDA59F214EF07D7700B26E40E562F267AF7306974_StaticFields
{
// UnityEngine.Quaternion UnityEngine.Quaternion::identityQuaternion
Quaternion_tDA59F214EF07D7700B26E40E562F267AF7306974 ___identityQuaternion_4;
};
// UnityEngine.Rect
struct Rect_tA04E0F8A1830E767F40FB27ECD8D309303571F0D
{
// System.Single UnityEngine.Rect::m_XMin
float ___m_XMin_0;
// System.Single UnityEngine.Rect::m_YMin
float ___m_YMin_1;
// System.Single UnityEngine.Rect::m_Width
float ___m_Width_2;
// System.Single UnityEngine.Rect::m_Height
float ___m_Height_3;
};
// UnityEngine.RectInt
struct RectInt_t1744D10E1063135DA9D574F95205B98DAC600CB8
{
// System.Int32 UnityEngine.RectInt::m_XMin
int32_t ___m_XMin_0;
// System.Int32 UnityEngine.RectInt::m_YMin
int32_t ___m_YMin_1;
// System.Int32 UnityEngine.RectInt::m_Width
int32_t ___m_Width_2;
// System.Int32 UnityEngine.RectInt::m_Height
int32_t ___m_Height_3;
};
// System.Numerics.Register
struct Register_t483055A1DB8634BA3FBF01BB15D4E94E186A2E7A
{
union
{
#pragma pack(push, tp, 1)
struct
{
// System.Byte System.Numerics.Register::byte_0
uint8_t ___byte_0_0;
};
#pragma pack(pop, tp)
struct
{
uint8_t ___byte_0_0_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_1_1_OffsetPadding[1];
// System.Byte System.Numerics.Register::byte_1
uint8_t ___byte_1_1;
};
#pragma pack(pop, tp)
struct
{
char ___byte_1_1_OffsetPadding_forAlignmentOnly[1];
uint8_t ___byte_1_1_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_2_2_OffsetPadding[2];
// System.Byte System.Numerics.Register::byte_2
uint8_t ___byte_2_2;
};
#pragma pack(pop, tp)
struct
{
char ___byte_2_2_OffsetPadding_forAlignmentOnly[2];
uint8_t ___byte_2_2_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_3_3_OffsetPadding[3];
// System.Byte System.Numerics.Register::byte_3
uint8_t ___byte_3_3;
};
#pragma pack(pop, tp)
struct
{
char ___byte_3_3_OffsetPadding_forAlignmentOnly[3];
uint8_t ___byte_3_3_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_4_4_OffsetPadding[4];
// System.Byte System.Numerics.Register::byte_4
uint8_t ___byte_4_4;
};
#pragma pack(pop, tp)
struct
{
char ___byte_4_4_OffsetPadding_forAlignmentOnly[4];
uint8_t ___byte_4_4_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_5_5_OffsetPadding[5];
// System.Byte System.Numerics.Register::byte_5
uint8_t ___byte_5_5;
};
#pragma pack(pop, tp)
struct
{
char ___byte_5_5_OffsetPadding_forAlignmentOnly[5];
uint8_t ___byte_5_5_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_6_6_OffsetPadding[6];
// System.Byte System.Numerics.Register::byte_6
uint8_t ___byte_6_6;
};
#pragma pack(pop, tp)
struct
{
char ___byte_6_6_OffsetPadding_forAlignmentOnly[6];
uint8_t ___byte_6_6_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_7_7_OffsetPadding[7];
// System.Byte System.Numerics.Register::byte_7
uint8_t ___byte_7_7;
};
#pragma pack(pop, tp)
struct
{
char ___byte_7_7_OffsetPadding_forAlignmentOnly[7];
uint8_t ___byte_7_7_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_8_8_OffsetPadding[8];
// System.Byte System.Numerics.Register::byte_8
uint8_t ___byte_8_8;
};
#pragma pack(pop, tp)
struct
{
char ___byte_8_8_OffsetPadding_forAlignmentOnly[8];
uint8_t ___byte_8_8_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_9_9_OffsetPadding[9];
// System.Byte System.Numerics.Register::byte_9
uint8_t ___byte_9_9;
};
#pragma pack(pop, tp)
struct
{
char ___byte_9_9_OffsetPadding_forAlignmentOnly[9];
uint8_t ___byte_9_9_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_10_10_OffsetPadding[10];
// System.Byte System.Numerics.Register::byte_10
uint8_t ___byte_10_10;
};
#pragma pack(pop, tp)
struct
{
char ___byte_10_10_OffsetPadding_forAlignmentOnly[10];
uint8_t ___byte_10_10_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_11_11_OffsetPadding[11];
// System.Byte System.Numerics.Register::byte_11
uint8_t ___byte_11_11;
};
#pragma pack(pop, tp)
struct
{
char ___byte_11_11_OffsetPadding_forAlignmentOnly[11];
uint8_t ___byte_11_11_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_12_12_OffsetPadding[12];
// System.Byte System.Numerics.Register::byte_12
uint8_t ___byte_12_12;
};
#pragma pack(pop, tp)
struct
{
char ___byte_12_12_OffsetPadding_forAlignmentOnly[12];
uint8_t ___byte_12_12_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_13_13_OffsetPadding[13];
// System.Byte System.Numerics.Register::byte_13
uint8_t ___byte_13_13;
};
#pragma pack(pop, tp)
struct
{
char ___byte_13_13_OffsetPadding_forAlignmentOnly[13];
uint8_t ___byte_13_13_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_14_14_OffsetPadding[14];
// System.Byte System.Numerics.Register::byte_14
uint8_t ___byte_14_14;
};
#pragma pack(pop, tp)
struct
{
char ___byte_14_14_OffsetPadding_forAlignmentOnly[14];
uint8_t ___byte_14_14_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___byte_15_15_OffsetPadding[15];
// System.Byte System.Numerics.Register::byte_15
uint8_t ___byte_15_15;
};
#pragma pack(pop, tp)
struct
{
char ___byte_15_15_OffsetPadding_forAlignmentOnly[15];
uint8_t ___byte_15_15_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
// System.SByte System.Numerics.Register::sbyte_0
int8_t ___sbyte_0_16;
};
#pragma pack(pop, tp)
struct
{
int8_t ___sbyte_0_16_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_1_17_OffsetPadding[1];
// System.SByte System.Numerics.Register::sbyte_1
int8_t ___sbyte_1_17;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_1_17_OffsetPadding_forAlignmentOnly[1];
int8_t ___sbyte_1_17_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_2_18_OffsetPadding[2];
// System.SByte System.Numerics.Register::sbyte_2
int8_t ___sbyte_2_18;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_2_18_OffsetPadding_forAlignmentOnly[2];
int8_t ___sbyte_2_18_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_3_19_OffsetPadding[3];
// System.SByte System.Numerics.Register::sbyte_3
int8_t ___sbyte_3_19;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_3_19_OffsetPadding_forAlignmentOnly[3];
int8_t ___sbyte_3_19_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_4_20_OffsetPadding[4];
// System.SByte System.Numerics.Register::sbyte_4
int8_t ___sbyte_4_20;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_4_20_OffsetPadding_forAlignmentOnly[4];
int8_t ___sbyte_4_20_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_5_21_OffsetPadding[5];
// System.SByte System.Numerics.Register::sbyte_5
int8_t ___sbyte_5_21;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_5_21_OffsetPadding_forAlignmentOnly[5];
int8_t ___sbyte_5_21_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_6_22_OffsetPadding[6];
// System.SByte System.Numerics.Register::sbyte_6
int8_t ___sbyte_6_22;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_6_22_OffsetPadding_forAlignmentOnly[6];
int8_t ___sbyte_6_22_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_7_23_OffsetPadding[7];
// System.SByte System.Numerics.Register::sbyte_7
int8_t ___sbyte_7_23;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_7_23_OffsetPadding_forAlignmentOnly[7];
int8_t ___sbyte_7_23_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_8_24_OffsetPadding[8];
// System.SByte System.Numerics.Register::sbyte_8
int8_t ___sbyte_8_24;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_8_24_OffsetPadding_forAlignmentOnly[8];
int8_t ___sbyte_8_24_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_9_25_OffsetPadding[9];
// System.SByte System.Numerics.Register::sbyte_9
int8_t ___sbyte_9_25;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_9_25_OffsetPadding_forAlignmentOnly[9];
int8_t ___sbyte_9_25_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_10_26_OffsetPadding[10];
// System.SByte System.Numerics.Register::sbyte_10
int8_t ___sbyte_10_26;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_10_26_OffsetPadding_forAlignmentOnly[10];
int8_t ___sbyte_10_26_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_11_27_OffsetPadding[11];
// System.SByte System.Numerics.Register::sbyte_11
int8_t ___sbyte_11_27;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_11_27_OffsetPadding_forAlignmentOnly[11];
int8_t ___sbyte_11_27_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_12_28_OffsetPadding[12];
// System.SByte System.Numerics.Register::sbyte_12
int8_t ___sbyte_12_28;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_12_28_OffsetPadding_forAlignmentOnly[12];
int8_t ___sbyte_12_28_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_13_29_OffsetPadding[13];
// System.SByte System.Numerics.Register::sbyte_13
int8_t ___sbyte_13_29;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_13_29_OffsetPadding_forAlignmentOnly[13];
int8_t ___sbyte_13_29_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_14_30_OffsetPadding[14];
// System.SByte System.Numerics.Register::sbyte_14
int8_t ___sbyte_14_30;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_14_30_OffsetPadding_forAlignmentOnly[14];
int8_t ___sbyte_14_30_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___sbyte_15_31_OffsetPadding[15];
// System.SByte System.Numerics.Register::sbyte_15
int8_t ___sbyte_15_31;
};
#pragma pack(pop, tp)
struct
{
char ___sbyte_15_31_OffsetPadding_forAlignmentOnly[15];
int8_t ___sbyte_15_31_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
// System.UInt16 System.Numerics.Register::uint16_0
uint16_t ___uint16_0_32;
};
#pragma pack(pop, tp)
struct
{
uint16_t ___uint16_0_32_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uint16_1_33_OffsetPadding[2];
// System.UInt16 System.Numerics.Register::uint16_1
uint16_t ___uint16_1_33;
};
#pragma pack(pop, tp)
struct
{
char ___uint16_1_33_OffsetPadding_forAlignmentOnly[2];
uint16_t ___uint16_1_33_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uint16_2_34_OffsetPadding[4];
// System.UInt16 System.Numerics.Register::uint16_2
uint16_t ___uint16_2_34;
};
#pragma pack(pop, tp)
struct
{
char ___uint16_2_34_OffsetPadding_forAlignmentOnly[4];
uint16_t ___uint16_2_34_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uint16_3_35_OffsetPadding[6];
// System.UInt16 System.Numerics.Register::uint16_3
uint16_t ___uint16_3_35;
};
#pragma pack(pop, tp)
struct
{
char ___uint16_3_35_OffsetPadding_forAlignmentOnly[6];
uint16_t ___uint16_3_35_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uint16_4_36_OffsetPadding[8];
// System.UInt16 System.Numerics.Register::uint16_4
uint16_t ___uint16_4_36;
};
#pragma pack(pop, tp)
struct
{
char ___uint16_4_36_OffsetPadding_forAlignmentOnly[8];
uint16_t ___uint16_4_36_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uint16_5_37_OffsetPadding[10];
// System.UInt16 System.Numerics.Register::uint16_5
uint16_t ___uint16_5_37;
};
#pragma pack(pop, tp)
struct
{
char ___uint16_5_37_OffsetPadding_forAlignmentOnly[10];
uint16_t ___uint16_5_37_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uint16_6_38_OffsetPadding[12];
// System.UInt16 System.Numerics.Register::uint16_6
uint16_t ___uint16_6_38;
};
#pragma pack(pop, tp)
struct
{
char ___uint16_6_38_OffsetPadding_forAlignmentOnly[12];
uint16_t ___uint16_6_38_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uint16_7_39_OffsetPadding[14];
// System.UInt16 System.Numerics.Register::uint16_7
uint16_t ___uint16_7_39;
};
#pragma pack(pop, tp)
struct
{
char ___uint16_7_39_OffsetPadding_forAlignmentOnly[14];
uint16_t ___uint16_7_39_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
// System.Int16 System.Numerics.Register::int16_0
int16_t ___int16_0_40;
};
#pragma pack(pop, tp)
struct
{
int16_t ___int16_0_40_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___int16_1_41_OffsetPadding[2];
// System.Int16 System.Numerics.Register::int16_1
int16_t ___int16_1_41;
};
#pragma pack(pop, tp)
struct
{
char ___int16_1_41_OffsetPadding_forAlignmentOnly[2];
int16_t ___int16_1_41_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___int16_2_42_OffsetPadding[4];
// System.Int16 System.Numerics.Register::int16_2
int16_t ___int16_2_42;
};
#pragma pack(pop, tp)
struct
{
char ___int16_2_42_OffsetPadding_forAlignmentOnly[4];
int16_t ___int16_2_42_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___int16_3_43_OffsetPadding[6];
// System.Int16 System.Numerics.Register::int16_3
int16_t ___int16_3_43;
};
#pragma pack(pop, tp)
struct
{
char ___int16_3_43_OffsetPadding_forAlignmentOnly[6];
int16_t ___int16_3_43_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___int16_4_44_OffsetPadding[8];
// System.Int16 System.Numerics.Register::int16_4
int16_t ___int16_4_44;
};
#pragma pack(pop, tp)
struct
{
char ___int16_4_44_OffsetPadding_forAlignmentOnly[8];
int16_t ___int16_4_44_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___int16_5_45_OffsetPadding[10];
// System.Int16 System.Numerics.Register::int16_5
int16_t ___int16_5_45;
};
#pragma pack(pop, tp)
struct
{
char ___int16_5_45_OffsetPadding_forAlignmentOnly[10];
int16_t ___int16_5_45_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___int16_6_46_OffsetPadding[12];
// System.Int16 System.Numerics.Register::int16_6
int16_t ___int16_6_46;
};
#pragma pack(pop, tp)
struct
{
char ___int16_6_46_OffsetPadding_forAlignmentOnly[12];
int16_t ___int16_6_46_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___int16_7_47_OffsetPadding[14];
// System.Int16 System.Numerics.Register::int16_7
int16_t ___int16_7_47;
};
#pragma pack(pop, tp)
struct
{
char ___int16_7_47_OffsetPadding_forAlignmentOnly[14];
int16_t ___int16_7_47_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
// System.UInt32 System.Numerics.Register::uint32_0
uint32_t ___uint32_0_48;
};
#pragma pack(pop, tp)
struct
{
uint32_t ___uint32_0_48_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uint32_1_49_OffsetPadding[4];
// System.UInt32 System.Numerics.Register::uint32_1
uint32_t ___uint32_1_49;
};
#pragma pack(pop, tp)
struct
{
char ___uint32_1_49_OffsetPadding_forAlignmentOnly[4];
uint32_t ___uint32_1_49_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uint32_2_50_OffsetPadding[8];
// System.UInt32 System.Numerics.Register::uint32_2
uint32_t ___uint32_2_50;
};
#pragma pack(pop, tp)
struct
{
char ___uint32_2_50_OffsetPadding_forAlignmentOnly[8];
uint32_t ___uint32_2_50_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uint32_3_51_OffsetPadding[12];
// System.UInt32 System.Numerics.Register::uint32_3
uint32_t ___uint32_3_51;
};
#pragma pack(pop, tp)
struct
{
char ___uint32_3_51_OffsetPadding_forAlignmentOnly[12];
uint32_t ___uint32_3_51_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
// System.Int32 System.Numerics.Register::int32_0
int32_t ___int32_0_52;
};
#pragma pack(pop, tp)
struct
{
int32_t ___int32_0_52_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___int32_1_53_OffsetPadding[4];
// System.Int32 System.Numerics.Register::int32_1
int32_t ___int32_1_53;
};
#pragma pack(pop, tp)
struct
{
char ___int32_1_53_OffsetPadding_forAlignmentOnly[4];
int32_t ___int32_1_53_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___int32_2_54_OffsetPadding[8];
// System.Int32 System.Numerics.Register::int32_2
int32_t ___int32_2_54;
};
#pragma pack(pop, tp)
struct
{
char ___int32_2_54_OffsetPadding_forAlignmentOnly[8];
int32_t ___int32_2_54_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___int32_3_55_OffsetPadding[12];
// System.Int32 System.Numerics.Register::int32_3
int32_t ___int32_3_55;
};
#pragma pack(pop, tp)
struct
{
char ___int32_3_55_OffsetPadding_forAlignmentOnly[12];
int32_t ___int32_3_55_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
// System.UInt64 System.Numerics.Register::uint64_0
uint64_t ___uint64_0_56;
};
#pragma pack(pop, tp)
struct
{
uint64_t ___uint64_0_56_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uint64_1_57_OffsetPadding[8];
// System.UInt64 System.Numerics.Register::uint64_1
uint64_t ___uint64_1_57;
};
#pragma pack(pop, tp)
struct
{
char ___uint64_1_57_OffsetPadding_forAlignmentOnly[8];
uint64_t ___uint64_1_57_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
// System.Int64 System.Numerics.Register::int64_0
int64_t ___int64_0_58;
};
#pragma pack(pop, tp)
struct
{
int64_t ___int64_0_58_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___int64_1_59_OffsetPadding[8];
// System.Int64 System.Numerics.Register::int64_1
int64_t ___int64_1_59;
};
#pragma pack(pop, tp)
struct
{
char ___int64_1_59_OffsetPadding_forAlignmentOnly[8];
int64_t ___int64_1_59_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
// System.Single System.Numerics.Register::single_0
float ___single_0_60;
};
#pragma pack(pop, tp)
struct
{
float ___single_0_60_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___single_1_61_OffsetPadding[4];
// System.Single System.Numerics.Register::single_1
float ___single_1_61;
};
#pragma pack(pop, tp)
struct
{
char ___single_1_61_OffsetPadding_forAlignmentOnly[4];
float ___single_1_61_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___single_2_62_OffsetPadding[8];
// System.Single System.Numerics.Register::single_2
float ___single_2_62;
};
#pragma pack(pop, tp)
struct
{
char ___single_2_62_OffsetPadding_forAlignmentOnly[8];
float ___single_2_62_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___single_3_63_OffsetPadding[12];
// System.Single System.Numerics.Register::single_3
float ___single_3_63;
};
#pragma pack(pop, tp)
struct
{
char ___single_3_63_OffsetPadding_forAlignmentOnly[12];
float ___single_3_63_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
// System.Double System.Numerics.Register::double_0
double ___double_0_64;
};
#pragma pack(pop, tp)
struct
{
double ___double_0_64_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___double_1_65_OffsetPadding[8];
// System.Double System.Numerics.Register::double_1
double ___double_1_65;
};
#pragma pack(pop, tp)
struct
{
char ___double_1_65_OffsetPadding_forAlignmentOnly[8];
double ___double_1_65_forAlignmentOnly;
};
};
};
// UnityEngine.UIElements.UIR.RenderChainTextEntry
struct RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11
{
// UnityEngine.UIElements.UIR.RenderChainCommand UnityEngine.UIElements.UIR.RenderChainTextEntry::command
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___command_0;
// System.Int32 UnityEngine.UIElements.UIR.RenderChainTextEntry::firstVertex
int32_t ___firstVertex_1;
// System.Int32 UnityEngine.UIElements.UIR.RenderChainTextEntry::vertexCount
int32_t ___vertexCount_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.UIR.RenderChainTextEntry
struct RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11_marshaled_pinvoke
{
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___command_0;
int32_t ___firstVertex_1;
int32_t ___vertexCount_2;
};
// Native definition for COM marshalling of UnityEngine.UIElements.UIR.RenderChainTextEntry
struct RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11_marshaled_com
{
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___command_0;
int32_t ___firstVertex_1;
int32_t ___vertexCount_2;
};
// System.Resources.ResourceLocator
struct ResourceLocator_t84F68A0DD2AA185761938E49BBE9B2C46A47E122
{
// System.Object System.Resources.ResourceLocator::_value
RuntimeObject* ____value_0;
// System.Int32 System.Resources.ResourceLocator::_dataPos
int32_t ____dataPos_1;
};
// Native definition for P/Invoke marshalling of System.Resources.ResourceLocator
struct ResourceLocator_t84F68A0DD2AA185761938E49BBE9B2C46A47E122_marshaled_pinvoke
{
Il2CppIUnknown* ____value_0;
int32_t ____dataPos_1;
};
// Native definition for COM marshalling of System.Resources.ResourceLocator
struct ResourceLocator_t84F68A0DD2AA185761938E49BBE9B2C46A47E122_marshaled_com
{
Il2CppIUnknown* ____value_0;
int32_t ____dataPos_1;
};
// UnityEngine.UIElements.RuleMatcher
struct RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E
{
// UnityEngine.UIElements.StyleSheet UnityEngine.UIElements.RuleMatcher::sheet
StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428* ___sheet_0;
// UnityEngine.UIElements.StyleComplexSelector UnityEngine.UIElements.RuleMatcher::complexSelector
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* ___complexSelector_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.RuleMatcher
struct RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E_marshaled_pinvoke
{
StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428* ___sheet_0;
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* ___complexSelector_1;
};
// Native definition for COM marshalling of UnityEngine.UIElements.RuleMatcher
struct RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E_marshaled_com
{
StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428* ___sheet_0;
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* ___complexSelector_1;
};
// System.SByte
struct SByte_tFEFFEF5D2FEBF5207950AE6FAC150FC53B668DB5
{
// System.SByte System.SByte::m_value
int8_t ___m_value_0;
};
// UnityEngine.UIElements.StyleSheets.ScalableImage
struct ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F
{
// UnityEngine.Texture2D UnityEngine.UIElements.StyleSheets.ScalableImage::normalImage
Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* ___normalImage_0;
// UnityEngine.Texture2D UnityEngine.UIElements.StyleSheets.ScalableImage::highResolutionImage
Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* ___highResolutionImage_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.StyleSheets.ScalableImage
struct ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F_marshaled_pinvoke
{
Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* ___normalImage_0;
Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* ___highResolutionImage_1;
};
// Native definition for COM marshalling of UnityEngine.UIElements.StyleSheets.ScalableImage
struct ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F_marshaled_com
{
Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* ___normalImage_0;
Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* ___highResolutionImage_1;
};
// UnityEngine.UIElements.StyleSheets.SelectorMatchRecord
struct SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7
{
// UnityEngine.UIElements.StyleSheet UnityEngine.UIElements.StyleSheets.SelectorMatchRecord::sheet
StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428* ___sheet_0;
// System.Int32 UnityEngine.UIElements.StyleSheets.SelectorMatchRecord::styleSheetIndexInStack
int32_t ___styleSheetIndexInStack_1;
// UnityEngine.UIElements.StyleComplexSelector UnityEngine.UIElements.StyleSheets.SelectorMatchRecord::complexSelector
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* ___complexSelector_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.StyleSheets.SelectorMatchRecord
struct SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7_marshaled_pinvoke
{
StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428* ___sheet_0;
int32_t ___styleSheetIndexInStack_1;
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* ___complexSelector_2;
};
// Native definition for COM marshalling of UnityEngine.UIElements.StyleSheets.SelectorMatchRecord
struct SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7_marshaled_com
{
StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428* ___sheet_0;
int32_t ___styleSheetIndexInStack_1;
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* ___complexSelector_2;
};
// System.Single
struct Single_t4530F2FF86FCB0DC29F35385CA1BD21BE294761C
{
// System.Single System.Single::m_value
float ___m_value_0;
};
// UnityEngine.UIElements.Experimental.StyleValues
struct StyleValues_t4AED947A53B84B62EF2B589A40B74911CA77D11A
{
// UnityEngine.UIElements.StyleValueCollection UnityEngine.UIElements.Experimental.StyleValues::m_StyleValues
StyleValueCollection_t5ADC08D23E648FBE78F2C161494786E6C83E1377* ___m_StyleValues_0;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.Experimental.StyleValues
struct StyleValues_t4AED947A53B84B62EF2B589A40B74911CA77D11A_marshaled_pinvoke
{
StyleValueCollection_t5ADC08D23E648FBE78F2C161494786E6C83E1377* ___m_StyleValues_0;
};
// Native definition for COM marshalling of UnityEngine.UIElements.Experimental.StyleValues
struct StyleValues_t4AED947A53B84B62EF2B589A40B74911CA77D11A_marshaled_com
{
StyleValueCollection_t5ADC08D23E648FBE78F2C161494786E6C83E1377* ___m_StyleValues_0;
};
// UnityEngine.UIElements.StyleVariable
struct StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269
{
// System.String UnityEngine.UIElements.StyleVariable::name
String_t* ___name_0;
// UnityEngine.UIElements.StyleSheet UnityEngine.UIElements.StyleVariable::sheet
StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428* ___sheet_1;
// UnityEngine.UIElements.StyleValueHandle[] UnityEngine.UIElements.StyleVariable::handles
StyleValueHandleU5BU5D_t66B7732469E9E30B1FB9A6E386315DAB36914ADE* ___handles_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.StyleVariable
struct StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269_marshaled_pinvoke
{
char* ___name_0;
StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428* ___sheet_1;
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D* ___handles_2;
};
// Native definition for COM marshalling of UnityEngine.UIElements.StyleVariable
struct StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269_marshaled_com
{
Il2CppChar* ___name_0;
StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428* ___sheet_1;
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D* ___handles_2;
};
// UnityEngine.UIElements.TextureId
struct TextureId_tFF4B4AAE53408AB10B0B89CCA5F7B50CF2535E58
{
// System.Int32 UnityEngine.UIElements.TextureId::m_Index
int32_t ___m_Index_0;
};
struct TextureId_tFF4B4AAE53408AB10B0B89CCA5F7B50CF2535E58_StaticFields
{
// UnityEngine.UIElements.TextureId UnityEngine.UIElements.TextureId::invalid
TextureId_tFF4B4AAE53408AB10B0B89CCA5F7B50CF2535E58 ___invalid_1;
};
// UnityEngine.UILineInfo
struct UILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC
{
// System.Int32 UnityEngine.UILineInfo::startCharIdx
int32_t ___startCharIdx_0;
// System.Int32 UnityEngine.UILineInfo::height
int32_t ___height_1;
// System.Single UnityEngine.UILineInfo::topY
float ___topY_2;
// System.Single UnityEngine.UILineInfo::leading
float ___leading_3;
};
// System.UInt16
struct UInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455
{
// System.UInt16 System.UInt16::m_value
uint16_t ___m_value_0;
};
// System.UInt32
struct UInt32_t1833D51FFA667B18A5AA4B8D34DE284F8495D29B
{
// System.UInt32 System.UInt32::m_value
uint32_t ___m_value_0;
};
// System.UInt64
struct UInt64_t8F12534CC8FC4B5860F2A2CD1EE79D322E7A41AF
{
// System.UInt64 System.UInt64::m_value
uint64_t ___m_value_0;
};
// System.UIntPtr
struct UIntPtr_t
{
// System.Void* System.UIntPtr::_pointer
void* ____pointer_1;
};
struct UIntPtr_t_StaticFields
{
// System.UIntPtr System.UIntPtr::Zero
uintptr_t ___Zero_0;
};
// UnityEngine.Vector2
struct Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7
{
// System.Single UnityEngine.Vector2::x
float ___x_0;
// System.Single UnityEngine.Vector2::y
float ___y_1;
};
struct Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7_StaticFields
{
// UnityEngine.Vector2 UnityEngine.Vector2::zeroVector
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___zeroVector_2;
// UnityEngine.Vector2 UnityEngine.Vector2::oneVector
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___oneVector_3;
// UnityEngine.Vector2 UnityEngine.Vector2::upVector
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___upVector_4;
// UnityEngine.Vector2 UnityEngine.Vector2::downVector
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___downVector_5;
// UnityEngine.Vector2 UnityEngine.Vector2::leftVector
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___leftVector_6;
// UnityEngine.Vector2 UnityEngine.Vector2::rightVector
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___rightVector_7;
// UnityEngine.Vector2 UnityEngine.Vector2::positiveInfinityVector
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___positiveInfinityVector_8;
// UnityEngine.Vector2 UnityEngine.Vector2::negativeInfinityVector
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___negativeInfinityVector_9;
};
// UnityEngine.Vector2Int
struct Vector2Int_t69B2886EBAB732D9B880565E18E7568F3DE0CE6A
{
// System.Int32 UnityEngine.Vector2Int::m_X
int32_t ___m_X_0;
// System.Int32 UnityEngine.Vector2Int::m_Y
int32_t ___m_Y_1;
};
struct Vector2Int_t69B2886EBAB732D9B880565E18E7568F3DE0CE6A_StaticFields
{
// UnityEngine.Vector2Int UnityEngine.Vector2Int::s_Zero
Vector2Int_t69B2886EBAB732D9B880565E18E7568F3DE0CE6A ___s_Zero_2;
// UnityEngine.Vector2Int UnityEngine.Vector2Int::s_One
Vector2Int_t69B2886EBAB732D9B880565E18E7568F3DE0CE6A ___s_One_3;
// UnityEngine.Vector2Int UnityEngine.Vector2Int::s_Up
Vector2Int_t69B2886EBAB732D9B880565E18E7568F3DE0CE6A ___s_Up_4;
// UnityEngine.Vector2Int UnityEngine.Vector2Int::s_Down
Vector2Int_t69B2886EBAB732D9B880565E18E7568F3DE0CE6A ___s_Down_5;
// UnityEngine.Vector2Int UnityEngine.Vector2Int::s_Left
Vector2Int_t69B2886EBAB732D9B880565E18E7568F3DE0CE6A ___s_Left_6;
// UnityEngine.Vector2Int UnityEngine.Vector2Int::s_Right
Vector2Int_t69B2886EBAB732D9B880565E18E7568F3DE0CE6A ___s_Right_7;
};
// UnityEngine.Vector3
struct Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2
{
// System.Single UnityEngine.Vector3::x
float ___x_2;
// System.Single UnityEngine.Vector3::y
float ___y_3;
// System.Single UnityEngine.Vector3::z
float ___z_4;
};
struct Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2_StaticFields
{
// UnityEngine.Vector3 UnityEngine.Vector3::zeroVector
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___zeroVector_5;
// UnityEngine.Vector3 UnityEngine.Vector3::oneVector
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___oneVector_6;
// UnityEngine.Vector3 UnityEngine.Vector3::upVector
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___upVector_7;
// UnityEngine.Vector3 UnityEngine.Vector3::downVector
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___downVector_8;
// UnityEngine.Vector3 UnityEngine.Vector3::leftVector
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___leftVector_9;
// UnityEngine.Vector3 UnityEngine.Vector3::rightVector
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___rightVector_10;
// UnityEngine.Vector3 UnityEngine.Vector3::forwardVector
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___forwardVector_11;
// UnityEngine.Vector3 UnityEngine.Vector3::backVector
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___backVector_12;
// UnityEngine.Vector3 UnityEngine.Vector3::positiveInfinityVector
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___positiveInfinityVector_13;
// UnityEngine.Vector3 UnityEngine.Vector3::negativeInfinityVector
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___negativeInfinityVector_14;
};
// UnityEngine.Vector4
struct Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3
{
// System.Single UnityEngine.Vector4::x
float ___x_1;
// System.Single UnityEngine.Vector4::y
float ___y_2;
// System.Single UnityEngine.Vector4::z
float ___z_3;
// System.Single UnityEngine.Vector4::w
float ___w_4;
};
struct Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3_StaticFields
{
// UnityEngine.Vector4 UnityEngine.Vector4::zeroVector
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___zeroVector_5;
// UnityEngine.Vector4 UnityEngine.Vector4::oneVector
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___oneVector_6;
// UnityEngine.Vector4 UnityEngine.Vector4::positiveInfinityVector
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___positiveInfinityVector_7;
// UnityEngine.Vector4 UnityEngine.Vector4::negativeInfinityVector
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___negativeInfinityVector_8;
};
// System.Void
struct Void_t4861ACF8F4594C3437BB48B6E56783494B843915
{
union
{
struct
{
};
uint8_t Void_t4861ACF8F4594C3437BB48B6E56783494B843915__padding[1];
};
};
// UnityEngine.TextCore.Text.WordInfo
struct WordInfo_tA466206097891A5A2590896EE164AFC406EB060D
{
// System.Int32 UnityEngine.TextCore.Text.WordInfo::firstCharacterIndex
int32_t ___firstCharacterIndex_0;
// System.Int32 UnityEngine.TextCore.Text.WordInfo::lastCharacterIndex
int32_t ___lastCharacterIndex_1;
// System.Int32 UnityEngine.TextCore.Text.WordInfo::characterCount
int32_t ___characterCount_2;
};
// UnityEngine.BeforeRenderHelper/OrderBlock
struct OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837
{
// System.Int32 UnityEngine.BeforeRenderHelper/OrderBlock::order
int32_t ___order_0;
// UnityEngine.Events.UnityAction UnityEngine.BeforeRenderHelper/OrderBlock::callback
UnityAction_t11A1F3B953B365C072A5DCC32677EE1796A962A7* ___callback_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.BeforeRenderHelper/OrderBlock
struct OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837_marshaled_pinvoke
{
int32_t ___order_0;
Il2CppMethodPointer ___callback_1;
};
// Native definition for COM marshalling of UnityEngine.BeforeRenderHelper/OrderBlock
struct OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837_marshaled_com
{
int32_t ___order_0;
Il2CppMethodPointer ___callback_1;
};
// UnityEngine.UIElements.UIR.BitmapAllocator32/Page
struct Page_t04FE552A388BF55B12C8868E19589136957E00A5
{
// System.UInt16 UnityEngine.UIElements.UIR.BitmapAllocator32/Page::x
uint16_t ___x_0;
// System.UInt16 UnityEngine.UIElements.UIR.BitmapAllocator32/Page::y
uint16_t ___y_1;
// System.Int32 UnityEngine.UIElements.UIR.BitmapAllocator32/Page::freeSlots
int32_t ___freeSlots_2;
};
// Cinemachine.CameraState/CustomBlendable
struct CustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB
{
// UnityEngine.Object Cinemachine.CameraState/CustomBlendable::m_Custom
Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C* ___m_Custom_0;
// System.Single Cinemachine.CameraState/CustomBlendable::m_Weight
float ___m_Weight_1;
};
// Cinemachine.CinemachineClearShot/Pair
struct Pair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2
{
// System.Int32 Cinemachine.CinemachineClearShot/Pair::a
int32_t ___a_0;
// System.Single Cinemachine.CinemachineClearShot/Pair::b
float ___b_1;
};
// Cinemachine.CinemachineStateDrivenCamera/HashPair
struct HashPair_t176F7624706A73500F3AB84D61111316D45ECCEC
{
// System.Int32 Cinemachine.CinemachineStateDrivenCamera/HashPair::parentHash
int32_t ___parentHash_0;
// System.Int32 Cinemachine.CinemachineStateDrivenCamera/HashPair::hash
int32_t ___hash_1;
};
// Cinemachine.ConfinerOven/PolygonSolution
struct PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C
{
// System.Collections.Generic.List`1<System.Collections.Generic.List`1<ClipperLib.IntPoint>> Cinemachine.ConfinerOven/PolygonSolution::m_Polygons
List_1_t5FC3329744B133EEDF6D1F91F711F3DB16EBD13D* ___m_Polygons_0;
// System.Single Cinemachine.ConfinerOven/PolygonSolution::m_FrustumHeight
float ___m_FrustumHeight_1;
};
// Native definition for P/Invoke marshalling of Cinemachine.ConfinerOven/PolygonSolution
struct PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C_marshaled_pinvoke
{
List_1_t5FC3329744B133EEDF6D1F91F711F3DB16EBD13D* ___m_Polygons_0;
float ___m_FrustumHeight_1;
};
// Native definition for COM marshalling of Cinemachine.ConfinerOven/PolygonSolution
struct PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C_marshaled_com
{
List_1_t5FC3329744B133EEDF6D1F91F711F3DB16EBD13D* ___m_Polygons_0;
float ___m_FrustumHeight_1;
};
// System.Decimal/DecCalc
struct DecCalc_t0E9BD1BAF25BAD15940FF4BAB400D012A8DEBCA9
{
union
{
#pragma pack(push, tp, 1)
struct
{
// System.UInt32 System.Decimal/DecCalc::uflags
uint32_t ___uflags_0;
};
#pragma pack(pop, tp)
struct
{
uint32_t ___uflags_0_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___uhi_1_OffsetPadding[4];
// System.UInt32 System.Decimal/DecCalc::uhi
uint32_t ___uhi_1;
};
#pragma pack(pop, tp)
struct
{
char ___uhi_1_OffsetPadding_forAlignmentOnly[4];
uint32_t ___uhi_1_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___ulo_2_OffsetPadding[8];
// System.UInt32 System.Decimal/DecCalc::ulo
uint32_t ___ulo_2;
};
#pragma pack(pop, tp)
struct
{
char ___ulo_2_OffsetPadding_forAlignmentOnly[8];
uint32_t ___ulo_2_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___umid_3_OffsetPadding[12];
// System.UInt32 System.Decimal/DecCalc::umid
uint32_t ___umid_3;
};
#pragma pack(pop, tp)
struct
{
char ___umid_3_OffsetPadding_forAlignmentOnly[12];
uint32_t ___umid_3_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___ulomidLE_4_OffsetPadding[8];
// System.UInt64 System.Decimal/DecCalc::ulomidLE
uint64_t ___ulomidLE_4;
};
#pragma pack(pop, tp)
struct
{
char ___ulomidLE_4_OffsetPadding_forAlignmentOnly[8];
uint64_t ___ulomidLE_4_forAlignmentOnly;
};
};
};
struct DecCalc_t0E9BD1BAF25BAD15940FF4BAB400D012A8DEBCA9_StaticFields
{
// System.UInt32[] System.Decimal/DecCalc::s_powers10
UInt32U5BU5D_t02FBD658AD156A17574ECE6106CF1FBFCC9807FA* ___s_powers10_5;
// System.UInt64[] System.Decimal/DecCalc::s_ulongPowers10
UInt64U5BU5D_tAB1A62450AC0899188486EDB9FC066B8BEED9299* ___s_ulongPowers10_6;
// System.Double[] System.Decimal/DecCalc::s_doublePowers10
DoubleU5BU5D_tCC308475BD3B8229DB2582938669EF2F9ECC1FEE* ___s_doublePowers10_7;
// System.Decimal/DecCalc/PowerOvfl[] System.Decimal/DecCalc::PowerOvflValues
PowerOvflU5BU5D_t8BB6F43AF19F1F7C7558815B4684875BC320735B* ___PowerOvflValues_8;
};
// UnityEngine.UIElements.EventInterestReflectionUtils/DefaultEventInterests
struct DefaultEventInterests_tF62D361FCDFA26C0E0A55ECCD8C20A64B3F2D8F0
{
// System.Int32 UnityEngine.UIElements.EventInterestReflectionUtils/DefaultEventInterests::DefaultActionCategories
int32_t ___DefaultActionCategories_0;
// System.Int32 UnityEngine.UIElements.EventInterestReflectionUtils/DefaultEventInterests::DefaultActionAtTargetCategories
int32_t ___DefaultActionAtTargetCategories_1;
};
// UnityEngine.UIElements.FocusController/FocusedElement
struct FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF
{
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.FocusController/FocusedElement::m_SubTreeRoot
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___m_SubTreeRoot_0;
// UnityEngine.UIElements.Focusable UnityEngine.UIElements.FocusController/FocusedElement::m_FocusedElement
Focusable_t39F2BAF0AF6CA465BC2BEDAF9B5B2CF379B846D0* ___m_FocusedElement_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.FocusController/FocusedElement
struct FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF_marshaled_pinvoke
{
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___m_SubTreeRoot_0;
Focusable_t39F2BAF0AF6CA465BC2BEDAF9B5B2CF379B846D0* ___m_FocusedElement_1;
};
// Native definition for COM marshalling of UnityEngine.UIElements.FocusController/FocusedElement
struct FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF_marshaled_com
{
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___m_SubTreeRoot_0;
Focusable_t39F2BAF0AF6CA465BC2BEDAF9B5B2CF379B846D0* ___m_FocusedElement_1;
};
// UnityEngine.UIElements.Hashes/<hashes>e__FixedBuffer
struct U3ChashesU3Ee__FixedBuffer_tB9B9E597830648919837C8EFBAD317741097D94E
{
union
{
struct
{
// System.Int32 UnityEngine.UIElements.Hashes/<hashes>e__FixedBuffer::FixedElementField
int32_t ___FixedElementField_0;
};
uint8_t U3ChashesU3Ee__FixedBuffer_tB9B9E597830648919837C8EFBAD317741097D94E__padding[16];
};
};
// UnityEngine.UIElements.InternalTreeView/TreeViewItemWrapper
struct TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F
{
// System.Int32 UnityEngine.UIElements.InternalTreeView/TreeViewItemWrapper::depth
int32_t ___depth_0;
// UnityEngine.UIElements.ITreeViewItem UnityEngine.UIElements.InternalTreeView/TreeViewItemWrapper::item
RuntimeObject* ___item_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.InternalTreeView/TreeViewItemWrapper
struct TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F_marshaled_pinvoke
{
int32_t ___depth_0;
RuntimeObject* ___item_1;
};
// Native definition for COM marshalling of UnityEngine.UIElements.InternalTreeView/TreeViewItemWrapper
struct TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F_marshaled_com
{
int32_t ___depth_0;
RuntimeObject* ___item_1;
};
// System.Text.RegularExpressions.RegexCharClass/SingleRange
struct SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC
{
// System.Char System.Text.RegularExpressions.RegexCharClass/SingleRange::First
Il2CppChar ___First_0;
// System.Char System.Text.RegularExpressions.RegexCharClass/SingleRange::Last
Il2CppChar ___Last_1;
};
// Native definition for P/Invoke marshalling of System.Text.RegularExpressions.RegexCharClass/SingleRange
struct SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC_marshaled_pinvoke
{
uint8_t ___First_0;
uint8_t ___Last_1;
};
// Native definition for COM marshalling of System.Text.RegularExpressions.RegexCharClass/SingleRange
struct SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC_marshaled_com
{
uint8_t ___First_0;
uint8_t ___Last_1;
};
// UnityEngine.UIElements.TemplateAsset/AttributeOverride
struct AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF
{
// System.String UnityEngine.UIElements.TemplateAsset/AttributeOverride::m_ElementName
String_t* ___m_ElementName_0;
// System.String UnityEngine.UIElements.TemplateAsset/AttributeOverride::m_AttributeName
String_t* ___m_AttributeName_1;
// System.String UnityEngine.UIElements.TemplateAsset/AttributeOverride::m_Value
String_t* ___m_Value_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.TemplateAsset/AttributeOverride
struct AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF_marshaled_pinvoke
{
char* ___m_ElementName_0;
char* ___m_AttributeName_1;
char* ___m_Value_2;
};
// Native definition for COM marshalling of UnityEngine.UIElements.TemplateAsset/AttributeOverride
struct AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF_marshaled_com
{
Il2CppChar* ___m_ElementName_0;
Il2CppChar* ___m_AttributeName_1;
Il2CppChar* ___m_Value_2;
};
// UnityEngine.TextCore.Text.TextResourceManager/FontAssetRef
struct FontAssetRef_t7B8E634754BC5683F1E6601D7CD0061285A28FF3
{
// System.Int32 UnityEngine.TextCore.Text.TextResourceManager/FontAssetRef::nameHashCode
int32_t ___nameHashCode_0;
// System.Int32 UnityEngine.TextCore.Text.TextResourceManager/FontAssetRef::familyNameHashCode
int32_t ___familyNameHashCode_1;
// System.Int32 UnityEngine.TextCore.Text.TextResourceManager/FontAssetRef::styleNameHashCode
int32_t ___styleNameHashCode_2;
// System.Int64 UnityEngine.TextCore.Text.TextResourceManager/FontAssetRef::familyNameAndStyleHashCode
int64_t ___familyNameAndStyleHashCode_3;
// UnityEngine.TextCore.Text.FontAsset UnityEngine.TextCore.Text.TextResourceManager/FontAssetRef::fontAsset
FontAsset_t61A6446D934E582651044E33D250EA8D306AB958* ___fontAsset_4;
};
// Native definition for P/Invoke marshalling of UnityEngine.TextCore.Text.TextResourceManager/FontAssetRef
struct FontAssetRef_t7B8E634754BC5683F1E6601D7CD0061285A28FF3_marshaled_pinvoke
{
int32_t ___nameHashCode_0;
int32_t ___familyNameHashCode_1;
int32_t ___styleNameHashCode_2;
int64_t ___familyNameAndStyleHashCode_3;
FontAsset_t61A6446D934E582651044E33D250EA8D306AB958* ___fontAsset_4;
};
// Native definition for COM marshalling of UnityEngine.TextCore.Text.TextResourceManager/FontAssetRef
struct FontAssetRef_t7B8E634754BC5683F1E6601D7CD0061285A28FF3_marshaled_com
{
int32_t ___nameHashCode_0;
int32_t ___familyNameHashCode_1;
int32_t ___styleNameHashCode_2;
int64_t ___familyNameAndStyleHashCode_3;
FontAsset_t61A6446D934E582651044E33D250EA8D306AB958* ___fontAsset_4;
};
// UnityEngine.TextCore.Text.TextSettings/FontReferenceMap
struct FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831
{
// UnityEngine.Font UnityEngine.TextCore.Text.TextSettings/FontReferenceMap::font
Font_tC95270EA3198038970422D78B74A7F2E218A96B6* ___font_0;
// UnityEngine.TextCore.Text.FontAsset UnityEngine.TextCore.Text.TextSettings/FontReferenceMap::fontAsset
FontAsset_t61A6446D934E582651044E33D250EA8D306AB958* ___fontAsset_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.TextCore.Text.TextSettings/FontReferenceMap
struct FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831_marshaled_pinvoke
{
Font_tC95270EA3198038970422D78B74A7F2E218A96B6* ___font_0;
FontAsset_t61A6446D934E582651044E33D250EA8D306AB958* ___fontAsset_1;
};
// Native definition for COM marshalling of UnityEngine.TextCore.Text.TextSettings/FontReferenceMap
struct FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831_marshaled_com
{
Font_tC95270EA3198038970422D78B74A7F2E218A96B6* ___font_0;
FontAsset_t61A6446D934E582651044E33D250EA8D306AB958* ___fontAsset_1;
};
// UnityEngine.UIElements.TextureRegistry/TextureInfo
struct TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B
{
// UnityEngine.Texture UnityEngine.UIElements.TextureRegistry/TextureInfo::texture
Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700* ___texture_0;
// System.Boolean UnityEngine.UIElements.TextureRegistry/TextureInfo::dynamic
bool ___dynamic_1;
// System.Int32 UnityEngine.UIElements.TextureRegistry/TextureInfo::refCount
int32_t ___refCount_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.TextureRegistry/TextureInfo
struct TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B_marshaled_pinvoke
{
Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700* ___texture_0;
int32_t ___dynamic_1;
int32_t ___refCount_2;
};
// Native definition for COM marshalling of UnityEngine.UIElements.TextureRegistry/TextureInfo
struct TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B_marshaled_com
{
Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700* ___texture_0;
int32_t ___dynamic_1;
int32_t ___refCount_2;
};
// UnityEngine.Timeline.TrackAsset/TransientBuildData
struct TransientBuildData_t3BE8EF6B5113561AEE7D53FDF3DB331D39BE194F
{
// System.Collections.Generic.List`1<UnityEngine.Timeline.TrackAsset> UnityEngine.Timeline.TrackAsset/TransientBuildData::trackList
List_1_t6908BEEFB57470CB30420983896AA06BFB8796F0* ___trackList_0;
// System.Collections.Generic.List`1<UnityEngine.Timeline.TimelineClip> UnityEngine.Timeline.TrackAsset/TransientBuildData::clipList
List_1_tD78196B4DE777C4B74ADAD24051A9978F5191506* ___clipList_1;
// System.Collections.Generic.List`1<UnityEngine.Timeline.IMarker> UnityEngine.Timeline.TrackAsset/TransientBuildData::markerList
List_1_tB481045C42962DD282E8A89B2AF0246A4042EADF* ___markerList_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.Timeline.TrackAsset/TransientBuildData
struct TransientBuildData_t3BE8EF6B5113561AEE7D53FDF3DB331D39BE194F_marshaled_pinvoke
{
List_1_t6908BEEFB57470CB30420983896AA06BFB8796F0* ___trackList_0;
List_1_tD78196B4DE777C4B74ADAD24051A9978F5191506* ___clipList_1;
List_1_tB481045C42962DD282E8A89B2AF0246A4042EADF* ___markerList_2;
};
// Native definition for COM marshalling of UnityEngine.Timeline.TrackAsset/TransientBuildData
struct TransientBuildData_t3BE8EF6B5113561AEE7D53FDF3DB331D39BE194F_marshaled_com
{
List_1_t6908BEEFB57470CB30420983896AA06BFB8796F0* ___trackList_0;
List_1_tD78196B4DE777C4B74ADAD24051A9978F5191506* ___clipList_1;
List_1_tB481045C42962DD282E8A89B2AF0246A4042EADF* ___markerList_2;
};
// UnityEngine.UIElements.TreeView/TreeViewItemWrapper
struct TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE
{
// System.Int32 UnityEngine.UIElements.TreeView/TreeViewItemWrapper::depth
int32_t ___depth_0;
// UnityEngine.UIElements.ITreeViewItem UnityEngine.UIElements.TreeView/TreeViewItemWrapper::item
RuntimeObject* ___item_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.TreeView/TreeViewItemWrapper
struct TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE_marshaled_pinvoke
{
int32_t ___depth_0;
RuntimeObject* ___item_1;
};
// Native definition for COM marshalling of UnityEngine.UIElements.TreeView/TreeViewItemWrapper
struct TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE_marshaled_com
{
int32_t ___depth_0;
RuntimeObject* ___item_1;
};
// UnityEngine.UIElements.UIR.UIRenderDevice/DrawStatistics
struct DrawStatistics_t4AF06C67CEC7B97509EBAD48E3EE908301598E6F
{
// System.Int32 UnityEngine.UIElements.UIR.UIRenderDevice/DrawStatistics::currentFrameIndex
int32_t ___currentFrameIndex_0;
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice/DrawStatistics::totalIndices
uint32_t ___totalIndices_1;
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice/DrawStatistics::commandCount
uint32_t ___commandCount_2;
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice/DrawStatistics::drawCommandCount
uint32_t ___drawCommandCount_3;
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice/DrawStatistics::materialSetCount
uint32_t ___materialSetCount_4;
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice/DrawStatistics::drawRangeCount
uint32_t ___drawRangeCount_5;
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice/DrawStatistics::drawRangeCallCount
uint32_t ___drawRangeCallCount_6;
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice/DrawStatistics::immediateDraws
uint32_t ___immediateDraws_7;
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice/DrawStatistics::stencilRefChanges
uint32_t ___stencilRefChanges_8;
};
// UnityEngine.UnitySynchronizationContext/WorkRequest
struct WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44
{
// System.Threading.SendOrPostCallback UnityEngine.UnitySynchronizationContext/WorkRequest::m_DelagateCallback
SendOrPostCallback_t5C292A12062F24027A98492F52ECFE9802AA6F0E* ___m_DelagateCallback_0;
// System.Object UnityEngine.UnitySynchronizationContext/WorkRequest::m_DelagateState
RuntimeObject* ___m_DelagateState_1;
// System.Threading.ManualResetEvent UnityEngine.UnitySynchronizationContext/WorkRequest::m_WaitHandle
ManualResetEvent_t63959486AA41A113A4353D0BF4A68E77EBA0A158* ___m_WaitHandle_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.UnitySynchronizationContext/WorkRequest
struct WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44_marshaled_pinvoke
{
Il2CppMethodPointer ___m_DelagateCallback_0;
Il2CppIUnknown* ___m_DelagateState_1;
ManualResetEvent_t63959486AA41A113A4353D0BF4A68E77EBA0A158* ___m_WaitHandle_2;
};
// Native definition for COM marshalling of UnityEngine.UnitySynchronizationContext/WorkRequest
struct WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44_marshaled_com
{
Il2CppMethodPointer ___m_DelagateCallback_0;
Il2CppIUnknown* ___m_DelagateState_1;
ManualResetEvent_t63959486AA41A113A4353D0BF4A68E77EBA0A158* ___m_WaitHandle_2;
};
// UnityEngine.UIElements.VisualElement/Hierarchy
struct Hierarchy_t4CF226F0EDE9C117C51C505730FC80641B1F1677
{
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.VisualElement/Hierarchy::m_Owner
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___m_Owner_0;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.VisualElement/Hierarchy
struct Hierarchy_t4CF226F0EDE9C117C51C505730FC80641B1F1677_marshaled_pinvoke
{
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___m_Owner_0;
};
// Native definition for COM marshalling of UnityEngine.UIElements.VisualElement/Hierarchy
struct Hierarchy_t4CF226F0EDE9C117C51C505730FC80641B1F1677_marshaled_com
{
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___m_Owner_0;
};
// UnityEngine.UIElements.VisualTreeAsset/SlotDefinition
struct SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8
{
// System.String UnityEngine.UIElements.VisualTreeAsset/SlotDefinition::name
String_t* ___name_0;
// System.Int32 UnityEngine.UIElements.VisualTreeAsset/SlotDefinition::insertionPointId
int32_t ___insertionPointId_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.VisualTreeAsset/SlotDefinition
struct SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8_marshaled_pinvoke
{
char* ___name_0;
int32_t ___insertionPointId_1;
};
// Native definition for COM marshalling of UnityEngine.UIElements.VisualTreeAsset/SlotDefinition
struct SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8_marshaled_com
{
Il2CppChar* ___name_0;
int32_t ___insertionPointId_1;
};
// UnityEngine.UIElements.VisualTreeAsset/SlotUsageEntry
struct SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76
{
// System.String UnityEngine.UIElements.VisualTreeAsset/SlotUsageEntry::slotName
String_t* ___slotName_0;
// System.Int32 UnityEngine.UIElements.VisualTreeAsset/SlotUsageEntry::assetId
int32_t ___assetId_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.VisualTreeAsset/SlotUsageEntry
struct SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76_marshaled_pinvoke
{
char* ___slotName_0;
int32_t ___assetId_1;
};
// Native definition for COM marshalling of UnityEngine.UIElements.VisualTreeAsset/SlotUsageEntry
struct SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76_marshaled_com
{
Il2CppChar* ___slotName_0;
int32_t ___assetId_1;
};
// UnityEngine.UIElements.VisualTreeAsset/UsingEntry
struct UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484
{
// System.String UnityEngine.UIElements.VisualTreeAsset/UsingEntry::alias
String_t* ___alias_1;
// System.String UnityEngine.UIElements.VisualTreeAsset/UsingEntry::path
String_t* ___path_2;
// UnityEngine.UIElements.VisualTreeAsset UnityEngine.UIElements.VisualTreeAsset/UsingEntry::asset
VisualTreeAsset_tFB5BF81F0780A412AE5A7C2C552B3EEA64EA2EEB* ___asset_3;
};
struct UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484_StaticFields
{
// System.Collections.Generic.IComparer`1<UnityEngine.UIElements.VisualTreeAsset/UsingEntry> UnityEngine.UIElements.VisualTreeAsset/UsingEntry::comparer
RuntimeObject* ___comparer_0;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.VisualTreeAsset/UsingEntry
struct UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484_marshaled_pinvoke
{
char* ___alias_1;
char* ___path_2;
VisualTreeAsset_tFB5BF81F0780A412AE5A7C2C552B3EEA64EA2EEB* ___asset_3;
};
// Native definition for COM marshalling of UnityEngine.UIElements.VisualTreeAsset/UsingEntry
struct UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484_marshaled_com
{
Il2CppChar* ___alias_1;
Il2CppChar* ___path_2;
VisualTreeAsset_tFB5BF81F0780A412AE5A7C2C552B3EEA64EA2EEB* ___asset_3;
};
// System.Threading.Volatile/VolatileObject
struct VolatileObject_tEA3ACFAAFB9D2EFA5162F693BAAB342EA7737B99
{
// System.Object modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.Volatile/VolatileObject::Value
RuntimeObject* ___Value_0;
};
// Native definition for P/Invoke marshalling of System.Threading.Volatile/VolatileObject
struct VolatileObject_tEA3ACFAAFB9D2EFA5162F693BAAB342EA7737B99_marshaled_pinvoke
{
RuntimeObject* ___Value_0;
};
// Native definition for COM marshalling of System.Threading.Volatile/VolatileObject
struct VolatileObject_tEA3ACFAAFB9D2EFA5162F693BAAB342EA7737B99_marshaled_com
{
RuntimeObject* ___Value_0;
};
// System.Number/NumberBuffer/DigitsAndNullTerminator
struct DigitsAndNullTerminator_tEF216B2D9886B3B6EBDBBA0E540214C013C02ECA
{
union
{
struct
{
};
uint8_t DigitsAndNullTerminator_tEF216B2D9886B3B6EBDBBA0E540214C013C02ECA__padding[102];
};
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.Rendering.BatchVisibility>
struct AlignOfHelper_1_t06B2AF48C49769AAD65F5E3F53EA9C54BFB10F00
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
BatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA ___data_1;
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.Color>
struct AlignOfHelper_1_tDD05A3FC824A309846DFDD7539C19F11BB681485
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___data_1;
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.Color32>
struct AlignOfHelper_1_t26A3226821AB86486949E2EEA83A5BE120465E3D
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___data_1;
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.UIElements.UIR.DrawBufferRange>
struct AlignOfHelper_1_t3F15C977CB75F6273144B3EB4A070152979E3542
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4 ___data_1;
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.Vector4>
struct AlignOfHelper_1_t715DBF373F018E47F9BAD31EF00130648BA568B2
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___data_1;
};
// System.ByReference`1<System.Char>
struct ByReference_1_t7BA5A6CA164F770BC688F21C5978D368716465F5
{
// System.IntPtr System.ByReference`1::_value
intptr_t ____value_0;
};
// UnityEngine.UIElements.UIR.Utility/GPUBuffer`1<System.UInt16>
struct GPUBuffer_1_tA865630D1AFA976A50A92C4ACE0243A78520BDC7 : public RuntimeObject
{
// System.IntPtr UnityEngine.UIElements.UIR.Utility/GPUBuffer`1::buffer
intptr_t ___buffer_0;
// System.Int32 UnityEngine.UIElements.UIR.Utility/GPUBuffer`1::elemCount
int32_t ___elemCount_1;
// System.Int32 UnityEngine.UIElements.UIR.Utility/GPUBuffer`1::elemStride
int32_t ___elemStride_2;
};
// UnityEngine.UIElements.UIR.Utility/GPUBuffer`1<UnityEngine.UIElements.Vertex>
struct GPUBuffer_1_tD1DC0573556845223680E17430EFF317DDA4A5AC : public RuntimeObject
{
// System.IntPtr UnityEngine.UIElements.UIR.Utility/GPUBuffer`1::buffer
intptr_t ___buffer_0;
// System.Int32 UnityEngine.UIElements.UIR.Utility/GPUBuffer`1::elemCount
int32_t ___elemCount_1;
// System.Int32 UnityEngine.UIElements.UIR.Utility/GPUBuffer`1::elemStride
int32_t ___elemStride_2;
};
// System.Collections.Generic.KeyValuePair`2<UnityEngine.PropertyName,System.Object>
struct KeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13
{
// TKey System.Collections.Generic.KeyValuePair`2::key
PropertyName_tE4B4AAA58AF3BF2C0CD95509EB7B786F096901C2 ___key_0;
// TValue System.Collections.Generic.KeyValuePair`2::value
RuntimeObject* ___value_1;
};
// UnityEngine.UIElements.Experimental.ValueAnimation`1<UnityEngine.UIElements.Experimental.StyleValues>
struct ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC : public RuntimeObject
{
// System.Int64 UnityEngine.UIElements.Experimental.ValueAnimation`1::m_StartTimeMs
int64_t ___m_StartTimeMs_0;
// System.Int32 UnityEngine.UIElements.Experimental.ValueAnimation`1::m_DurationMs
int32_t ___m_DurationMs_1;
// System.Func`2<System.Single,System.Single> UnityEngine.UIElements.Experimental.ValueAnimation`1::<easingCurve>k__BackingField
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___U3CeasingCurveU3Ek__BackingField_2;
// System.Boolean UnityEngine.UIElements.Experimental.ValueAnimation`1::<isRunning>k__BackingField
bool ___U3CisRunningU3Ek__BackingField_3;
// System.Action UnityEngine.UIElements.Experimental.ValueAnimation`1::<onAnimationCompleted>k__BackingField
Action_tD00B0A84D7945E50C2DFFC28EFEE6ED44ED2AD07* ___U3ConAnimationCompletedU3Ek__BackingField_4;
// System.Boolean UnityEngine.UIElements.Experimental.ValueAnimation`1::<autoRecycle>k__BackingField
bool ___U3CautoRecycleU3Ek__BackingField_5;
// System.Boolean UnityEngine.UIElements.Experimental.ValueAnimation`1::<recycled>k__BackingField
bool ___U3CrecycledU3Ek__BackingField_6;
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.Experimental.ValueAnimation`1::<owner>k__BackingField
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___U3CownerU3Ek__BackingField_8;
// System.Action`2<UnityEngine.UIElements.VisualElement,T> UnityEngine.UIElements.Experimental.ValueAnimation`1::<valueUpdated>k__BackingField
Action_2_tCFAD9DC5CF83678682A1102DCD1B12DE9FCA395A* ___U3CvalueUpdatedU3Ek__BackingField_9;
// System.Func`2<UnityEngine.UIElements.VisualElement,T> UnityEngine.UIElements.Experimental.ValueAnimation`1::<initialValue>k__BackingField
Func_2_t87FB5A45506EB8DF671CF8BEB31A0FD5A00FA227* ___U3CinitialValueU3Ek__BackingField_10;
// System.Func`4<T,T,System.Single,T> UnityEngine.UIElements.Experimental.ValueAnimation`1::<interpolator>k__BackingField
Func_4_t93A2D1B3300415C1167923C629725F6A8758E6B5* ___U3CinterpolatorU3Ek__BackingField_11;
// T UnityEngine.UIElements.Experimental.ValueAnimation`1::_from
StyleValues_t4AED947A53B84B62EF2B589A40B74911CA77D11A ____from_12;
// System.Boolean UnityEngine.UIElements.Experimental.ValueAnimation`1::fromValueSet
bool ___fromValueSet_13;
// T UnityEngine.UIElements.Experimental.ValueAnimation`1::<to>k__BackingField
StyleValues_t4AED947A53B84B62EF2B589A40B74911CA77D11A ___U3CtoU3Ek__BackingField_14;
};
struct ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC_StaticFields
{
// UnityEngine.UIElements.ObjectPool`1<UnityEngine.UIElements.Experimental.ValueAnimation`1<T>> UnityEngine.UIElements.Experimental.ValueAnimation`1::sObjectPool
ObjectPool_1_t048E004E7532AED8FD10569876C6065B7527D2AE* ___sObjectPool_7;
};
// System.ValueTuple`5<System.IntPtr,System.Int32,System.IntPtr,System.Int32,System.Boolean>
struct ValueTuple_5_t558B9F95CA55DE5694FC58A3BEAE441BF728FB57
{
// T1 System.ValueTuple`5::Item1
intptr_t ___Item1_0;
// T2 System.ValueTuple`5::Item2
int32_t ___Item2_1;
// T3 System.ValueTuple`5::Item3
intptr_t ___Item3_2;
// T4 System.ValueTuple`5::Item4
int32_t ___Item4_3;
// T5 System.ValueTuple`5::Item5
bool ___Item5_4;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.Background>
struct Values_1_t19A1E2B4752BCDF06B5D68597FF7E74704C6F99F : public Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24
{
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentTimeMs
int64_t ___m_CurrentTimeMs_0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentFrameEventsState
TransitionEventsFrameState_tE3B03C5A4D3A9B62395A67012747638ADE7B8D2D* ___m_CurrentFrameEventsState_1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_NextFrameEventsState
TransitionEventsFrameState_tE3B03C5A4D3A9B62395A67012747638ADE7B8D2D* ___m_NextFrameEventsState_2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<T>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<T>> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::running
AnimationDataSet_2_tA243970D144368E3CCB216CDCA976F7B00517D50 ___running_3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<T>,T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::completed
AnimationDataSet_2_t07C050B2EAC67E726A0EDE08E5279AEDE10CD2E1 ___completed_4;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.Color>
struct Values_1_t49C0EEE75C4A46F518DA157D93141A5AA673B5E0 : public Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24
{
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentTimeMs
int64_t ___m_CurrentTimeMs_0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentFrameEventsState
TransitionEventsFrameState_tC1DACCA9274641DD267223338E7C026D4CF520AC* ___m_CurrentFrameEventsState_1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_NextFrameEventsState
TransitionEventsFrameState_tC1DACCA9274641DD267223338E7C026D4CF520AC* ___m_NextFrameEventsState_2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<T>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<T>> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::running
AnimationDataSet_2_t05E5B46314C503F32CE3258CA1AF9DF73160F79D ___running_3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<T>,T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::completed
AnimationDataSet_2_t5C2C52995428480EE498ED27BBDAFCCE55045703 ___completed_4;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.Cursor>
struct Values_1_t669A6AFCA17FE6CB7D673FED4589CEDC1F145A98 : public Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24
{
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentTimeMs
int64_t ___m_CurrentTimeMs_0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentFrameEventsState
TransitionEventsFrameState_tE02BB17F313986E594A2CEC2FFE45236E28672B2* ___m_CurrentFrameEventsState_1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_NextFrameEventsState
TransitionEventsFrameState_tE02BB17F313986E594A2CEC2FFE45236E28672B2* ___m_NextFrameEventsState_2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<T>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<T>> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::running
AnimationDataSet_2_t6BC396B0B5FF985F629D1C8295796EBE26A30B48 ___running_3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<T>,T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::completed
AnimationDataSet_2_tD9DDD28AA56350E42A0698BF7B9BAF02785C90B5 ___completed_4;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.FontDefinition>
struct Values_1_t45BEBFF589B2E0FB589C839603CF54DAFA8EE2B7 : public Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24
{
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentTimeMs
int64_t ___m_CurrentTimeMs_0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentFrameEventsState
TransitionEventsFrameState_t2B8264420B693D76C74F99F305197870C62C10F4* ___m_CurrentFrameEventsState_1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_NextFrameEventsState
TransitionEventsFrameState_t2B8264420B693D76C74F99F305197870C62C10F4* ___m_NextFrameEventsState_2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<T>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<T>> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::running
AnimationDataSet_2_tEF417861004C34C4652386FBC8E77254726BA9AC ___running_3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<T>,T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::completed
AnimationDataSet_2_t484294514C51AC5E0E440CDA5AF2A1043C53E0FC ___completed_4;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<System.Int32>
struct Values_1_tF2422B8F8347145D2FE398C58F2EF1EAB96567A5 : public Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24
{
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentTimeMs
int64_t ___m_CurrentTimeMs_0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentFrameEventsState
TransitionEventsFrameState_tC8FEB488506DC99B874A454BED371793598879E9* ___m_CurrentFrameEventsState_1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_NextFrameEventsState
TransitionEventsFrameState_tC8FEB488506DC99B874A454BED371793598879E9* ___m_NextFrameEventsState_2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<T>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<T>> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::running
AnimationDataSet_2_t85603CE9660948961D59A0333F6A6309C7BB17FF ___running_3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<T>,T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::completed
AnimationDataSet_2_t4DB9D41C1AF8039FC6D44B76F29446F2BEC85A14 ___completed_4;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.Length>
struct Values_1_t988DC70C892CC8E803830C5C3A4370F5177CD9A6 : public Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24
{
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentTimeMs
int64_t ___m_CurrentTimeMs_0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentFrameEventsState
TransitionEventsFrameState_tFBFEC4A6BE1900A8D6115CD438F3CCC15A0DBCE9* ___m_CurrentFrameEventsState_1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_NextFrameEventsState
TransitionEventsFrameState_tFBFEC4A6BE1900A8D6115CD438F3CCC15A0DBCE9* ___m_NextFrameEventsState_2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<T>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<T>> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::running
AnimationDataSet_2_t45555A77E9CCB1712AFAC90FC398811D0DFC89D0 ___running_3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<T>,T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::completed
AnimationDataSet_2_tC6CE5153E3EAA98BB106BC6F00B2A9DE6FD23D69 ___completed_4;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<System.Object>
struct Values_1_t34227637D0C93F730700DFD895768AF8F8C7FF8D : public Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24
{
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentTimeMs
int64_t ___m_CurrentTimeMs_0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentFrameEventsState
TransitionEventsFrameState_tE30358B7263E3BE53EB8E856D7B0E1980F1AD855* ___m_CurrentFrameEventsState_1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_NextFrameEventsState
TransitionEventsFrameState_tE30358B7263E3BE53EB8E856D7B0E1980F1AD855* ___m_NextFrameEventsState_2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<T>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<T>> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::running
AnimationDataSet_2_t1BF178588B6708AE2B0B1E189EA53A67F8B421FB ___running_3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<T>,T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::completed
AnimationDataSet_2_t2AB6B1DCEF83474EFD60DF81EB5AC7788DA9AEE1 ___completed_4;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.Rotate>
struct Values_1_t1B84258FDB622ABECA26BA9E2E8F638E1B6B213F : public Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24
{
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentTimeMs
int64_t ___m_CurrentTimeMs_0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentFrameEventsState
TransitionEventsFrameState_t9DC16C7535A4271EA0FD763A64CD7CF84670EC64* ___m_CurrentFrameEventsState_1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_NextFrameEventsState
TransitionEventsFrameState_t9DC16C7535A4271EA0FD763A64CD7CF84670EC64* ___m_NextFrameEventsState_2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<T>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<T>> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::running
AnimationDataSet_2_t0C85CDF29C591FFB68A31A73E030182698C727FA ___running_3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<T>,T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::completed
AnimationDataSet_2_tC89D9008D3FFA8DFDC3145842EFEC11F9D8EBEAC ___completed_4;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.Scale>
struct Values_1_tD710D214E4D407A033AE57CE091D4C4FBB293714 : public Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24
{
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentTimeMs
int64_t ___m_CurrentTimeMs_0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentFrameEventsState
TransitionEventsFrameState_t25D5D3420391A40A0B978B0D5CA13F775283274E* ___m_CurrentFrameEventsState_1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_NextFrameEventsState
TransitionEventsFrameState_t25D5D3420391A40A0B978B0D5CA13F775283274E* ___m_NextFrameEventsState_2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<T>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<T>> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::running
AnimationDataSet_2_t295398C1274FE0EB846F0554EBF4EF36A80BCDBE ___running_3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<T>,T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::completed
AnimationDataSet_2_tF4CF89DB617BD2ACE24400B864B2FB32EADB9D04 ___completed_4;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<System.Single>
struct Values_1_t0E31EAA5A590859BBD863FE74A3208C8F5722AA1 : public Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24
{
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentTimeMs
int64_t ___m_CurrentTimeMs_0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentFrameEventsState
TransitionEventsFrameState_t864A52D0F7726A4F4C2C667BCB56E8A745F7340C* ___m_CurrentFrameEventsState_1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_NextFrameEventsState
TransitionEventsFrameState_t864A52D0F7726A4F4C2C667BCB56E8A745F7340C* ___m_NextFrameEventsState_2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<T>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<T>> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::running
AnimationDataSet_2_t6CCD1B60CF99FF9003A6D1D5C5902EC074711A32 ___running_3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<T>,T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::completed
AnimationDataSet_2_t37FCD741F1DDE73FBF7D33FB969BB39D5F0EB530 ___completed_4;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.TextShadow>
struct Values_1_tFB112CD52331C038F6B928FEAFAB19A06FD2F62C : public Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24
{
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentTimeMs
int64_t ___m_CurrentTimeMs_0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentFrameEventsState
TransitionEventsFrameState_t896507B4A758D8F131A06984765BA0F57C8939A2* ___m_CurrentFrameEventsState_1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_NextFrameEventsState
TransitionEventsFrameState_t896507B4A758D8F131A06984765BA0F57C8939A2* ___m_NextFrameEventsState_2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<T>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<T>> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::running
AnimationDataSet_2_t9B3435A0C6251F2602B478702F4F7EC8CEDBC437 ___running_3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<T>,T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::completed
AnimationDataSet_2_t41E105586D98932D715A57A47A3E21B5C3A7B340 ___completed_4;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.TransformOrigin>
struct Values_1_t4B3725FE6B9D8A60439FC42ABC27E2FAE91ACBA5 : public Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24
{
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentTimeMs
int64_t ___m_CurrentTimeMs_0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentFrameEventsState
TransitionEventsFrameState_t7FB3FD474018D429F5F1EE705EF9ADA6F197EDEF* ___m_CurrentFrameEventsState_1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_NextFrameEventsState
TransitionEventsFrameState_t7FB3FD474018D429F5F1EE705EF9ADA6F197EDEF* ___m_NextFrameEventsState_2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<T>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<T>> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::running
AnimationDataSet_2_t51062A50DDCEFF7458A164F033D211C9E0701513 ___running_3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<T>,T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::completed
AnimationDataSet_2_t4532152E7A78B3E14F61FA9CA7C80BC1C3269D33 ___completed_4;
};
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<UnityEngine.UIElements.Translate>
struct Values_1_tF515CA326AF84CBBA1A40F1C76BC6D39AA409215 : public Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24
{
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentTimeMs
int64_t ___m_CurrentTimeMs_0;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_CurrentFrameEventsState
TransitionEventsFrameState_t3F9A8EB2B33780D3F2037BFEED0A3C6A03B03FEC* ___m_CurrentFrameEventsState_1;
// UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TransitionEventsFrameState<T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::m_NextFrameEventsState
TransitionEventsFrameState_t3F9A8EB2B33780D3F2037BFEED0A3C6A03B03FEC* ___m_NextFrameEventsState_2;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/TimingData<T>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/StyleData<T>> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::running
AnimationDataSet_2_t22FC41AC7166F393727321C212FD541AA7DC4880 ___running_3;
// UnityEngine.UIElements.StylePropertyAnimationSystem/AnimationDataSet`2<UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1/EmptyData<T>,T> UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1::completed
AnimationDataSet_2_t9D395E96FBE02DA4D17B2E175F9B5C297C1BBAA8 ___completed_4;
};
// System.Numerics.Vector`1<System.UInt16>
struct Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489
{
// System.Numerics.Register System.Numerics.Vector`1::register
Register_t483055A1DB8634BA3FBF01BB15D4E94E186A2E7A ___register_0;
};
struct Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489_StaticFields
{
// System.Int32 System.Numerics.Vector`1::s_count
int32_t ___s_count_1;
// System.Numerics.Vector`1<T> System.Numerics.Vector`1::s_zero
Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 ___s_zero_2;
// System.Numerics.Vector`1<T> System.Numerics.Vector`1::s_one
Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 ___s_one_3;
// System.Numerics.Vector`1<T> System.Numerics.Vector`1::s_allOnes
Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 ___s_allOnes_4;
};
// System.Numerics.Vector`1<System.UInt64>
struct Vector_1_t566D05A9DE75BCD8F12F1E09AC3F8A4BC01BF92A
{
// System.Numerics.Register System.Numerics.Vector`1::register
Register_t483055A1DB8634BA3FBF01BB15D4E94E186A2E7A ___register_0;
};
struct Vector_1_t566D05A9DE75BCD8F12F1E09AC3F8A4BC01BF92A_StaticFields
{
// System.Int32 System.Numerics.Vector`1::s_count
int32_t ___s_count_1;
// System.Numerics.Vector`1<T> System.Numerics.Vector`1::s_zero
Vector_1_t566D05A9DE75BCD8F12F1E09AC3F8A4BC01BF92A ___s_zero_2;
// System.Numerics.Vector`1<T> System.Numerics.Vector`1::s_one
Vector_1_t566D05A9DE75BCD8F12F1E09AC3F8A4BC01BF92A ___s_one_3;
// System.Numerics.Vector`1<T> System.Numerics.Vector`1::s_allOnes
Vector_1_t566D05A9DE75BCD8F12F1E09AC3F8A4BC01BF92A ___s_allOnes_4;
};
// Unity.Collections.Allocator
struct Allocator_t996642592271AAD9EE688F142741D512C07B5824
{
// System.Int32 Unity.Collections.Allocator::value__
int32_t ___value___2;
};
// System.Reflection.BindingFlags
struct BindingFlags_t5DC2835E4AE9C1862B3AD172EF35B6A5F4F1812C
{
// System.Int32 System.Reflection.BindingFlags::value__
int32_t ___value___2;
};
// UnityEngine.Timeline.ClipCaps
struct ClipCaps_t5A4215235745856AF28238667B359DD8C4BD76DE
{
// System.Int32 UnityEngine.Timeline.ClipCaps::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.UIR.Implementation.ClipMethod
struct ClipMethod_t576E65D24928AB1D0072DB926DDFA98B84FBCEDB
{
// System.Int32 UnityEngine.UIElements.UIR.Implementation.ClipMethod::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.ComputedStyle
struct ComputedStyle_t8B08CCCEE20525528B3FFDAC6D3F58F101AAF54C
{
// UnityEngine.UIElements.StyleDataRef`1<UnityEngine.UIElements.InheritedData> UnityEngine.UIElements.ComputedStyle::inheritedData
StyleDataRef_1_tBB9987581539847AE5CCA2EA2349E05CDC9127FA ___inheritedData_0;
// UnityEngine.UIElements.StyleDataRef`1<UnityEngine.UIElements.LayoutData> UnityEngine.UIElements.ComputedStyle::layoutData
StyleDataRef_1_t5330A6F4EAC0EAB88E3B9849D866AA23BB6BE5F4 ___layoutData_1;
// UnityEngine.UIElements.StyleDataRef`1<UnityEngine.UIElements.RareData> UnityEngine.UIElements.ComputedStyle::rareData
StyleDataRef_1_tF773E9CBC6DC0FEB38DF95A6F3F47AC49AE045B3 ___rareData_2;
// UnityEngine.UIElements.StyleDataRef`1<UnityEngine.UIElements.TransformData> UnityEngine.UIElements.ComputedStyle::transformData
StyleDataRef_1_t1D59CCAB740BE6B330D5B5FDA9F67391800200B3 ___transformData_3;
// UnityEngine.UIElements.StyleDataRef`1<UnityEngine.UIElements.TransitionData> UnityEngine.UIElements.ComputedStyle::transitionData
StyleDataRef_1_t6A7B146DD79EDF7F42CD8CCF3E411B40AA729B8E ___transitionData_4;
// UnityEngine.UIElements.StyleDataRef`1<UnityEngine.UIElements.VisualData> UnityEngine.UIElements.ComputedStyle::visualData
StyleDataRef_1_t9CB834B90E638D92A3BE5123B0D3989697AA87FC ___visualData_5;
// UnityEngine.Yoga.YogaNode UnityEngine.UIElements.ComputedStyle::yogaNode
YogaNode_t4B5B593220CCB315B5A60CB48BA4795636F04DDA* ___yogaNode_6;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.UIElements.StyleSheets.StylePropertyValue> UnityEngine.UIElements.ComputedStyle::customProperties
Dictionary_2_t645C7B1DAE2D839B52A5E387C165CE13D5465B00* ___customProperties_7;
// System.Int64 UnityEngine.UIElements.ComputedStyle::matchingRulesHash
int64_t ___matchingRulesHash_8;
// System.Single UnityEngine.UIElements.ComputedStyle::dpiScaling
float ___dpiScaling_9;
// UnityEngine.UIElements.ComputedTransitionProperty[] UnityEngine.UIElements.ComputedStyle::computedTransitions
ComputedTransitionPropertyU5BU5D_t25B9E78F5276CDA297C8215C316452CAB8219E82* ___computedTransitions_10;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.ComputedStyle
struct ComputedStyle_t8B08CCCEE20525528B3FFDAC6D3F58F101AAF54C_marshaled_pinvoke
{
StyleDataRef_1_tBB9987581539847AE5CCA2EA2349E05CDC9127FA ___inheritedData_0;
StyleDataRef_1_t5330A6F4EAC0EAB88E3B9849D866AA23BB6BE5F4 ___layoutData_1;
StyleDataRef_1_tF773E9CBC6DC0FEB38DF95A6F3F47AC49AE045B3 ___rareData_2;
StyleDataRef_1_t1D59CCAB740BE6B330D5B5FDA9F67391800200B3 ___transformData_3;
StyleDataRef_1_t6A7B146DD79EDF7F42CD8CCF3E411B40AA729B8E ___transitionData_4;
StyleDataRef_1_t9CB834B90E638D92A3BE5123B0D3989697AA87FC ___visualData_5;
YogaNode_t4B5B593220CCB315B5A60CB48BA4795636F04DDA* ___yogaNode_6;
Dictionary_2_t645C7B1DAE2D839B52A5E387C165CE13D5465B00* ___customProperties_7;
int64_t ___matchingRulesHash_8;
float ___dpiScaling_9;
ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1_marshaled_pinvoke* ___computedTransitions_10;
};
// Native definition for COM marshalling of UnityEngine.UIElements.ComputedStyle
struct ComputedStyle_t8B08CCCEE20525528B3FFDAC6D3F58F101AAF54C_marshaled_com
{
StyleDataRef_1_tBB9987581539847AE5CCA2EA2349E05CDC9127FA ___inheritedData_0;
StyleDataRef_1_t5330A6F4EAC0EAB88E3B9849D866AA23BB6BE5F4 ___layoutData_1;
StyleDataRef_1_tF773E9CBC6DC0FEB38DF95A6F3F47AC49AE045B3 ___rareData_2;
StyleDataRef_1_t1D59CCAB740BE6B330D5B5FDA9F67391800200B3 ___transformData_3;
StyleDataRef_1_t6A7B146DD79EDF7F42CD8CCF3E411B40AA729B8E ___transitionData_4;
StyleDataRef_1_t9CB834B90E638D92A3BE5123B0D3989697AA87FC ___visualData_5;
YogaNode_t4B5B593220CCB315B5A60CB48BA4795636F04DDA* ___yogaNode_6;
Dictionary_2_t645C7B1DAE2D839B52A5E387C165CE13D5465B00* ___customProperties_7;
int64_t ___matchingRulesHash_8;
float ___dpiScaling_9;
ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1_marshaled_com* ___computedTransitions_10;
};
// UnityEngine.UIElements.Cursor
struct Cursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82
{
// UnityEngine.Texture2D UnityEngine.UIElements.Cursor::<texture>k__BackingField
Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* ___U3CtextureU3Ek__BackingField_0;
// UnityEngine.Vector2 UnityEngine.UIElements.Cursor::<hotspot>k__BackingField
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___U3ChotspotU3Ek__BackingField_1;
// System.Int32 UnityEngine.UIElements.Cursor::<defaultCursorId>k__BackingField
int32_t ___U3CdefaultCursorIdU3Ek__BackingField_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.Cursor
struct Cursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82_marshaled_pinvoke
{
Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* ___U3CtextureU3Ek__BackingField_0;
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___U3ChotspotU3Ek__BackingField_1;
int32_t ___U3CdefaultCursorIdU3Ek__BackingField_2;
};
// Native definition for COM marshalling of UnityEngine.UIElements.Cursor
struct Cursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82_marshaled_com
{
Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* ___U3CtextureU3Ek__BackingField_0;
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___U3ChotspotU3Ek__BackingField_1;
int32_t ___U3CdefaultCursorIdU3Ek__BackingField_2;
};
// System.Delegate
struct Delegate_t : public RuntimeObject
{
// System.IntPtr System.Delegate::method_ptr
Il2CppMethodPointer ___method_ptr_0;
// System.IntPtr System.Delegate::invoke_impl
intptr_t ___invoke_impl_1;
// System.Object System.Delegate::m_target
RuntimeObject* ___m_target_2;
// System.IntPtr System.Delegate::method
intptr_t ___method_3;
// System.IntPtr System.Delegate::delegate_trampoline
intptr_t ___delegate_trampoline_4;
// System.IntPtr System.Delegate::extra_arg
intptr_t ___extra_arg_5;
// System.IntPtr System.Delegate::method_code
intptr_t ___method_code_6;
// System.IntPtr System.Delegate::interp_method
intptr_t ___interp_method_7;
// System.IntPtr System.Delegate::interp_invoke_impl
intptr_t ___interp_invoke_impl_8;
// System.Reflection.MethodInfo System.Delegate::method_info
MethodInfo_t* ___method_info_9;
// System.Reflection.MethodInfo System.Delegate::original_method_info
MethodInfo_t* ___original_method_info_10;
// System.DelegateData System.Delegate::data
DelegateData_t9B286B493293CD2D23A5B2B5EF0E5B1324C2B77E* ___data_11;
// System.Boolean System.Delegate::method_is_virtual
bool ___method_is_virtual_12;
};
// Native definition for P/Invoke marshalling of System.Delegate
struct Delegate_t_marshaled_pinvoke
{
intptr_t ___method_ptr_0;
intptr_t ___invoke_impl_1;
Il2CppIUnknown* ___m_target_2;
intptr_t ___method_3;
intptr_t ___delegate_trampoline_4;
intptr_t ___extra_arg_5;
intptr_t ___method_code_6;
intptr_t ___interp_method_7;
intptr_t ___interp_invoke_impl_8;
MethodInfo_t* ___method_info_9;
MethodInfo_t* ___original_method_info_10;
DelegateData_t9B286B493293CD2D23A5B2B5EF0E5B1324C2B77E* ___data_11;
int32_t ___method_is_virtual_12;
};
// Native definition for COM marshalling of System.Delegate
struct Delegate_t_marshaled_com
{
intptr_t ___method_ptr_0;
intptr_t ___invoke_impl_1;
Il2CppIUnknown* ___m_target_2;
intptr_t ___method_3;
intptr_t ___delegate_trampoline_4;
intptr_t ___extra_arg_5;
intptr_t ___method_code_6;
intptr_t ___interp_method_7;
intptr_t ___interp_invoke_impl_8;
MethodInfo_t* ___method_info_9;
MethodInfo_t* ___original_method_info_10;
DelegateData_t9B286B493293CD2D23A5B2B5EF0E5B1324C2B77E* ___data_11;
int32_t ___method_is_virtual_12;
};
// UnityEngine.UIElements.EasingMode
struct EasingMode_tEF87477B9B9EB2524525550AE5ABEBC00FC7B0DF
{
// System.Int32 UnityEngine.UIElements.EasingMode::value__
int32_t ___value___2;
};
// UnityEngine.EventModifiers
struct EventModifiers_t48244B043FBB42CDD555C6AC43279EC7158777AC
{
// System.Int32 UnityEngine.EventModifiers::value__
int32_t ___value___2;
};
// System.Exception
struct Exception_t : public RuntimeObject
{
// 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_tCBB85B95DFD1634237140CD892E82D06ECB3F5E6* ____safeSerializationManager_13;
// System.Diagnostics.StackTrace[] System.Exception::captured_traces
StackTraceU5BU5D_t32FBCB20930EAF5BAE3F450FF75228E5450DA0DF* ___captured_traces_14;
// System.IntPtr[] System.Exception::native_trace_ips
IntPtrU5BU5D_tFD177F8C806A6921AD7150264CCC62FA00CAD832* ___native_trace_ips_15;
// System.Int32 System.Exception::caught_in_unmanaged
int32_t ___caught_in_unmanaged_16;
};
struct Exception_t_StaticFields
{
// System.Object System.Exception::s_EDILock
RuntimeObject* ___s_EDILock_0;
};
// 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_tCBB85B95DFD1634237140CD892E82D06ECB3F5E6* ____safeSerializationManager_13;
StackTraceU5BU5D_t32FBCB20930EAF5BAE3F450FF75228E5450DA0DF* ___captured_traces_14;
Il2CppSafeArray/*NONE*/* ___native_trace_ips_15;
int32_t ___caught_in_unmanaged_16;
};
// 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_tCBB85B95DFD1634237140CD892E82D06ECB3F5E6* ____safeSerializationManager_13;
StackTraceU5BU5D_t32FBCB20930EAF5BAE3F450FF75228E5450DA0DF* ___captured_traces_14;
Il2CppSafeArray/*NONE*/* ___native_trace_ips_15;
int32_t ___caught_in_unmanaged_16;
};
// System.ExceptionArgument
struct ExceptionArgument_t60E7F8D9DE5362CBE9365893983C30302D83B778
{
// System.Int32 System.ExceptionArgument::value__
int32_t ___value___2;
};
// UnityEngine.Experimental.GlobalIllumination.FalloffType
struct FalloffType_tE9BECCB411DA63109760103AF7476F422A01376D
{
// System.Byte UnityEngine.Experimental.GlobalIllumination.FalloffType::value__
uint8_t ___value___2;
};
// UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags
struct FontFeatureLookupFlags_t2000121BA341A3CAE5E0D4FAC6AA4378FE14AE1B
{
// System.Int32 UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags::value__
int32_t ___value___2;
};
// UnityEngine.TextCore.Text.FontStyles
struct FontStyles_t284AF8C10031F4774DF8BC8DE6DF9EC11EE14668
{
// System.Int32 UnityEngine.TextCore.Text.FontStyles::value__
int32_t ___value___2;
};
// System.Runtime.InteropServices.GCHandle
struct GCHandle_tC44F6F72EE68BD4CFABA24309DA7A179D41127DC
{
// System.IntPtr System.Runtime.InteropServices.GCHandle::handle
intptr_t ___handle_0;
};
// UnityEngine.UIElements.UIR.GfxUpdateBufferRange
struct GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97
{
// System.UInt32 UnityEngine.UIElements.UIR.GfxUpdateBufferRange::offsetFromWriteStart
uint32_t ___offsetFromWriteStart_0;
// System.UInt32 UnityEngine.UIElements.UIR.GfxUpdateBufferRange::size
uint32_t ___size_1;
// System.UIntPtr UnityEngine.UIElements.UIR.GfxUpdateBufferRange::source
uintptr_t ___source_2;
};
// UnityEngine.TextCore.LowLevel.GlyphAdjustmentRecord
struct GlyphAdjustmentRecord_tC7A1B2E0AC7C4ED9CDB8E95E48790A46B6F315F7
{
// System.UInt32 UnityEngine.TextCore.LowLevel.GlyphAdjustmentRecord::m_GlyphIndex
uint32_t ___m_GlyphIndex_0;
// UnityEngine.TextCore.LowLevel.GlyphValueRecord UnityEngine.TextCore.LowLevel.GlyphAdjustmentRecord::m_GlyphValueRecord
GlyphValueRecord_t780927A39D46924E0D546A2AE5DDF1BB2B5A9C8E ___m_GlyphValueRecord_1;
};
// UnityEngine.UIElements.Hashes
struct Hashes_t2535089FD6C6F036205113292C62B0D6E286ABE6
{
// UnityEngine.UIElements.Hashes/<hashes>e__FixedBuffer UnityEngine.UIElements.Hashes::hashes
U3ChashesU3Ee__FixedBuffer_tB9B9E597830648919837C8EFBAD317741097D94E ___hashes_1;
};
// System.Int32Enum
struct Int32Enum_tCBAC8BA2BFF3A845FA599F303093BBBA374B6F0C
{
// System.Int32 System.Int32Enum::value__
int32_t ___value___2;
};
// Unity.Jobs.JobHandle
struct JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08
{
// System.IntPtr Unity.Jobs.JobHandle::jobGroup
intptr_t ___jobGroup_0;
// System.Int32 Unity.Jobs.JobHandle::version
int32_t ___version_1;
};
// UnityEngine.Experimental.GlobalIllumination.LightMode
struct LightMode_t058E4E7AAE5689BCFF46BB8E0259D90D227E7FF9
{
// System.Byte UnityEngine.Experimental.GlobalIllumination.LightMode::value__
uint8_t ___value___2;
};
// UnityEngine.Experimental.GlobalIllumination.LightType
struct LightType_t97C5050F2F742FBF050FEB8FC5131A9A8DB50D26
{
// System.Byte UnityEngine.Experimental.GlobalIllumination.LightType::value__
uint8_t ___value___2;
};
// UnityEngine.TextCore.Text.MarkToBaseAdjustmentRecord
struct MarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437
{
// System.UInt32 UnityEngine.TextCore.Text.MarkToBaseAdjustmentRecord::m_BaseGlyphID
uint32_t ___m_BaseGlyphID_0;
// UnityEngine.TextCore.Text.GlyphAnchorPoint UnityEngine.TextCore.Text.MarkToBaseAdjustmentRecord::m_BaseGlyphAnchorPoint
GlyphAnchorPoint_t5B67FFC3E40D32105FADE04ED0A705F66C992A24 ___m_BaseGlyphAnchorPoint_1;
// System.UInt32 UnityEngine.TextCore.Text.MarkToBaseAdjustmentRecord::m_MarkGlyphID
uint32_t ___m_MarkGlyphID_2;
// UnityEngine.TextCore.Text.MarkPositionAdjustment UnityEngine.TextCore.Text.MarkToBaseAdjustmentRecord::m_MarkPositionAdjustment
MarkPositionAdjustment_t437B0951674D336156DE28F420A9DE902978D639 ___m_MarkPositionAdjustment_3;
};
// UnityEngine.TextCore.Text.MarkToMarkAdjustmentRecord
struct MarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6
{
// System.UInt32 UnityEngine.TextCore.Text.MarkToMarkAdjustmentRecord::m_BaseMarkGlyphID
uint32_t ___m_BaseMarkGlyphID_0;
// UnityEngine.TextCore.Text.GlyphAnchorPoint UnityEngine.TextCore.Text.MarkToMarkAdjustmentRecord::m_BaseMarkGlyphAnchorPoint
GlyphAnchorPoint_t5B67FFC3E40D32105FADE04ED0A705F66C992A24 ___m_BaseMarkGlyphAnchorPoint_1;
// System.UInt32 UnityEngine.TextCore.Text.MarkToMarkAdjustmentRecord::m_CombiningMarkGlyphID
uint32_t ___m_CombiningMarkGlyphID_2;
// UnityEngine.TextCore.Text.MarkPositionAdjustment UnityEngine.TextCore.Text.MarkToMarkAdjustmentRecord::m_CombiningMarkPositionAdjustment
MarkPositionAdjustment_t437B0951674D336156DE28F420A9DE902978D639 ___m_CombiningMarkPositionAdjustment_3;
};
// UnityEngine.MaterialPropertyBlock
struct MaterialPropertyBlock_t2308669579033A857EFE6E4831909F638B27411D : public RuntimeObject
{
// System.IntPtr UnityEngine.MaterialPropertyBlock::m_Ptr
intptr_t ___m_Ptr_0;
};
// UnityEngine.TextCore.Text.MeshInfo
struct MeshInfo_tE55C4A8846CC2C399CCC3FE989476D987B86AB2F
{
// System.Int32 UnityEngine.TextCore.Text.MeshInfo::vertexCount
int32_t ___vertexCount_1;
// UnityEngine.Vector3[] UnityEngine.TextCore.Text.MeshInfo::vertices
Vector3U5BU5D_tFF1859CCE176131B909E2044F76443064254679C* ___vertices_2;
// UnityEngine.Vector2[] UnityEngine.TextCore.Text.MeshInfo::uvs0
Vector2U5BU5D_tFEBBC94BCC6C9C88277BA04047D2B3FDB6ED7FDA* ___uvs0_3;
// UnityEngine.Vector2[] UnityEngine.TextCore.Text.MeshInfo::uvs2
Vector2U5BU5D_tFEBBC94BCC6C9C88277BA04047D2B3FDB6ED7FDA* ___uvs2_4;
// UnityEngine.Color32[] UnityEngine.TextCore.Text.MeshInfo::colors32
Color32U5BU5D_t38116C3E91765C4C5726CE12C77FAD7F9F737259* ___colors32_5;
// System.Int32[] UnityEngine.TextCore.Text.MeshInfo::triangles
Int32U5BU5D_t19C97395396A72ECAF310612F0760F165060314C* ___triangles_6;
// UnityEngine.Material UnityEngine.TextCore.Text.MeshInfo::material
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___material_7;
};
struct MeshInfo_tE55C4A8846CC2C399CCC3FE989476D987B86AB2F_StaticFields
{
// UnityEngine.Color32 UnityEngine.TextCore.Text.MeshInfo::k_DefaultColor
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___k_DefaultColor_0;
};
// Native definition for P/Invoke marshalling of UnityEngine.TextCore.Text.MeshInfo
struct MeshInfo_tE55C4A8846CC2C399CCC3FE989476D987B86AB2F_marshaled_pinvoke
{
int32_t ___vertexCount_1;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2* ___vertices_2;
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7* ___uvs0_3;
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7* ___uvs2_4;
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B* ___colors32_5;
Il2CppSafeArray/*NONE*/* ___triangles_6;
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___material_7;
};
// Native definition for COM marshalling of UnityEngine.TextCore.Text.MeshInfo
struct MeshInfo_tE55C4A8846CC2C399CCC3FE989476D987B86AB2F_marshaled_com
{
int32_t ___vertexCount_1;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2* ___vertices_2;
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7* ___uvs0_3;
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7* ___uvs2_4;
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B* ___colors32_5;
Il2CppSafeArray/*NONE*/* ___triangles_6;
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___material_7;
};
// UnityEngine.ModifiableContactPair
struct ModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960
{
// System.IntPtr UnityEngine.ModifiableContactPair::actor
intptr_t ___actor_0;
// System.IntPtr UnityEngine.ModifiableContactPair::otherActor
intptr_t ___otherActor_1;
// System.IntPtr UnityEngine.ModifiableContactPair::shape
intptr_t ___shape_2;
// System.IntPtr UnityEngine.ModifiableContactPair::otherShape
intptr_t ___otherShape_3;
// UnityEngine.Quaternion UnityEngine.ModifiableContactPair::rotation
Quaternion_tDA59F214EF07D7700B26E40E562F267AF7306974 ___rotation_4;
// UnityEngine.Vector3 UnityEngine.ModifiableContactPair::position
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___position_5;
// UnityEngine.Quaternion UnityEngine.ModifiableContactPair::otherRotation
Quaternion_tDA59F214EF07D7700B26E40E562F267AF7306974 ___otherRotation_6;
// UnityEngine.Vector3 UnityEngine.ModifiableContactPair::otherPosition
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___otherPosition_7;
// System.Int32 UnityEngine.ModifiableContactPair::numContacts
int32_t ___numContacts_8;
// System.IntPtr UnityEngine.ModifiableContactPair::contacts
intptr_t ___contacts_9;
};
// UnityEngine.UIElements.MouseButton
struct MouseButton_tEF578B8F208D798E053BC320C29FCBB655E24454
{
// System.Int32 UnityEngine.UIElements.MouseButton::value__
int32_t ___value___2;
};
// UnityEngine.Timeline.NotificationFlags
struct NotificationFlags_tB23F73EAAD5438F9AC46646EAE9BCBEA142ABC1A
{
// System.Int16 UnityEngine.Timeline.NotificationFlags::value__
int16_t ___value___2;
};
// UnityEngine.Object
struct Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C : public RuntimeObject
{
// System.IntPtr UnityEngine.Object::m_CachedPtr
intptr_t ___m_CachedPtr_0;
};
struct Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C_StaticFields
{
// System.Int32 UnityEngine.Object::OffsetOfInstanceIDInCPlusPlusObject
int32_t ___OffsetOfInstanceIDInCPlusPlusObject_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.Object
struct Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C_marshaled_pinvoke
{
intptr_t ___m_CachedPtr_0;
};
// Native definition for COM marshalling of UnityEngine.Object
struct Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C_marshaled_com
{
intptr_t ___m_CachedPtr_0;
};
// UnityEngine.UIElements.UIR.OwnedState
struct OwnedState_t0957CA36E21DE8A443B616EBE83B25CCCA70B5A4
{
// System.Byte UnityEngine.UIElements.UIR.OwnedState::value__
uint8_t ___value___2;
};
// UnityEngine.UIElements.PanelClearSettings
struct PanelClearSettings_tA3D8EE9A4864781CE3E5FED5225C6FB37ED66EE7
{
// System.Boolean UnityEngine.UIElements.PanelClearSettings::clearDepthStencil
bool ___clearDepthStencil_0;
// System.Boolean UnityEngine.UIElements.PanelClearSettings::clearColor
bool ___clearColor_1;
// UnityEngine.Color UnityEngine.UIElements.PanelClearSettings::color
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___color_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.PanelClearSettings
struct PanelClearSettings_tA3D8EE9A4864781CE3E5FED5225C6FB37ED66EE7_marshaled_pinvoke
{
int32_t ___clearDepthStencil_0;
int32_t ___clearColor_1;
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___color_2;
};
// Native definition for COM marshalling of UnityEngine.UIElements.PanelClearSettings
struct PanelClearSettings_tA3D8EE9A4864781CE3E5FED5225C6FB37ED66EE7_marshaled_com
{
int32_t ___clearDepthStencil_0;
int32_t ___clearColor_1;
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___color_2;
};
// UnityEngine.UIElements.PickingMode
struct PickingMode_t5699BF9E5F2587E0D297984D5BF5B63B768E66AC
{
// System.Int32 UnityEngine.UIElements.PickingMode::value__
int32_t ___value___2;
};
// UnityEngine.Plane
struct Plane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C
{
// UnityEngine.Vector3 UnityEngine.Plane::m_Normal
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___m_Normal_0;
// System.Single UnityEngine.Plane::m_Distance
float ___m_Distance_1;
};
// UnityEngine.Playables.PlayableHandle
struct PlayableHandle_t5D6A01EF94382EFEDC047202F71DF882769654D4
{
// System.IntPtr UnityEngine.Playables.PlayableHandle::m_Handle
intptr_t ___m_Handle_0;
// System.UInt32 UnityEngine.Playables.PlayableHandle::m_Version
uint32_t ___m_Version_1;
};
struct PlayableHandle_t5D6A01EF94382EFEDC047202F71DF882769654D4_StaticFields
{
// UnityEngine.Playables.PlayableHandle UnityEngine.Playables.PlayableHandle::m_Null
PlayableHandle_t5D6A01EF94382EFEDC047202F71DF882769654D4 ___m_Null_2;
};
// Unity.Profiling.ProfilerMarker
struct ProfilerMarker_tA256E18DA86EDBC5528CE066FC91C96EE86501AD
{
// System.IntPtr Unity.Profiling.ProfilerMarker::m_Ptr
intptr_t ___m_Ptr_0;
};
// UnityEngine.UIElements.PseudoStates
struct PseudoStates_tF4AB056E8743741BCE464A0983A060A53AAB7E4D
{
// System.Int32 UnityEngine.UIElements.PseudoStates::value__
int32_t ___value___2;
};
// UnityEngine.RaycastHit2D
struct RaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA
{
// UnityEngine.Vector2 UnityEngine.RaycastHit2D::m_Centroid
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___m_Centroid_0;
// UnityEngine.Vector2 UnityEngine.RaycastHit2D::m_Point
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___m_Point_1;
// UnityEngine.Vector2 UnityEngine.RaycastHit2D::m_Normal
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___m_Normal_2;
// System.Single UnityEngine.RaycastHit2D::m_Distance
float ___m_Distance_3;
// System.Single UnityEngine.RaycastHit2D::m_Fraction
float ___m_Fraction_4;
// System.Int32 UnityEngine.RaycastHit2D::m_Collider
int32_t ___m_Collider_5;
};
// UnityEngine.EventSystems.RaycastResult
struct RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023
{
// UnityEngine.GameObject UnityEngine.EventSystems.RaycastResult::m_GameObject
GameObject_t76FEDD663AB33C991A9C9A23129337651094216F* ___m_GameObject_0;
// UnityEngine.EventSystems.BaseRaycaster UnityEngine.EventSystems.RaycastResult::module
BaseRaycaster_t7DC8158FD3CA0193455344379DD5FF7CD5F1F832* ___module_1;
// System.Single UnityEngine.EventSystems.RaycastResult::distance
float ___distance_2;
// System.Single UnityEngine.EventSystems.RaycastResult::index
float ___index_3;
// System.Int32 UnityEngine.EventSystems.RaycastResult::depth
int32_t ___depth_4;
// System.Int32 UnityEngine.EventSystems.RaycastResult::sortingLayer
int32_t ___sortingLayer_5;
// System.Int32 UnityEngine.EventSystems.RaycastResult::sortingOrder
int32_t ___sortingOrder_6;
// UnityEngine.Vector3 UnityEngine.EventSystems.RaycastResult::worldPosition
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___worldPosition_7;
// UnityEngine.Vector3 UnityEngine.EventSystems.RaycastResult::worldNormal
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___worldNormal_8;
// UnityEngine.Vector2 UnityEngine.EventSystems.RaycastResult::screenPosition
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___screenPosition_9;
// System.Int32 UnityEngine.EventSystems.RaycastResult::displayIndex
int32_t ___displayIndex_10;
};
// Native definition for P/Invoke marshalling of UnityEngine.EventSystems.RaycastResult
struct RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023_marshaled_pinvoke
{
GameObject_t76FEDD663AB33C991A9C9A23129337651094216F* ___m_GameObject_0;
BaseRaycaster_t7DC8158FD3CA0193455344379DD5FF7CD5F1F832* ___module_1;
float ___distance_2;
float ___index_3;
int32_t ___depth_4;
int32_t ___sortingLayer_5;
int32_t ___sortingOrder_6;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___worldPosition_7;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___worldNormal_8;
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___screenPosition_9;
int32_t ___displayIndex_10;
};
// Native definition for COM marshalling of UnityEngine.EventSystems.RaycastResult
struct RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023_marshaled_com
{
GameObject_t76FEDD663AB33C991A9C9A23129337651094216F* ___m_GameObject_0;
BaseRaycaster_t7DC8158FD3CA0193455344379DD5FF7CD5F1F832* ___module_1;
float ___distance_2;
float ___index_3;
int32_t ___depth_4;
int32_t ___sortingLayer_5;
int32_t ___sortingOrder_6;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___worldPosition_7;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___worldNormal_8;
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___screenPosition_9;
int32_t ___displayIndex_10;
};
// UnityEngine.UIElements.UIR.RenderDataDirtyTypes
struct RenderDataDirtyTypes_tEF0AE4EB7DF790A711AA45103050432B8FEDB907
{
// System.Int32 UnityEngine.UIElements.UIR.RenderDataDirtyTypes::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.RenderHints
struct RenderHints_t4032FC4AB3FD946FD2A484865B8861730D9035E7
{
// System.Int32 UnityEngine.UIElements.RenderHints::value__
int32_t ___value___2;
};
// System.RuntimeTypeHandle
struct RuntimeTypeHandle_t332A452B8B6179E4469B69525D0FE82A88030F7B
{
// System.IntPtr System.RuntimeTypeHandle::value
intptr_t ___value_0;
};
// UnityEngine.UIElements.Scale
struct Scale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7
{
// UnityEngine.Vector3 UnityEngine.UIElements.Scale::m_Scale
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___m_Scale_0;
// System.Boolean UnityEngine.UIElements.Scale::m_IsNone
bool ___m_IsNone_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.Scale
struct Scale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7_marshaled_pinvoke
{
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___m_Scale_0;
int32_t ___m_IsNone_1;
};
// Native definition for COM marshalling of UnityEngine.UIElements.Scale
struct Scale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7_marshaled_com
{
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___m_Scale_0;
int32_t ___m_IsNone_1;
};
// UnityEngine.UIElements.StyleKeyword
struct StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705
{
// System.Int32 UnityEngine.UIElements.StyleKeyword::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.StyleSheets.StylePropertyId
struct StylePropertyId_tA3B8A5213F5BA43F9C5443B27B165D744713BE69
{
// System.Int32 UnityEngine.UIElements.StyleSheets.StylePropertyId::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.StyleSelectorRelationship
struct StyleSelectorRelationship_tAABCDC80BF87B347ACE1C64B32C85B05268A7F9E
{
// System.Int32 UnityEngine.UIElements.StyleSelectorRelationship::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.StyleSelectorType
struct StyleSelectorType_t425962DE6D175F785FA2B5554D793B71D39430A3
{
// System.Int32 UnityEngine.UIElements.StyleSelectorType::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.StyleSheets.Syntax.StyleSyntaxTokenType
struct StyleSyntaxTokenType_tFB5906557ADB62467788C6C7F28D771374EC4834
{
// System.Int32 UnityEngine.UIElements.StyleSheets.Syntax.StyleSyntaxTokenType::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.StyleValueType
struct StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE
{
// System.Int32 UnityEngine.UIElements.StyleValueType::value__
int32_t ___value___2;
};
// System.Threading.Tasks.Task
struct Task_t751C4CC3ECD055BABA8A0B6A5DFBB4283DCA8572 : public RuntimeObject
{
// System.Int32 modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.Tasks.Task::m_taskId
int32_t ___m_taskId_1;
// System.Delegate System.Threading.Tasks.Task::m_action
Delegate_t* ___m_action_2;
// System.Object System.Threading.Tasks.Task::m_stateObject
RuntimeObject* ___m_stateObject_3;
// System.Threading.Tasks.TaskScheduler System.Threading.Tasks.Task::m_taskScheduler
TaskScheduler_t3F0550EBEF7C41F74EC8C08FF4BED0D8CE66006E* ___m_taskScheduler_4;
// System.Threading.Tasks.Task System.Threading.Tasks.Task::m_parent
Task_t751C4CC3ECD055BABA8A0B6A5DFBB4283DCA8572* ___m_parent_5;
// System.Int32 modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.Tasks.Task::m_stateFlags
int32_t ___m_stateFlags_6;
// System.Object modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.Tasks.Task::m_continuationObject
RuntimeObject* ___m_continuationObject_7;
// System.Threading.Tasks.Task/ContingentProperties modreq(System.Runtime.CompilerServices.IsVolatile) System.Threading.Tasks.Task::m_contingentProperties
ContingentProperties_t3FA59480914505CEA917B1002EC675F29D0CB540* ___m_contingentProperties_10;
};
struct Task_t751C4CC3ECD055BABA8A0B6A5DFBB4283DCA8572_StaticFields
{
// System.Int32 System.Threading.Tasks.Task::s_taskIdCounter
int32_t ___s_taskIdCounter_0;
// System.Object System.Threading.Tasks.Task::s_taskCompletionSentinel
RuntimeObject* ___s_taskCompletionSentinel_8;
// System.Boolean System.Threading.Tasks.Task::s_asyncDebuggingEnabled
bool ___s_asyncDebuggingEnabled_9;
// System.Action`1<System.Object> System.Threading.Tasks.Task::s_taskCancelCallback
Action_1_t6F9EB113EB3F16226AEF811A2744F4111C116C87* ___s_taskCancelCallback_11;
// System.Func`1<System.Threading.Tasks.Task/ContingentProperties> System.Threading.Tasks.Task::s_createContingentProperties
Func_1_tD59A12717D79BFB403BF973694B1BE5B85474BD1* ___s_createContingentProperties_14;
// System.Threading.Tasks.TaskFactory System.Threading.Tasks.Task::<Factory>k__BackingField
TaskFactory_tF781BD37BE23917412AD83424D1497C7C1509DF0* ___U3CFactoryU3Ek__BackingField_15;
// System.Threading.Tasks.Task System.Threading.Tasks.Task::<CompletedTask>k__BackingField
Task_t751C4CC3ECD055BABA8A0B6A5DFBB4283DCA8572* ___U3CCompletedTaskU3Ek__BackingField_16;
// System.Predicate`1<System.Threading.Tasks.Task> System.Threading.Tasks.Task::s_IsExceptionObservedByParentPredicate
Predicate_1_t7F48518B008C1472339EEEBABA3DE203FE1F26ED* ___s_IsExceptionObservedByParentPredicate_17;
// System.Threading.ContextCallback System.Threading.Tasks.Task::s_ecCallback
ContextCallback_tE8AFBDBFCC040FDA8DA8C1EEFE9BD66B16BDA007* ___s_ecCallback_18;
// System.Predicate`1<System.Object> System.Threading.Tasks.Task::s_IsTaskContinuationNullPredicate
Predicate_1_t8342C85FF4E41CD1F7024AC0CDC3E5312A32CB12* ___s_IsTaskContinuationNullPredicate_19;
// System.Collections.Generic.Dictionary`2<System.Int32,System.Threading.Tasks.Task> System.Threading.Tasks.Task::s_currentActiveTasks
Dictionary_2_t403063CE4960B4F46C688912237C6A27E550FF55* ___s_currentActiveTasks_20;
// System.Object System.Threading.Tasks.Task::s_activeTasksLock
RuntimeObject* ___s_activeTasksLock_21;
};
struct Task_t751C4CC3ECD055BABA8A0B6A5DFBB4283DCA8572_ThreadStaticFields
{
// System.Threading.Tasks.Task System.Threading.Tasks.Task::t_currentTask
Task_t751C4CC3ECD055BABA8A0B6A5DFBB4283DCA8572* ___t_currentTask_12;
// System.Threading.Tasks.StackGuard System.Threading.Tasks.Task::t_stackGuard
StackGuard_tACE063A1B7374BDF4AD472DE4585D05AD8745352* ___t_stackGuard_13;
};
// System.Threading.Tasks.TaskCreationOptions
struct TaskCreationOptions_tB15CB42D61B8958640A7C702A79097B56D5C7ABA
{
// System.Int32 System.Threading.Tasks.TaskCreationOptions::value__
int32_t ___value___2;
};
// UnityEngine.TextCore.Text.TextElementType
struct TextElementType_tEBCF09EEF888E8B1F62D3DD66AF21890D12545EB
{
// System.Byte UnityEngine.TextCore.Text.TextElementType::value__
uint8_t ___value___2;
};
// UnityEngine.TextCore.Text.TextGeneratorUtilities
struct TextGeneratorUtilities_tAD0F329B1A5C7CC27CF63086C11FE092B43FED53 : public RuntimeObject
{
};
struct TextGeneratorUtilities_tAD0F329B1A5C7CC27CF63086C11FE092B43FED53_StaticFields
{
// UnityEngine.Vector2 UnityEngine.TextCore.Text.TextGeneratorUtilities::largePositiveVector2
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___largePositiveVector2_0;
// UnityEngine.Vector2 UnityEngine.TextCore.Text.TextGeneratorUtilities::largeNegativeVector2
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___largeNegativeVector2_1;
};
// UnityEngine.TextCore.Text.TextInfo
struct TextInfo_t27E58E62A7552C66D38C175AF9D22622365F5D09 : public RuntimeObject
{
// System.Int32 UnityEngine.TextCore.Text.TextInfo::characterCount
int32_t ___characterCount_2;
// System.Int32 UnityEngine.TextCore.Text.TextInfo::spriteCount
int32_t ___spriteCount_3;
// System.Int32 UnityEngine.TextCore.Text.TextInfo::spaceCount
int32_t ___spaceCount_4;
// System.Int32 UnityEngine.TextCore.Text.TextInfo::wordCount
int32_t ___wordCount_5;
// System.Int32 UnityEngine.TextCore.Text.TextInfo::linkCount
int32_t ___linkCount_6;
// System.Int32 UnityEngine.TextCore.Text.TextInfo::lineCount
int32_t ___lineCount_7;
// System.Int32 UnityEngine.TextCore.Text.TextInfo::pageCount
int32_t ___pageCount_8;
// System.Int32 UnityEngine.TextCore.Text.TextInfo::materialCount
int32_t ___materialCount_9;
// UnityEngine.TextCore.Text.TextElementInfo[] UnityEngine.TextCore.Text.TextInfo::textElementInfo
TextElementInfoU5BU5D_tEC28C9B72883EE21AA798913497C69E179A15C4E* ___textElementInfo_10;
// UnityEngine.TextCore.Text.WordInfo[] UnityEngine.TextCore.Text.TextInfo::wordInfo
WordInfoU5BU5D_tAD74C9720883D7BB229A20FFAE9EFD2CF9963F7B* ___wordInfo_11;
// UnityEngine.TextCore.Text.LinkInfo[] UnityEngine.TextCore.Text.TextInfo::linkInfo
LinkInfoU5BU5D_tB7EB23E47AF29CCBEC884F9D0DB95BC97F62AE51* ___linkInfo_12;
// UnityEngine.TextCore.Text.LineInfo[] UnityEngine.TextCore.Text.TextInfo::lineInfo
LineInfoU5BU5D_t37598F2175B291797270D1161DC29B6296FB169D* ___lineInfo_13;
// UnityEngine.TextCore.Text.PageInfo[] UnityEngine.TextCore.Text.TextInfo::pageInfo
PageInfoU5BU5D_tFEA2CF88695491CFC2F2A2EF6BDCC56E52B0A6D4* ___pageInfo_14;
// UnityEngine.TextCore.Text.MeshInfo[] UnityEngine.TextCore.Text.TextInfo::meshInfo
MeshInfoU5BU5D_t3DF8B75BF4A213334EED197AD25E432212894AC6* ___meshInfo_15;
// System.Boolean UnityEngine.TextCore.Text.TextInfo::isDirty
bool ___isDirty_16;
};
struct TextInfo_t27E58E62A7552C66D38C175AF9D22622365F5D09_StaticFields
{
// UnityEngine.Vector2 UnityEngine.TextCore.Text.TextInfo::s_InfinityVectorPositive
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___s_InfinityVectorPositive_0;
// UnityEngine.Vector2 UnityEngine.TextCore.Text.TextInfo::s_InfinityVectorNegative
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___s_InfinityVectorNegative_1;
};
// UnityEngine.UIElements.TextShadow
struct TextShadow_t6BADF37AB90ABCB63859A225B58AC5A580950A05
{
// UnityEngine.Vector2 UnityEngine.UIElements.TextShadow::offset
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___offset_0;
// System.Single UnityEngine.UIElements.TextShadow::blurRadius
float ___blurRadius_1;
// UnityEngine.Color UnityEngine.UIElements.TextShadow::color
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___color_2;
};
// UnityEngine.TextCore.Text.TextVertex
struct TextVertex_tF030A16DC67EAF3F6C9C9C0564D4B88758B173A9
{
// UnityEngine.Vector3 UnityEngine.TextCore.Text.TextVertex::position
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___position_0;
// UnityEngine.Vector2 UnityEngine.TextCore.Text.TextVertex::uv
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___uv_1;
// UnityEngine.Vector2 UnityEngine.TextCore.Text.TextVertex::uv2
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___uv2_2;
// UnityEngine.Vector2 UnityEngine.TextCore.Text.TextVertex::uv4
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___uv4_3;
// UnityEngine.Color32 UnityEngine.TextCore.Text.TextVertex::color
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___color_4;
};
// UnityEngine.UIElements.TextVertex
struct TextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3
{
// UnityEngine.Vector3 UnityEngine.UIElements.TextVertex::position
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___position_0;
// UnityEngine.Color32 UnityEngine.UIElements.TextVertex::color
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___color_1;
// UnityEngine.Vector2 UnityEngine.UIElements.TextVertex::uv0
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___uv0_2;
};
// UnityEngine.UIElements.TimeUnit
struct TimeUnit_t56A79CDB672E98A4EE28002BD23B6D5E0BAA2649
{
// System.Int32 UnityEngine.UIElements.TimeUnit::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.UIR.Transform3x4
struct Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F
{
// UnityEngine.Vector4 UnityEngine.UIElements.UIR.Transform3x4::v0
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___v0_0;
// UnityEngine.Vector4 UnityEngine.UIElements.UIR.Transform3x4::v1
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___v1_1;
// UnityEngine.Vector4 UnityEngine.UIElements.UIR.Transform3x4::v2
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___v2_2;
};
// UnityEngine.UICharInfo
struct UICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD
{
// UnityEngine.Vector2 UnityEngine.UICharInfo::cursorPos
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___cursorPos_0;
// System.Single UnityEngine.UICharInfo::charWidth
float ___charWidth_1;
};
// UnityEngine.UIVertex
struct UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207
{
// UnityEngine.Vector3 UnityEngine.UIVertex::position
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___position_0;
// UnityEngine.Vector3 UnityEngine.UIVertex::normal
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___normal_1;
// UnityEngine.Vector4 UnityEngine.UIVertex::tangent
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___tangent_2;
// UnityEngine.Color32 UnityEngine.UIVertex::color
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___color_3;
// UnityEngine.Vector4 UnityEngine.UIVertex::uv0
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___uv0_4;
// UnityEngine.Vector4 UnityEngine.UIVertex::uv1
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___uv1_5;
// UnityEngine.Vector4 UnityEngine.UIVertex::uv2
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___uv2_6;
// UnityEngine.Vector4 UnityEngine.UIVertex::uv3
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___uv3_7;
};
struct UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207_StaticFields
{
// UnityEngine.Color32 UnityEngine.UIVertex::s_DefaultColor
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___s_DefaultColor_8;
// UnityEngine.Vector4 UnityEngine.UIVertex::s_DefaultTangent
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___s_DefaultTangent_9;
// UnityEngine.UIVertex UnityEngine.UIVertex::simpleVert
UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207 ___simpleVert_10;
};
// UnityEngine.UIElements.UQueryExtensions
struct UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426 : public RuntimeObject
{
};
struct UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_StaticFields
{
// UnityEngine.UIElements.UQueryState`1<UnityEngine.UIElements.VisualElement> UnityEngine.UIElements.UQueryExtensions::SingleElementEmptyQuery
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA ___SingleElementEmptyQuery_0;
// UnityEngine.UIElements.UQueryState`1<UnityEngine.UIElements.VisualElement> UnityEngine.UIElements.UQueryExtensions::SingleElementNameQuery
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA ___SingleElementNameQuery_1;
// UnityEngine.UIElements.UQueryState`1<UnityEngine.UIElements.VisualElement> UnityEngine.UIElements.UQueryExtensions::SingleElementClassQuery
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA ___SingleElementClassQuery_2;
// UnityEngine.UIElements.UQueryState`1<UnityEngine.UIElements.VisualElement> UnityEngine.UIElements.UQueryExtensions::SingleElementNameAndClassQuery
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA ___SingleElementNameAndClassQuery_3;
// UnityEngine.UIElements.UQueryState`1<UnityEngine.UIElements.VisualElement> UnityEngine.UIElements.UQueryExtensions::SingleElementTypeQuery
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA ___SingleElementTypeQuery_4;
// UnityEngine.UIElements.UQueryState`1<UnityEngine.UIElements.VisualElement> UnityEngine.UIElements.UQueryExtensions::SingleElementTypeAndNameQuery
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA ___SingleElementTypeAndNameQuery_5;
// UnityEngine.UIElements.UQueryState`1<UnityEngine.UIElements.VisualElement> UnityEngine.UIElements.UQueryExtensions::SingleElementTypeAndClassQuery
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA ___SingleElementTypeAndClassQuery_6;
// UnityEngine.UIElements.UQueryState`1<UnityEngine.UIElements.VisualElement> UnityEngine.UIElements.UQueryExtensions::SingleElementTypeAndNameAndClassQuery
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA ___SingleElementTypeAndNameAndClassQuery_7;
};
// UnityEngine.UIElements.Vertex
struct Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7
{
// UnityEngine.Vector3 UnityEngine.UIElements.Vertex::position
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___position_1;
// UnityEngine.Color32 UnityEngine.UIElements.Vertex::tint
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___tint_2;
// UnityEngine.Vector2 UnityEngine.UIElements.Vertex::uv
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 ___uv_3;
// UnityEngine.Color32 UnityEngine.UIElements.Vertex::xformClipPages
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___xformClipPages_4;
// UnityEngine.Color32 UnityEngine.UIElements.Vertex::ids
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___ids_5;
// UnityEngine.Color32 UnityEngine.UIElements.Vertex::flags
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___flags_6;
// UnityEngine.Color32 UnityEngine.UIElements.Vertex::opacityColorPages
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___opacityColorPages_7;
// UnityEngine.Vector4 UnityEngine.UIElements.Vertex::circle
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___circle_8;
// System.Single UnityEngine.UIElements.Vertex::textureId
float ___textureId_9;
};
struct Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7_StaticFields
{
// System.Single UnityEngine.UIElements.Vertex::nearZ
float ___nearZ_0;
};
// UnityEngine.UIElements.UIR.VertexFlags
struct VertexFlags_tDC60142536F477FF72F8D0E14C41679078949D3D
{
// System.Int32 UnityEngine.UIElements.UIR.VertexFlags::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.VisualElementFlags
struct VisualElementFlags_t4D1066E11400967A1A2DA7331391ACDC4AA14409
{
// System.Int32 UnityEngine.UIElements.VisualElementFlags::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.VisualTreeUpdatePhase
struct VisualTreeUpdatePhase_t1EF45877A1796DC3991B9FF3A6AD762BE02DF67D
{
// System.Int32 UnityEngine.UIElements.VisualTreeUpdatePhase::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.Angle/Unit
struct Unit_t21DCD5C095F7DC1A0B9A47CAF8CAD3E7776CD3DB
{
// System.Int32 UnityEngine.UIElements.Angle/Unit::value__
int32_t ___value___2;
};
// UnityEngine.Camera/RenderRequestMode
struct RenderRequestMode_t660E12F8EBA39A0449633A31AA8DEFC97D366ED0
{
// System.Int32 UnityEngine.Camera/RenderRequestMode::value__
int32_t ___value___2;
};
// UnityEngine.Camera/RenderRequestOutputSpace
struct RenderRequestOutputSpace_tF55D7C0ABB4514D5FBF1695B9E71644C2256D329
{
// System.Int32 UnityEngine.Camera/RenderRequestOutputSpace::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.StyleSheets.Dimension/Unit
struct Unit_tAE6456027618FB5F9E5CCB6E5C209250AC5695CC
{
// System.Int32 UnityEngine.UIElements.StyleSheets.Dimension/Unit::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.Length/Unit
struct Unit_t7A9C3ABB0618BEBFDC1813D07080CE0C145448ED
{
// System.Int32 UnityEngine.UIElements.Length/Unit::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.UIR.OpacityIdAccelerator/OpacityIdUpdateJob
struct OpacityIdUpdateJob_t44287EF1EDECBC73C16DD75791575F362A19A110
{
// Unity.Collections.NativeSlice`1<UnityEngine.UIElements.Vertex> UnityEngine.UIElements.UIR.OpacityIdAccelerator/OpacityIdUpdateJob::oldVerts
NativeSlice_1_t66375568C4FF313931F4D2F646D64FE6A406BAD2 ___oldVerts_0;
// Unity.Collections.NativeSlice`1<UnityEngine.UIElements.Vertex> UnityEngine.UIElements.UIR.OpacityIdAccelerator/OpacityIdUpdateJob::newVerts
NativeSlice_1_t66375568C4FF313931F4D2F646D64FE6A406BAD2 ___newVerts_1;
// UnityEngine.Color32 UnityEngine.UIElements.UIR.OpacityIdAccelerator/OpacityIdUpdateJob::opacityData
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___opacityData_2;
};
// UnityEngine.UIElements.UIR.RenderChain/RenderNodeData
struct RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE
{
// UnityEngine.Material UnityEngine.UIElements.UIR.RenderChain/RenderNodeData::standardMaterial
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___standardMaterial_0;
// UnityEngine.Material UnityEngine.UIElements.UIR.RenderChain/RenderNodeData::initialMaterial
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___initialMaterial_1;
// UnityEngine.MaterialPropertyBlock UnityEngine.UIElements.UIR.RenderChain/RenderNodeData::matPropBlock
MaterialPropertyBlock_t2308669579033A857EFE6E4831909F638B27411D* ___matPropBlock_2;
// UnityEngine.UIElements.UIR.RenderChainCommand UnityEngine.UIElements.UIR.RenderChain/RenderNodeData::firstCommand
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___firstCommand_3;
// UnityEngine.UIElements.UIR.UIRenderDevice UnityEngine.UIElements.UIR.RenderChain/RenderNodeData::device
UIRenderDevice_t59628CBA89B4617E832C2B270E1C1A3931D01302* ___device_4;
// UnityEngine.Texture UnityEngine.UIElements.UIR.RenderChain/RenderNodeData::vectorAtlas
Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700* ___vectorAtlas_5;
// UnityEngine.Texture UnityEngine.UIElements.UIR.RenderChain/RenderNodeData::shaderInfoAtlas
Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700* ___shaderInfoAtlas_6;
// System.Single UnityEngine.UIElements.UIR.RenderChain/RenderNodeData::dpiScale
float ___dpiScale_7;
// Unity.Collections.NativeSlice`1<UnityEngine.UIElements.UIR.Transform3x4> UnityEngine.UIElements.UIR.RenderChain/RenderNodeData::transformConstants
NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370 ___transformConstants_8;
// Unity.Collections.NativeSlice`1<UnityEngine.Vector4> UnityEngine.UIElements.UIR.RenderChain/RenderNodeData::clipRectConstants
NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F ___clipRectConstants_9;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.UIR.RenderChain/RenderNodeData
struct RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE_marshaled_pinvoke
{
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___standardMaterial_0;
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___initialMaterial_1;
MaterialPropertyBlock_t2308669579033A857EFE6E4831909F638B27411D* ___matPropBlock_2;
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___firstCommand_3;
UIRenderDevice_t59628CBA89B4617E832C2B270E1C1A3931D01302* ___device_4;
Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700* ___vectorAtlas_5;
Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700* ___shaderInfoAtlas_6;
float ___dpiScale_7;
NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370 ___transformConstants_8;
NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F ___clipRectConstants_9;
};
// Native definition for COM marshalling of UnityEngine.UIElements.UIR.RenderChain/RenderNodeData
struct RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE_marshaled_com
{
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___standardMaterial_0;
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___initialMaterial_1;
MaterialPropertyBlock_t2308669579033A857EFE6E4831909F638B27411D* ___matPropBlock_2;
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___firstCommand_3;
UIRenderDevice_t59628CBA89B4617E832C2B270E1C1A3931D01302* ___device_4;
Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700* ___vectorAtlas_5;
Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700* ___shaderInfoAtlas_6;
float ___dpiScale_7;
NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370 ___transformConstants_8;
NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F ___clipRectConstants_9;
};
// UnityEngine.UIElements.UIR.TextureBlitter/BlitInfo
struct BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357
{
// UnityEngine.Texture UnityEngine.UIElements.UIR.TextureBlitter/BlitInfo::src
Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700* ___src_0;
// UnityEngine.RectInt UnityEngine.UIElements.UIR.TextureBlitter/BlitInfo::srcRect
RectInt_t1744D10E1063135DA9D574F95205B98DAC600CB8 ___srcRect_1;
// UnityEngine.Vector2Int UnityEngine.UIElements.UIR.TextureBlitter/BlitInfo::dstPos
Vector2Int_t69B2886EBAB732D9B880565E18E7568F3DE0CE6A ___dstPos_2;
// System.Int32 UnityEngine.UIElements.UIR.TextureBlitter/BlitInfo::border
int32_t ___border_3;
// UnityEngine.Color UnityEngine.UIElements.UIR.TextureBlitter/BlitInfo::tint
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___tint_4;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.UIR.TextureBlitter/BlitInfo
struct BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357_marshaled_pinvoke
{
Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700* ___src_0;
RectInt_t1744D10E1063135DA9D574F95205B98DAC600CB8 ___srcRect_1;
Vector2Int_t69B2886EBAB732D9B880565E18E7568F3DE0CE6A ___dstPos_2;
int32_t ___border_3;
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___tint_4;
};
// Native definition for COM marshalling of UnityEngine.UIElements.UIR.TextureBlitter/BlitInfo
struct BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357_marshaled_com
{
Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700* ___src_0;
RectInt_t1744D10E1063135DA9D574F95205B98DAC600CB8 ___srcRect_1;
Vector2Int_t69B2886EBAB732D9B880565E18E7568F3DE0CE6A ___dstPos_2;
int32_t ___border_3;
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___tint_4;
};
// UnityEngine.Timeline.TimelineAsset/DurationMode
struct DurationMode_t6088BA687395F5BC722CE0542A183ABF5B8D0012
{
// System.Int32 UnityEngine.Timeline.TimelineAsset/DurationMode::value__
int32_t ___value___2;
};
// UnityEngine.Timeline.TimelineClip/BlendCurveMode
struct BlendCurveMode_t640C5D7BCAF4793D5F3E99C768868B0199A596F8
{
// System.Int32 UnityEngine.Timeline.TimelineClip/BlendCurveMode::value__
int32_t ___value___2;
};
// UnityEngine.Timeline.TimelineClip/ClipExtrapolation
struct ClipExtrapolation_tB0EC49AFBEA6AE69BA93439FE120C01D4BF16ECB
{
// System.Int32 UnityEngine.Timeline.TimelineClip/ClipExtrapolation::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.UIR.UIRenderDevice/AllocToFree
struct AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8
{
// UnityEngine.UIElements.UIR.Alloc UnityEngine.UIElements.UIR.UIRenderDevice/AllocToFree::alloc
Alloc_t78312CFE58F38082281E80E297AE6176BD2BD8AE ___alloc_0;
// UnityEngine.UIElements.UIR.Page UnityEngine.UIElements.UIR.UIRenderDevice/AllocToFree::page
Page_tB4EA8095DF85BAF22AB8FCA71400121E721B57C9* ___page_1;
// System.Boolean UnityEngine.UIElements.UIR.UIRenderDevice/AllocToFree::vertices
bool ___vertices_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.UIR.UIRenderDevice/AllocToFree
struct AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8_marshaled_pinvoke
{
Alloc_t78312CFE58F38082281E80E297AE6176BD2BD8AE_marshaled_pinvoke ___alloc_0;
Page_tB4EA8095DF85BAF22AB8FCA71400121E721B57C9* ___page_1;
int32_t ___vertices_2;
};
// Native definition for COM marshalling of UnityEngine.UIElements.UIR.UIRenderDevice/AllocToFree
struct AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8_marshaled_com
{
Alloc_t78312CFE58F38082281E80E297AE6176BD2BD8AE_marshaled_com ___alloc_0;
Page_tB4EA8095DF85BAF22AB8FCA71400121E721B57C9* ___page_1;
int32_t ___vertices_2;
};
// UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate
struct AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512
{
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate::id
uint32_t ___id_0;
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate::allocTime
uint32_t ___allocTime_1;
// UnityEngine.UIElements.UIR.MeshHandle UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate::meshHandle
MeshHandle_tC1E9A7ECCFDAEFDE064B8D58B35B9CEE5A70A22E* ___meshHandle_2;
// UnityEngine.UIElements.UIR.Alloc UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate::permAllocVerts
Alloc_t78312CFE58F38082281E80E297AE6176BD2BD8AE ___permAllocVerts_3;
// UnityEngine.UIElements.UIR.Alloc UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate::permAllocIndices
Alloc_t78312CFE58F38082281E80E297AE6176BD2BD8AE ___permAllocIndices_4;
// UnityEngine.UIElements.UIR.Page UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate::permPage
Page_tB4EA8095DF85BAF22AB8FCA71400121E721B57C9* ___permPage_5;
// System.Boolean UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate::copyBackIndices
bool ___copyBackIndices_6;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate
struct AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512_marshaled_pinvoke
{
uint32_t ___id_0;
uint32_t ___allocTime_1;
MeshHandle_tC1E9A7ECCFDAEFDE064B8D58B35B9CEE5A70A22E* ___meshHandle_2;
Alloc_t78312CFE58F38082281E80E297AE6176BD2BD8AE_marshaled_pinvoke ___permAllocVerts_3;
Alloc_t78312CFE58F38082281E80E297AE6176BD2BD8AE_marshaled_pinvoke ___permAllocIndices_4;
Page_tB4EA8095DF85BAF22AB8FCA71400121E721B57C9* ___permPage_5;
int32_t ___copyBackIndices_6;
};
// Native definition for COM marshalling of UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate
struct AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512_marshaled_com
{
uint32_t ___id_0;
uint32_t ___allocTime_1;
MeshHandle_tC1E9A7ECCFDAEFDE064B8D58B35B9CEE5A70A22E* ___meshHandle_2;
Alloc_t78312CFE58F38082281E80E297AE6176BD2BD8AE_marshaled_com ___permAllocVerts_3;
Alloc_t78312CFE58F38082281E80E297AE6176BD2BD8AE_marshaled_com ___permAllocIndices_4;
Page_tB4EA8095DF85BAF22AB8FCA71400121E721B57C9* ___permPage_5;
int32_t ___copyBackIndices_6;
};
// UnityEngine.UIElements.UxmlAttributeDescription/Use
struct Use_tB32C57550EDF1A878B28A5BD90C918FFBD876670
{
// System.Int32 UnityEngine.UIElements.UxmlAttributeDescription/Use::value__
int32_t ___value___2;
};
// UnityEngine.UIElements.VisualElement/RenderTargetMode
struct RenderTargetMode_tAE75E29BB61A64BDE7646D5CBD353B64BCFA9F3A
{
// System.Int32 UnityEngine.UIElements.VisualElement/RenderTargetMode::value__
int32_t ___value___2;
};
// Cinemachine.TargetPositionCache/CacheCurve/Item
struct Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E
{
// UnityEngine.Vector3 Cinemachine.TargetPositionCache/CacheCurve/Item::Pos
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___Pos_0;
// UnityEngine.Quaternion Cinemachine.TargetPositionCache/CacheCurve/Item::Rot
Quaternion_tDA59F214EF07D7700B26E40E562F267AF7306974 ___Rot_1;
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.UIElements.UIR.GfxUpdateBufferRange>
struct AlignOfHelper_1_tD52B3A8A6905ECEC0B9C3B4D1828784E75D7FE88
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97 ___data_1;
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<Unity.Jobs.JobHandle>
struct AlignOfHelper_1_t34F1F7B1C240980BD9A2FE1C6A698A61423A9012
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08 ___data_1;
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.ModifiableContactPair>
struct AlignOfHelper_1_tD67A48EC63F59A3B0822645B10F6057BB0B1A6FB
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
ModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960 ___data_1;
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.Plane>
struct AlignOfHelper_1_t0A0F0444D297D1B268776F65B34B921CC7440328
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
Plane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C ___data_1;
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.UIElements.TextVertex>
struct AlignOfHelper_1_tD213CBFA28C6ED84BFB52825C5EDC3D52ADE5B18
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
TextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3 ___data_1;
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.UIElements.UIR.Transform3x4>
struct AlignOfHelper_1_t6867F50FD3853DD4CA4DD96AD88FE1A614E678D2
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F ___data_1;
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.UIElements.Vertex>
struct AlignOfHelper_1_t7A2C4AA30B2C9EC8415A83A5A9B280DBF11AB9AF
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7 ___data_1;
};
// Unity.Collections.NativeArray`1<UnityEngine.Color>
struct NativeArray_1_t6AE72D578EEA854475A487A2795F8C90FD258D8D
{
// System.Void* Unity.Collections.NativeArray`1::m_Buffer
void* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeArray`1::m_Length
int32_t ___m_Length_1;
// Unity.Collections.Allocator Unity.Collections.NativeArray`1::m_AllocatorLabel
int32_t ___m_AllocatorLabel_2;
};
// Unity.Collections.NativeArray`1<UnityEngine.Color32>
struct NativeArray_1_t0783F5E3C7AF6C600A6A20DA7A32D82CA836528D
{
// System.Void* Unity.Collections.NativeArray`1::m_Buffer
void* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeArray`1::m_Length
int32_t ___m_Length_1;
// Unity.Collections.Allocator Unity.Collections.NativeArray`1::m_AllocatorLabel
int32_t ___m_AllocatorLabel_2;
};
// Unity.Collections.NativeArray`1<System.UInt16>
struct NativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934
{
// System.Void* Unity.Collections.NativeArray`1::m_Buffer
void* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeArray`1::m_Length
int32_t ___m_Length_1;
// Unity.Collections.Allocator Unity.Collections.NativeArray`1::m_AllocatorLabel
int32_t ___m_AllocatorLabel_2;
};
// Unity.Collections.NativeArray`1<UnityEngine.UIElements.Vertex>
struct NativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81
{
// System.Void* Unity.Collections.NativeArray`1::m_Buffer
void* ___m_Buffer_0;
// System.Int32 Unity.Collections.NativeArray`1::m_Length
int32_t ___m_Length_1;
// Unity.Collections.Allocator Unity.Collections.NativeArray`1::m_AllocatorLabel
int32_t ___m_AllocatorLabel_2;
};
// System.Span`1<System.Char>
struct Span_1_tEDDF15FCF9EC6DEBA0F696BAACDDBAB9D92C252D
{
// System.ByReference`1<T> System.Span`1::_pointer
ByReference_1_t7BA5A6CA164F770BC688F21C5978D368716465F5 ____pointer_0;
// System.Int32 System.Span`1::_length
int32_t ____length_1;
};
// System.Threading.Tasks.Task`1<System.Boolean>
struct Task_1_t824317F4B958F7512E8F7300511752937A6C6043 : public Task_t751C4CC3ECD055BABA8A0B6A5DFBB4283DCA8572
{
// TResult System.Threading.Tasks.Task`1::m_result
bool ___m_result_22;
};
// System.Threading.Tasks.Task`1<System.Int32>
struct Task_1_t4C228DE57804012969575431CFF12D57C875552D : public Task_t751C4CC3ECD055BABA8A0B6A5DFBB4283DCA8572
{
// TResult System.Threading.Tasks.Task`1::m_result
int32_t ___m_result_22;
};
// System.Threading.Tasks.Task`1<System.Object>
struct Task_1_t0C4CD3A5BB93A184420D73218644C56C70FDA7E2 : public Task_t751C4CC3ECD055BABA8A0B6A5DFBB4283DCA8572
{
// TResult System.Threading.Tasks.Task`1::m_result
RuntimeObject* ___m_result_22;
};
// UnityEngine.UIElements.Angle
struct Angle_t0229F612898D65B3CC646C40A32D93D8A33C1DFC
{
// System.Single UnityEngine.UIElements.Angle::m_Value
float ___m_Value_0;
// UnityEngine.UIElements.Angle/Unit UnityEngine.UIElements.Angle::m_Unit
int32_t ___m_Unit_1;
};
// UnityEngine.UIElements.UIR.BMPAlloc
struct BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30
{
// System.Int32 UnityEngine.UIElements.UIR.BMPAlloc::page
int32_t ___page_1;
// System.UInt16 UnityEngine.UIElements.UIR.BMPAlloc::pageLine
uint16_t ___pageLine_2;
// System.Byte UnityEngine.UIElements.UIR.BMPAlloc::bitIndex
uint8_t ___bitIndex_3;
// UnityEngine.UIElements.UIR.OwnedState UnityEngine.UIElements.UIR.BMPAlloc::ownedState
uint8_t ___ownedState_4;
};
struct BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30_StaticFields
{
// UnityEngine.UIElements.UIR.BMPAlloc UnityEngine.UIElements.UIR.BMPAlloc::Invalid
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___Invalid_0;
};
// UnityEngine.UIElements.BaseVisualElementPanel
struct BaseVisualElementPanel_tE3811F3D1474B72CB6CD5BCEECFF5B5CBEC1E303 : public RuntimeObject
{
// System.Action`1<UnityEngine.UIElements.BaseVisualElementPanel> UnityEngine.UIElements.BaseVisualElementPanel::panelDisposed
Action_1_tF0C1AFCCE9CE63382F43540DC0DA04A8939A8A53* ___panelDisposed_0;
// System.Single UnityEngine.UIElements.BaseVisualElementPanel::m_Scale
float ___m_Scale_1;
// UnityEngine.Yoga.YogaConfig UnityEngine.UIElements.BaseVisualElementPanel::yogaConfig
YogaConfig_tE8B56F99460C291C1F7F46DBD8BAC9F0B653A345* ___yogaConfig_2;
// System.Single UnityEngine.UIElements.BaseVisualElementPanel::m_PixelsPerPoint
float ___m_PixelsPerPoint_3;
// UnityEngine.UIElements.PanelClearSettings UnityEngine.UIElements.BaseVisualElementPanel::<clearSettings>k__BackingField
PanelClearSettings_tA3D8EE9A4864781CE3E5FED5225C6FB37ED66EE7 ___U3CclearSettingsU3Ek__BackingField_4;
// System.Boolean UnityEngine.UIElements.BaseVisualElementPanel::<duringLayoutPhase>k__BackingField
bool ___U3CduringLayoutPhaseU3Ek__BackingField_5;
// UnityEngine.UIElements.RepaintData UnityEngine.UIElements.BaseVisualElementPanel::<repaintData>k__BackingField
RepaintData_t90534752135661579EC254884F550545D001B5EA* ___U3CrepaintDataU3Ek__BackingField_6;
// UnityEngine.UIElements.ICursorManager UnityEngine.UIElements.BaseVisualElementPanel::<cursorManager>k__BackingField
RuntimeObject* ___U3CcursorManagerU3Ek__BackingField_7;
// UnityEngine.UIElements.ContextualMenuManager UnityEngine.UIElements.BaseVisualElementPanel::<contextualMenuManager>k__BackingField
ContextualMenuManager_tEE3B1F33FFFD180705467CA625AEBA0F5D63154B* ___U3CcontextualMenuManagerU3Ek__BackingField_8;
// System.Boolean UnityEngine.UIElements.BaseVisualElementPanel::<disposed>k__BackingField
bool ___U3CdisposedU3Ek__BackingField_9;
// UnityEngine.UIElements.ElementUnderPointer UnityEngine.UIElements.BaseVisualElementPanel::m_TopElementUnderPointers
ElementUnderPointer_tB43AD64F79C6F06829D8B90318AF1A6BBE9C1904* ___m_TopElementUnderPointers_10;
// System.Action UnityEngine.UIElements.BaseVisualElementPanel::standardShaderChanged
Action_tD00B0A84D7945E50C2DFFC28EFEE6ED44ED2AD07* ___standardShaderChanged_11;
// System.Action UnityEngine.UIElements.BaseVisualElementPanel::standardWorldSpaceShaderChanged
Action_tD00B0A84D7945E50C2DFFC28EFEE6ED44ED2AD07* ___standardWorldSpaceShaderChanged_12;
// System.Action UnityEngine.UIElements.BaseVisualElementPanel::atlasChanged
Action_tD00B0A84D7945E50C2DFFC28EFEE6ED44ED2AD07* ___atlasChanged_13;
// System.Action`1<UnityEngine.Material> UnityEngine.UIElements.BaseVisualElementPanel::updateMaterial
Action_1_t996DFD52B4BDA6CBE8058C13167C4D2B8C612CAA* ___updateMaterial_14;
// UnityEngine.UIElements.HierarchyEvent UnityEngine.UIElements.BaseVisualElementPanel::hierarchyChanged
HierarchyEvent_tB23E4347BC47656A014CA104A5B1DDC172A2A705* ___hierarchyChanged_15;
// System.Action`1<UnityEngine.UIElements.IPanel> UnityEngine.UIElements.BaseVisualElementPanel::beforeUpdate
Action_1_tE55F8AC1EEC45D0C976E56B2950D65EC814C06E6* ___beforeUpdate_16;
};
// UnityEngine.UIElements.ComputedTransitionProperty
struct ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1
{
// UnityEngine.UIElements.StyleSheets.StylePropertyId UnityEngine.UIElements.ComputedTransitionProperty::id
int32_t ___id_0;
// System.Int32 UnityEngine.UIElements.ComputedTransitionProperty::durationMs
int32_t ___durationMs_1;
// System.Int32 UnityEngine.UIElements.ComputedTransitionProperty::delayMs
int32_t ___delayMs_2;
// System.Func`2<System.Single,System.Single> UnityEngine.UIElements.ComputedTransitionProperty::easingCurve
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___easingCurve_3;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.ComputedTransitionProperty
struct ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1_marshaled_pinvoke
{
int32_t ___id_0;
int32_t ___durationMs_1;
int32_t ___delayMs_2;
Il2CppMethodPointer ___easingCurve_3;
};
// Native definition for COM marshalling of UnityEngine.UIElements.ComputedTransitionProperty
struct ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1_marshaled_com
{
int32_t ___id_0;
int32_t ___durationMs_1;
int32_t ___delayMs_2;
Il2CppMethodPointer ___easingCurve_3;
};
// UnityEngine.UIElements.StyleSheets.Dimension
struct Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8
{
// UnityEngine.UIElements.StyleSheets.Dimension/Unit UnityEngine.UIElements.StyleSheets.Dimension::unit
int32_t ___unit_0;
// System.Single UnityEngine.UIElements.StyleSheets.Dimension::value
float ___value_1;
};
// UnityEngine.UIElements.EasingFunction
struct EasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4
{
// UnityEngine.UIElements.EasingMode UnityEngine.UIElements.EasingFunction::m_Mode
int32_t ___m_Mode_0;
};
// UnityEngine.TextCore.LowLevel.GlyphPairAdjustmentRecord
struct GlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E
{
// UnityEngine.TextCore.LowLevel.GlyphAdjustmentRecord UnityEngine.TextCore.LowLevel.GlyphPairAdjustmentRecord::m_FirstAdjustmentRecord
GlyphAdjustmentRecord_tC7A1B2E0AC7C4ED9CDB8E95E48790A46B6F315F7 ___m_FirstAdjustmentRecord_0;
// UnityEngine.TextCore.LowLevel.GlyphAdjustmentRecord UnityEngine.TextCore.LowLevel.GlyphPairAdjustmentRecord::m_SecondAdjustmentRecord
GlyphAdjustmentRecord_tC7A1B2E0AC7C4ED9CDB8E95E48790A46B6F315F7 ___m_SecondAdjustmentRecord_1;
// UnityEngine.TextCore.LowLevel.FontFeatureLookupFlags UnityEngine.TextCore.LowLevel.GlyphPairAdjustmentRecord::m_FeatureLookupFlags
int32_t ___m_FeatureLookupFlags_2;
};
// UnityEngine.UIElements.Length
struct Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256
{
// System.Single UnityEngine.UIElements.Length::m_Value
float ___m_Value_1;
// UnityEngine.UIElements.Length/Unit UnityEngine.UIElements.Length::m_Unit
int32_t ___m_Unit_2;
};
// UnityEngine.Experimental.GlobalIllumination.LightDataGI
struct LightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21
{
// System.Int32 UnityEngine.Experimental.GlobalIllumination.LightDataGI::instanceID
int32_t ___instanceID_0;
// System.Int32 UnityEngine.Experimental.GlobalIllumination.LightDataGI::cookieID
int32_t ___cookieID_1;
// System.Single UnityEngine.Experimental.GlobalIllumination.LightDataGI::cookieScale
float ___cookieScale_2;
// UnityEngine.Experimental.GlobalIllumination.LinearColor UnityEngine.Experimental.GlobalIllumination.LightDataGI::color
LinearColor_t60964F15C567D7FE5442C29298DCF20ABD8816C7 ___color_3;
// UnityEngine.Experimental.GlobalIllumination.LinearColor UnityEngine.Experimental.GlobalIllumination.LightDataGI::indirectColor
LinearColor_t60964F15C567D7FE5442C29298DCF20ABD8816C7 ___indirectColor_4;
// UnityEngine.Quaternion UnityEngine.Experimental.GlobalIllumination.LightDataGI::orientation
Quaternion_tDA59F214EF07D7700B26E40E562F267AF7306974 ___orientation_5;
// UnityEngine.Vector3 UnityEngine.Experimental.GlobalIllumination.LightDataGI::position
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___position_6;
// System.Single UnityEngine.Experimental.GlobalIllumination.LightDataGI::range
float ___range_7;
// System.Single UnityEngine.Experimental.GlobalIllumination.LightDataGI::coneAngle
float ___coneAngle_8;
// System.Single UnityEngine.Experimental.GlobalIllumination.LightDataGI::innerConeAngle
float ___innerConeAngle_9;
// System.Single UnityEngine.Experimental.GlobalIllumination.LightDataGI::shape0
float ___shape0_10;
// System.Single UnityEngine.Experimental.GlobalIllumination.LightDataGI::shape1
float ___shape1_11;
// UnityEngine.Experimental.GlobalIllumination.LightType UnityEngine.Experimental.GlobalIllumination.LightDataGI::type
uint8_t ___type_12;
// UnityEngine.Experimental.GlobalIllumination.LightMode UnityEngine.Experimental.GlobalIllumination.LightDataGI::mode
uint8_t ___mode_13;
// System.Byte UnityEngine.Experimental.GlobalIllumination.LightDataGI::shadow
uint8_t ___shadow_14;
// UnityEngine.Experimental.GlobalIllumination.FalloffType UnityEngine.Experimental.GlobalIllumination.LightDataGI::falloff
uint8_t ___falloff_15;
};
// UnityEngine.UIElements.ManipulatorActivationFilter
struct ManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81
{
// UnityEngine.UIElements.MouseButton UnityEngine.UIElements.ManipulatorActivationFilter::<button>k__BackingField
int32_t ___U3CbuttonU3Ek__BackingField_0;
// UnityEngine.EventModifiers UnityEngine.UIElements.ManipulatorActivationFilter::<modifiers>k__BackingField
int32_t ___U3CmodifiersU3Ek__BackingField_1;
// System.Int32 UnityEngine.UIElements.ManipulatorActivationFilter::<clickCount>k__BackingField
int32_t ___U3CclickCountU3Ek__BackingField_2;
};
// System.MulticastDelegate
struct MulticastDelegate_t : public Delegate_t
{
// System.Delegate[] System.MulticastDelegate::delegates
DelegateU5BU5D_tC5AB7E8F745616680F337909D3A8E6C722CDF771* ___delegates_13;
};
// Native definition for P/Invoke marshalling of System.MulticastDelegate
struct MulticastDelegate_t_marshaled_pinvoke : public Delegate_t_marshaled_pinvoke
{
Delegate_t_marshaled_pinvoke** ___delegates_13;
};
// Native definition for COM marshalling of System.MulticastDelegate
struct MulticastDelegate_t_marshaled_com : public Delegate_t_marshaled_com
{
Delegate_t_marshaled_com** ___delegates_13;
};
// UnityEngine.Playables.Playable
struct Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F
{
// UnityEngine.Playables.PlayableHandle UnityEngine.Playables.Playable::m_Handle
PlayableHandle_t5D6A01EF94382EFEDC047202F71DF882769654D4 ___m_Handle_0;
};
struct Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F_StaticFields
{
// UnityEngine.Playables.Playable UnityEngine.Playables.Playable::m_NullPlayable
Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F ___m_NullPlayable_1;
};
// UnityEngine.Playables.PlayableBinding
struct PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4
{
// System.String UnityEngine.Playables.PlayableBinding::m_StreamName
String_t* ___m_StreamName_0;
// UnityEngine.Object UnityEngine.Playables.PlayableBinding::m_SourceObject
Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C* ___m_SourceObject_1;
// System.Type UnityEngine.Playables.PlayableBinding::m_SourceBindingType
Type_t* ___m_SourceBindingType_2;
// UnityEngine.Playables.PlayableBinding/CreateOutputMethod UnityEngine.Playables.PlayableBinding::m_CreateOutputMethod
CreateOutputMethod_tD18AFE3B69E6DDD913D82D5FA1D5D909CEEC8509* ___m_CreateOutputMethod_3;
};
struct PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4_StaticFields
{
// UnityEngine.Playables.PlayableBinding[] UnityEngine.Playables.PlayableBinding::None
PlayableBindingU5BU5D_tC50C3F27A8E4246488F7A5998CAABAC4811A92CD* ___None_4;
// System.Double UnityEngine.Playables.PlayableBinding::DefaultDuration
double ___DefaultDuration_5;
};
// Native definition for P/Invoke marshalling of UnityEngine.Playables.PlayableBinding
struct PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4_marshaled_pinvoke
{
char* ___m_StreamName_0;
Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C_marshaled_pinvoke ___m_SourceObject_1;
Type_t* ___m_SourceBindingType_2;
Il2CppMethodPointer ___m_CreateOutputMethod_3;
};
// Native definition for COM marshalling of UnityEngine.Playables.PlayableBinding
struct PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4_marshaled_com
{
Il2CppChar* ___m_StreamName_0;
Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C_marshaled_com* ___m_SourceObject_1;
Type_t* ___m_SourceBindingType_2;
Il2CppMethodPointer ___m_CreateOutputMethod_3;
};
// UnityEngine.ScriptableObject
struct ScriptableObject_tB3BFDB921A1B1795B38A5417D3B97A89A140436A : public Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C
{
};
// Native definition for P/Invoke marshalling of UnityEngine.ScriptableObject
struct ScriptableObject_tB3BFDB921A1B1795B38A5417D3B97A89A140436A_marshaled_pinvoke : public Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C_marshaled_pinvoke
{
};
// Native definition for COM marshalling of UnityEngine.ScriptableObject
struct ScriptableObject_tB3BFDB921A1B1795B38A5417D3B97A89A140436A_marshaled_com : public Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C_marshaled_com
{
};
// UnityEngine.UIElements.StyleComplexSelector
struct StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD : public RuntimeObject
{
// UnityEngine.UIElements.Hashes UnityEngine.UIElements.StyleComplexSelector::ancestorHashes
Hashes_t2535089FD6C6F036205113292C62B0D6E286ABE6 ___ancestorHashes_0;
// System.Int32 UnityEngine.UIElements.StyleComplexSelector::m_Specificity
int32_t ___m_Specificity_1;
// UnityEngine.UIElements.StyleRule UnityEngine.UIElements.StyleComplexSelector::<rule>k__BackingField
StyleRule_t69F0C0989004F85BBD9C72BC7A73F79BFE61651E* ___U3CruleU3Ek__BackingField_2;
// System.Boolean UnityEngine.UIElements.StyleComplexSelector::m_isSimple
bool ___m_isSimple_3;
// UnityEngine.UIElements.StyleSelector[] UnityEngine.UIElements.StyleComplexSelector::m_Selectors
StyleSelectorU5BU5D_t11A633455FC601606B3DF3CEDDDAB1625B54708D* ___m_Selectors_4;
// System.Int32 UnityEngine.UIElements.StyleComplexSelector::ruleIndex
int32_t ___ruleIndex_5;
// UnityEngine.UIElements.StyleComplexSelector UnityEngine.UIElements.StyleComplexSelector::nextInTable
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* ___nextInTable_6;
// System.Int32 UnityEngine.UIElements.StyleComplexSelector::orderInStyleSheet
int32_t ___orderInStyleSheet_7;
};
struct StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD_StaticFields
{
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.UIElements.StyleComplexSelector/PseudoStateData> UnityEngine.UIElements.StyleComplexSelector::s_PseudoStates
Dictionary_2_t29D782BF5D0A26D11A04865B4306B86575506834* ___s_PseudoStates_8;
// System.Collections.Generic.List`1<UnityEngine.UIElements.StyleSelectorPart> UnityEngine.UIElements.StyleComplexSelector::m_HashList
List_1_t85FF16594D5F70EECC5855882558F8E26EF6BAFF* ___m_HashList_9;
};
// UnityEngine.UIElements.StylePropertyName
struct StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF
{
// UnityEngine.UIElements.StyleSheets.StylePropertyId UnityEngine.UIElements.StylePropertyName::<id>k__BackingField
int32_t ___U3CidU3Ek__BackingField_0;
// System.String UnityEngine.UIElements.StylePropertyName::<name>k__BackingField
String_t* ___U3CnameU3Ek__BackingField_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.StylePropertyName
struct StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF_marshaled_pinvoke
{
int32_t ___U3CidU3Ek__BackingField_0;
char* ___U3CnameU3Ek__BackingField_1;
};
// Native definition for COM marshalling of UnityEngine.UIElements.StylePropertyName
struct StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF_marshaled_com
{
int32_t ___U3CidU3Ek__BackingField_0;
Il2CppChar* ___U3CnameU3Ek__BackingField_1;
};
// UnityEngine.UIElements.StyleSelector
struct StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362 : public RuntimeObject
{
// UnityEngine.UIElements.StyleSelectorPart[] UnityEngine.UIElements.StyleSelector::m_Parts
StyleSelectorPartU5BU5D_tBA574FB3E75E94E52874FDB7B05B9048E8A5421B* ___m_Parts_0;
// UnityEngine.UIElements.StyleSelectorRelationship UnityEngine.UIElements.StyleSelector::m_PreviousRelationship
int32_t ___m_PreviousRelationship_1;
// System.Int32 UnityEngine.UIElements.StyleSelector::pseudoStateMask
int32_t ___pseudoStateMask_2;
// System.Int32 UnityEngine.UIElements.StyleSelector::negatedPseudoStateMask
int32_t ___negatedPseudoStateMask_3;
};
// UnityEngine.UIElements.StyleSelectorPart
struct StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470
{
// System.String UnityEngine.UIElements.StyleSelectorPart::m_Value
String_t* ___m_Value_0;
// UnityEngine.UIElements.StyleSelectorType UnityEngine.UIElements.StyleSelectorPart::m_Type
int32_t ___m_Type_1;
// System.Object UnityEngine.UIElements.StyleSelectorPart::tempData
RuntimeObject* ___tempData_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.StyleSelectorPart
struct StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470_marshaled_pinvoke
{
char* ___m_Value_0;
int32_t ___m_Type_1;
Il2CppIUnknown* ___tempData_2;
};
// Native definition for COM marshalling of UnityEngine.UIElements.StyleSelectorPart
struct StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470_marshaled_com
{
Il2CppChar* ___m_Value_0;
int32_t ___m_Type_1;
Il2CppIUnknown* ___tempData_2;
};
// UnityEngine.UIElements.StyleSheets.Syntax.StyleSyntaxToken
struct StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C
{
// UnityEngine.UIElements.StyleSheets.Syntax.StyleSyntaxTokenType UnityEngine.UIElements.StyleSheets.Syntax.StyleSyntaxToken::type
int32_t ___type_0;
// System.String UnityEngine.UIElements.StyleSheets.Syntax.StyleSyntaxToken::text
String_t* ___text_1;
// System.Int32 UnityEngine.UIElements.StyleSheets.Syntax.StyleSyntaxToken::number
int32_t ___number_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.StyleSheets.Syntax.StyleSyntaxToken
struct StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C_marshaled_pinvoke
{
int32_t ___type_0;
char* ___text_1;
int32_t ___number_2;
};
// Native definition for COM marshalling of UnityEngine.UIElements.StyleSheets.Syntax.StyleSyntaxToken
struct StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C_marshaled_com
{
int32_t ___type_0;
Il2CppChar* ___text_1;
int32_t ___number_2;
};
// UnityEngine.UIElements.StyleValueHandle
struct StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D
{
// UnityEngine.UIElements.StyleValueType UnityEngine.UIElements.StyleValueHandle::m_ValueType
int32_t ___m_ValueType_0;
// System.Int32 UnityEngine.UIElements.StyleValueHandle::valueIndex
int32_t ___valueIndex_1;
};
// UnityEngine.UIElements.StyleSheets.StyleValueManaged
struct StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4
{
// UnityEngine.UIElements.StyleSheets.StylePropertyId UnityEngine.UIElements.StyleSheets.StyleValueManaged::id
int32_t ___id_0;
// UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.StyleSheets.StyleValueManaged::keyword
int32_t ___keyword_1;
// System.Object UnityEngine.UIElements.StyleSheets.StyleValueManaged::value
RuntimeObject* ___value_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.StyleSheets.StyleValueManaged
struct StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4_marshaled_pinvoke
{
int32_t ___id_0;
int32_t ___keyword_1;
Il2CppIUnknown* ___value_2;
};
// Native definition for COM marshalling of UnityEngine.UIElements.StyleSheets.StyleValueManaged
struct StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4_marshaled_com
{
int32_t ___id_0;
int32_t ___keyword_1;
Il2CppIUnknown* ___value_2;
};
// System.SystemException
struct SystemException_tCC48D868298F4C0705279823E34B00F4FBDB7295 : public Exception_t
{
};
// UnityEngine.TextCore.Text.TextElementInfo
struct TextElementInfo_tDD7A12E319505510E0B350E342BD55F32AB5F976
{
// System.Char UnityEngine.TextCore.Text.TextElementInfo::character
Il2CppChar ___character_0;
// System.Int32 UnityEngine.TextCore.Text.TextElementInfo::index
int32_t ___index_1;
// UnityEngine.TextCore.Text.TextElementType UnityEngine.TextCore.Text.TextElementInfo::elementType
uint8_t ___elementType_2;
// UnityEngine.TextCore.Text.TextElement UnityEngine.TextCore.Text.TextElementInfo::textElement
TextElement_tCEF567A8810788262275B39DC39CBA6EBE7472DA* ___textElement_3;
// UnityEngine.TextCore.Text.FontAsset UnityEngine.TextCore.Text.TextElementInfo::fontAsset
FontAsset_t61A6446D934E582651044E33D250EA8D306AB958* ___fontAsset_4;
// UnityEngine.TextCore.Text.SpriteAsset UnityEngine.TextCore.Text.TextElementInfo::spriteAsset
SpriteAsset_t1D3CF1D9DC350A4690CB09DE228A8B59F2F02313* ___spriteAsset_5;
// System.Int32 UnityEngine.TextCore.Text.TextElementInfo::spriteIndex
int32_t ___spriteIndex_6;
// UnityEngine.Material UnityEngine.TextCore.Text.TextElementInfo::material
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___material_7;
// System.Int32 UnityEngine.TextCore.Text.TextElementInfo::materialReferenceIndex
int32_t ___materialReferenceIndex_8;
// System.Boolean UnityEngine.TextCore.Text.TextElementInfo::isUsingAlternateTypeface
bool ___isUsingAlternateTypeface_9;
// System.Single UnityEngine.TextCore.Text.TextElementInfo::pointSize
float ___pointSize_10;
// System.Int32 UnityEngine.TextCore.Text.TextElementInfo::lineNumber
int32_t ___lineNumber_11;
// System.Int32 UnityEngine.TextCore.Text.TextElementInfo::pageNumber
int32_t ___pageNumber_12;
// System.Int32 UnityEngine.TextCore.Text.TextElementInfo::vertexIndex
int32_t ___vertexIndex_13;
// UnityEngine.TextCore.Text.TextVertex UnityEngine.TextCore.Text.TextElementInfo::vertexTopLeft
TextVertex_tF030A16DC67EAF3F6C9C9C0564D4B88758B173A9 ___vertexTopLeft_14;
// UnityEngine.TextCore.Text.TextVertex UnityEngine.TextCore.Text.TextElementInfo::vertexBottomLeft
TextVertex_tF030A16DC67EAF3F6C9C9C0564D4B88758B173A9 ___vertexBottomLeft_15;
// UnityEngine.TextCore.Text.TextVertex UnityEngine.TextCore.Text.TextElementInfo::vertexTopRight
TextVertex_tF030A16DC67EAF3F6C9C9C0564D4B88758B173A9 ___vertexTopRight_16;
// UnityEngine.TextCore.Text.TextVertex UnityEngine.TextCore.Text.TextElementInfo::vertexBottomRight
TextVertex_tF030A16DC67EAF3F6C9C9C0564D4B88758B173A9 ___vertexBottomRight_17;
// UnityEngine.Vector3 UnityEngine.TextCore.Text.TextElementInfo::topLeft
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___topLeft_18;
// UnityEngine.Vector3 UnityEngine.TextCore.Text.TextElementInfo::bottomLeft
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___bottomLeft_19;
// UnityEngine.Vector3 UnityEngine.TextCore.Text.TextElementInfo::topRight
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___topRight_20;
// UnityEngine.Vector3 UnityEngine.TextCore.Text.TextElementInfo::bottomRight
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___bottomRight_21;
// System.Single UnityEngine.TextCore.Text.TextElementInfo::origin
float ___origin_22;
// System.Single UnityEngine.TextCore.Text.TextElementInfo::ascender
float ___ascender_23;
// System.Single UnityEngine.TextCore.Text.TextElementInfo::baseLine
float ___baseLine_24;
// System.Single UnityEngine.TextCore.Text.TextElementInfo::descender
float ___descender_25;
// System.Single UnityEngine.TextCore.Text.TextElementInfo::xAdvance
float ___xAdvance_26;
// System.Single UnityEngine.TextCore.Text.TextElementInfo::aspectRatio
float ___aspectRatio_27;
// System.Single UnityEngine.TextCore.Text.TextElementInfo::scale
float ___scale_28;
// UnityEngine.Color32 UnityEngine.TextCore.Text.TextElementInfo::color
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___color_29;
// UnityEngine.Color32 UnityEngine.TextCore.Text.TextElementInfo::underlineColor
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___underlineColor_30;
// UnityEngine.Color32 UnityEngine.TextCore.Text.TextElementInfo::strikethroughColor
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___strikethroughColor_31;
// UnityEngine.Color32 UnityEngine.TextCore.Text.TextElementInfo::highlightColor
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___highlightColor_32;
// UnityEngine.TextCore.Text.FontStyles UnityEngine.TextCore.Text.TextElementInfo::style
int32_t ___style_33;
// System.Boolean UnityEngine.TextCore.Text.TextElementInfo::isVisible
bool ___isVisible_34;
};
// Native definition for P/Invoke marshalling of UnityEngine.TextCore.Text.TextElementInfo
struct TextElementInfo_tDD7A12E319505510E0B350E342BD55F32AB5F976_marshaled_pinvoke
{
uint8_t ___character_0;
int32_t ___index_1;
uint8_t ___elementType_2;
TextElement_tCEF567A8810788262275B39DC39CBA6EBE7472DA* ___textElement_3;
FontAsset_t61A6446D934E582651044E33D250EA8D306AB958* ___fontAsset_4;
SpriteAsset_t1D3CF1D9DC350A4690CB09DE228A8B59F2F02313* ___spriteAsset_5;
int32_t ___spriteIndex_6;
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___material_7;
int32_t ___materialReferenceIndex_8;
int32_t ___isUsingAlternateTypeface_9;
float ___pointSize_10;
int32_t ___lineNumber_11;
int32_t ___pageNumber_12;
int32_t ___vertexIndex_13;
TextVertex_tF030A16DC67EAF3F6C9C9C0564D4B88758B173A9 ___vertexTopLeft_14;
TextVertex_tF030A16DC67EAF3F6C9C9C0564D4B88758B173A9 ___vertexBottomLeft_15;
TextVertex_tF030A16DC67EAF3F6C9C9C0564D4B88758B173A9 ___vertexTopRight_16;
TextVertex_tF030A16DC67EAF3F6C9C9C0564D4B88758B173A9 ___vertexBottomRight_17;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___topLeft_18;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___bottomLeft_19;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___topRight_20;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___bottomRight_21;
float ___origin_22;
float ___ascender_23;
float ___baseLine_24;
float ___descender_25;
float ___xAdvance_26;
float ___aspectRatio_27;
float ___scale_28;
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___color_29;
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___underlineColor_30;
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___strikethroughColor_31;
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___highlightColor_32;
int32_t ___style_33;
int32_t ___isVisible_34;
};
// Native definition for COM marshalling of UnityEngine.TextCore.Text.TextElementInfo
struct TextElementInfo_tDD7A12E319505510E0B350E342BD55F32AB5F976_marshaled_com
{
uint8_t ___character_0;
int32_t ___index_1;
uint8_t ___elementType_2;
TextElement_tCEF567A8810788262275B39DC39CBA6EBE7472DA* ___textElement_3;
FontAsset_t61A6446D934E582651044E33D250EA8D306AB958* ___fontAsset_4;
SpriteAsset_t1D3CF1D9DC350A4690CB09DE228A8B59F2F02313* ___spriteAsset_5;
int32_t ___spriteIndex_6;
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___material_7;
int32_t ___materialReferenceIndex_8;
int32_t ___isUsingAlternateTypeface_9;
float ___pointSize_10;
int32_t ___lineNumber_11;
int32_t ___pageNumber_12;
int32_t ___vertexIndex_13;
TextVertex_tF030A16DC67EAF3F6C9C9C0564D4B88758B173A9 ___vertexTopLeft_14;
TextVertex_tF030A16DC67EAF3F6C9C9C0564D4B88758B173A9 ___vertexBottomLeft_15;
TextVertex_tF030A16DC67EAF3F6C9C9C0564D4B88758B173A9 ___vertexTopRight_16;
TextVertex_tF030A16DC67EAF3F6C9C9C0564D4B88758B173A9 ___vertexBottomRight_17;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___topLeft_18;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___bottomLeft_19;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___topRight_20;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___bottomRight_21;
float ___origin_22;
float ___ascender_23;
float ___baseLine_24;
float ___descender_25;
float ___xAdvance_26;
float ___aspectRatio_27;
float ___scale_28;
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___color_29;
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___underlineColor_30;
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___strikethroughColor_31;
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___highlightColor_32;
int32_t ___style_33;
int32_t ___isVisible_34;
};
// UnityEngine.Texture
struct Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700 : public Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C
{
};
struct Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700_StaticFields
{
// System.Int32 UnityEngine.Texture::GenerateAllMips
int32_t ___GenerateAllMips_4;
};
// UnityEngine.UIElements.TimeValue
struct TimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E
{
// System.Single UnityEngine.UIElements.TimeValue::m_Value
float ___m_Value_0;
// UnityEngine.UIElements.TimeUnit UnityEngine.UIElements.TimeValue::m_Unit
int32_t ___m_Unit_1;
};
// UnityEngine.Timeline.TimelineClip
struct TimelineClip_t003008F08E56A75F3A47FD9ADE7C066988A3371D : public RuntimeObject
{
// System.Int32 UnityEngine.Timeline.TimelineClip::m_Version
int32_t ___m_Version_1;
// System.Double UnityEngine.Timeline.TimelineClip::m_Start
double ___m_Start_9;
// System.Double UnityEngine.Timeline.TimelineClip::m_ClipIn
double ___m_ClipIn_10;
// UnityEngine.Object UnityEngine.Timeline.TimelineClip::m_Asset
Object_tC12DECB6760A7F2CBF65D9DCF18D044C2D97152C* ___m_Asset_11;
// System.Double UnityEngine.Timeline.TimelineClip::m_Duration
double ___m_Duration_12;
// System.Double UnityEngine.Timeline.TimelineClip::m_TimeScale
double ___m_TimeScale_13;
// UnityEngine.Timeline.TrackAsset UnityEngine.Timeline.TimelineClip::m_ParentTrack
TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96* ___m_ParentTrack_14;
// System.Double UnityEngine.Timeline.TimelineClip::m_EaseInDuration
double ___m_EaseInDuration_15;
// System.Double UnityEngine.Timeline.TimelineClip::m_EaseOutDuration
double ___m_EaseOutDuration_16;
// System.Double UnityEngine.Timeline.TimelineClip::m_BlendInDuration
double ___m_BlendInDuration_17;
// System.Double UnityEngine.Timeline.TimelineClip::m_BlendOutDuration
double ___m_BlendOutDuration_18;
// UnityEngine.AnimationCurve UnityEngine.Timeline.TimelineClip::m_MixInCurve
AnimationCurve_tCBFFAAD05CEBB35EF8D8631BD99914BE1A6BB354* ___m_MixInCurve_19;
// UnityEngine.AnimationCurve UnityEngine.Timeline.TimelineClip::m_MixOutCurve
AnimationCurve_tCBFFAAD05CEBB35EF8D8631BD99914BE1A6BB354* ___m_MixOutCurve_20;
// UnityEngine.Timeline.TimelineClip/BlendCurveMode UnityEngine.Timeline.TimelineClip::m_BlendInCurveMode
int32_t ___m_BlendInCurveMode_21;
// UnityEngine.Timeline.TimelineClip/BlendCurveMode UnityEngine.Timeline.TimelineClip::m_BlendOutCurveMode
int32_t ___m_BlendOutCurveMode_22;
// System.Collections.Generic.List`1<System.String> UnityEngine.Timeline.TimelineClip::m_ExposedParameterNames
List_1_tF470A3BE5C1B5B68E1325EF3F109D172E60BD7CD* ___m_ExposedParameterNames_23;
// UnityEngine.AnimationClip UnityEngine.Timeline.TimelineClip::m_AnimationCurves
AnimationClip_t00BD2F131D308A4AD2C6B0BF66644FC25FECE712* ___m_AnimationCurves_24;
// System.Boolean UnityEngine.Timeline.TimelineClip::m_Recordable
bool ___m_Recordable_25;
// UnityEngine.Timeline.TimelineClip/ClipExtrapolation UnityEngine.Timeline.TimelineClip::m_PostExtrapolationMode
int32_t ___m_PostExtrapolationMode_26;
// UnityEngine.Timeline.TimelineClip/ClipExtrapolation UnityEngine.Timeline.TimelineClip::m_PreExtrapolationMode
int32_t ___m_PreExtrapolationMode_27;
// System.Double UnityEngine.Timeline.TimelineClip::m_PostExtrapolationTime
double ___m_PostExtrapolationTime_28;
// System.Double UnityEngine.Timeline.TimelineClip::m_PreExtrapolationTime
double ___m_PreExtrapolationTime_29;
// System.String UnityEngine.Timeline.TimelineClip::m_DisplayName
String_t* ___m_DisplayName_30;
};
struct TimelineClip_t003008F08E56A75F3A47FD9ADE7C066988A3371D_StaticFields
{
// UnityEngine.Timeline.ClipCaps UnityEngine.Timeline.TimelineClip::kDefaultClipCaps
int32_t ___kDefaultClipCaps_2;
// System.Single UnityEngine.Timeline.TimelineClip::kDefaultClipDurationInSeconds
float ___kDefaultClipDurationInSeconds_3;
// System.Double UnityEngine.Timeline.TimelineClip::kTimeScaleMin
double ___kTimeScaleMin_4;
// System.Double UnityEngine.Timeline.TimelineClip::kTimeScaleMax
double ___kTimeScaleMax_5;
// System.String UnityEngine.Timeline.TimelineClip::kDefaultCurvesName
String_t* ___kDefaultCurvesName_6;
// System.Double UnityEngine.Timeline.TimelineClip::kMinDuration
double ___kMinDuration_7;
// System.Double UnityEngine.Timeline.TimelineClip::kMaxTimeValue
double ___kMaxTimeValue_8;
};
// System.Type
struct Type_t : public MemberInfo_t
{
// System.RuntimeTypeHandle System.Type::_impl
RuntimeTypeHandle_t332A452B8B6179E4469B69525D0FE82A88030F7B ____impl_8;
};
struct Type_t_StaticFields
{
// System.Reflection.Binder modreq(System.Runtime.CompilerServices.IsVolatile) System.Type::s_defaultBinder
Binder_t91BFCE95A7057FADF4D8A1A342AFE52872246235* ___s_defaultBinder_0;
// System.Char System.Type::Delimiter
Il2CppChar ___Delimiter_1;
// System.Type[] System.Type::EmptyTypes
TypeU5BU5D_t97234E1129B564EB38B8D85CAC2AD8B5B9522FFB* ___EmptyTypes_2;
// System.Object System.Type::Missing
RuntimeObject* ___Missing_3;
// System.Reflection.MemberFilter System.Type::FilterAttribute
MemberFilter_tF644F1AE82F611B677CE1964D5A3277DDA21D553* ___FilterAttribute_4;
// System.Reflection.MemberFilter System.Type::FilterName
MemberFilter_tF644F1AE82F611B677CE1964D5A3277DDA21D553* ___FilterName_5;
// System.Reflection.MemberFilter System.Type::FilterNameIgnoreCase
MemberFilter_tF644F1AE82F611B677CE1964D5A3277DDA21D553* ___FilterNameIgnoreCase_6;
};
// UnityEngine.UIElements.UIR.UIRenderDevice
struct UIRenderDevice_t59628CBA89B4617E832C2B270E1C1A3931D01302 : public RuntimeObject
{
// System.Boolean UnityEngine.UIElements.UIR.UIRenderDevice::m_MockDevice
bool ___m_MockDevice_0;
// System.IntPtr UnityEngine.UIElements.UIR.UIRenderDevice::m_DefaultStencilState
intptr_t ___m_DefaultStencilState_1;
// System.IntPtr UnityEngine.UIElements.UIR.UIRenderDevice::m_VertexDecl
intptr_t ___m_VertexDecl_2;
// UnityEngine.UIElements.UIR.Page UnityEngine.UIElements.UIR.UIRenderDevice::m_FirstPage
Page_tB4EA8095DF85BAF22AB8FCA71400121E721B57C9* ___m_FirstPage_3;
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice::m_NextPageVertexCount
uint32_t ___m_NextPageVertexCount_4;
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice::m_LargeMeshVertexCount
uint32_t ___m_LargeMeshVertexCount_5;
// System.Single UnityEngine.UIElements.UIR.UIRenderDevice::m_IndexToVertexCountRatio
float ___m_IndexToVertexCountRatio_6;
// System.Collections.Generic.List`1<System.Collections.Generic.List`1<UnityEngine.UIElements.UIR.UIRenderDevice/AllocToFree>> UnityEngine.UIElements.UIR.UIRenderDevice::m_DeferredFrees
List_1_tB86898E2E533634C35EC58EC5DAE3353038A9210* ___m_DeferredFrees_7;
// System.Collections.Generic.List`1<System.Collections.Generic.List`1<UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate>> UnityEngine.UIElements.UIR.UIRenderDevice::m_Updates
List_1_tA79C35FB5E50135962B53960CB758B9262700632* ___m_Updates_8;
// System.UInt32[] UnityEngine.UIElements.UIR.UIRenderDevice::m_Fences
UInt32U5BU5D_t02FBD658AD156A17574ECE6106CF1FBFCC9807FA* ___m_Fences_9;
// UnityEngine.MaterialPropertyBlock UnityEngine.UIElements.UIR.UIRenderDevice::m_StandardMatProps
MaterialPropertyBlock_t2308669579033A857EFE6E4831909F638B27411D* ___m_StandardMatProps_10;
// UnityEngine.MaterialPropertyBlock UnityEngine.UIElements.UIR.UIRenderDevice::m_CommonMatProps
MaterialPropertyBlock_t2308669579033A857EFE6E4831909F638B27411D* ___m_CommonMatProps_11;
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice::m_FrameIndex
uint32_t ___m_FrameIndex_12;
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice::m_NextUpdateID
uint32_t ___m_NextUpdateID_13;
// UnityEngine.UIElements.UIR.UIRenderDevice/DrawStatistics UnityEngine.UIElements.UIR.UIRenderDevice::m_DrawStats
DrawStatistics_t4AF06C67CEC7B97509EBAD48E3EE908301598E6F ___m_DrawStats_14;
// UnityEngine.UIElements.UIR.LinkedPool`1<UnityEngine.UIElements.UIR.MeshHandle> UnityEngine.UIElements.UIR.UIRenderDevice::m_MeshHandles
LinkedPool_1_tD8A175EE023C8220138E51E722F4A20ACE9CA851* ___m_MeshHandles_15;
// UnityEngine.UIElements.UIR.DrawParams UnityEngine.UIElements.UIR.UIRenderDevice::m_DrawParams
DrawParams_t523864F415D78BD8BB14E8B7BD349594D6187443* ___m_DrawParams_16;
// UnityEngine.UIElements.UIR.TextureSlotManager UnityEngine.UIElements.UIR.UIRenderDevice::m_TextureSlotManager
TextureSlotManager_tB1F8E620AE296DE3728FAAFBE3CC85D2A176928D* ___m_TextureSlotManager_17;
// System.UInt32 UnityEngine.UIElements.UIR.UIRenderDevice::<maxVerticesPerPage>k__BackingField
uint32_t ___U3CmaxVerticesPerPageU3Ek__BackingField_35;
// System.Boolean UnityEngine.UIElements.UIR.UIRenderDevice::<breakBatches>k__BackingField
bool ___U3CbreakBatchesU3Ek__BackingField_36;
// System.Boolean UnityEngine.UIElements.UIR.UIRenderDevice::<disposed>k__BackingField
bool ___U3CdisposedU3Ek__BackingField_39;
};
struct UIRenderDevice_t59628CBA89B4617E832C2B270E1C1A3931D01302_StaticFields
{
// System.Collections.Generic.LinkedList`1<UnityEngine.UIElements.UIR.UIRenderDevice/DeviceToFree> UnityEngine.UIElements.UIR.UIRenderDevice::m_DeviceFreeQueue
LinkedList_1_t09F6FB09C766455615BBF59716D285304C49E0E7* ___m_DeviceFreeQueue_18;
// System.Int32 UnityEngine.UIElements.UIR.UIRenderDevice::m_ActiveDeviceCount
int32_t ___m_ActiveDeviceCount_19;
// System.Boolean UnityEngine.UIElements.UIR.UIRenderDevice::m_SubscribedToNotifications
bool ___m_SubscribedToNotifications_20;
// System.Boolean UnityEngine.UIElements.UIR.UIRenderDevice::m_SynchronousFree
bool ___m_SynchronousFree_21;
// System.Int32 UnityEngine.UIElements.UIR.UIRenderDevice::s_PixelClipInvViewPropID
int32_t ___s_PixelClipInvViewPropID_22;
// System.Int32 UnityEngine.UIElements.UIR.UIRenderDevice::s_GradientSettingsTexID
int32_t ___s_GradientSettingsTexID_23;
// System.Int32 UnityEngine.UIElements.UIR.UIRenderDevice::s_ShaderInfoTexID
int32_t ___s_ShaderInfoTexID_24;
// System.Int32 UnityEngine.UIElements.UIR.UIRenderDevice::s_ScreenClipRectPropID
int32_t ___s_ScreenClipRectPropID_25;
// System.Int32 UnityEngine.UIElements.UIR.UIRenderDevice::s_TransformsPropID
int32_t ___s_TransformsPropID_26;
// System.Int32 UnityEngine.UIElements.UIR.UIRenderDevice::s_ClipRectsPropID
int32_t ___s_ClipRectsPropID_27;
// Unity.Profiling.ProfilerMarker UnityEngine.UIElements.UIR.UIRenderDevice::s_MarkerAllocate
ProfilerMarker_tA256E18DA86EDBC5528CE066FC91C96EE86501AD ___s_MarkerAllocate_28;
// Unity.Profiling.ProfilerMarker UnityEngine.UIElements.UIR.UIRenderDevice::s_MarkerFree
ProfilerMarker_tA256E18DA86EDBC5528CE066FC91C96EE86501AD ___s_MarkerFree_29;
// Unity.Profiling.ProfilerMarker UnityEngine.UIElements.UIR.UIRenderDevice::s_MarkerAdvanceFrame
ProfilerMarker_tA256E18DA86EDBC5528CE066FC91C96EE86501AD ___s_MarkerAdvanceFrame_30;
// Unity.Profiling.ProfilerMarker UnityEngine.UIElements.UIR.UIRenderDevice::s_MarkerFence
ProfilerMarker_tA256E18DA86EDBC5528CE066FC91C96EE86501AD ___s_MarkerFence_31;
// Unity.Profiling.ProfilerMarker UnityEngine.UIElements.UIR.UIRenderDevice::s_MarkerBeforeDraw
ProfilerMarker_tA256E18DA86EDBC5528CE066FC91C96EE86501AD ___s_MarkerBeforeDraw_32;
// System.Nullable`1<System.Boolean> UnityEngine.UIElements.UIR.UIRenderDevice::s_VertexTexturingIsAvailable
Nullable_1_t78F453FADB4A9F50F267A4E349019C34410D1A01 ___s_VertexTexturingIsAvailable_33;
// System.Nullable`1<System.Boolean> UnityEngine.UIElements.UIR.UIRenderDevice::s_ShaderModelIs35
Nullable_1_t78F453FADB4A9F50F267A4E349019C34410D1A01 ___s_ShaderModelIs35_34;
// UnityEngine.Texture2D UnityEngine.UIElements.UIR.UIRenderDevice::s_DefaultShaderInfoTexFloat
Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* ___s_DefaultShaderInfoTexFloat_37;
// UnityEngine.Texture2D UnityEngine.UIElements.UIR.UIRenderDevice::s_DefaultShaderInfoTexARGB8
Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* ___s_DefaultShaderInfoTexARGB8_38;
};
// UnityEngine.UnityException
struct UnityException_tA1EC1E95ADE689CF6EB7FAFF77C160AE1F559067 : public Exception_t
{
};
// UnityEngine.UIElements.UIR.Utility
struct Utility_t8BCC393462C6270211734BE47CF5350F05EC97AD : public RuntimeObject
{
};
struct Utility_t8BCC393462C6270211734BE47CF5350F05EC97AD_StaticFields
{
// System.Action`1<System.Boolean> UnityEngine.UIElements.UIR.Utility::GraphicsResourcesRecreate
Action_1_t10DCB0C07D0D3C565CEACADC80D1152B35A45F6C* ___GraphicsResourcesRecreate_0;
// System.Action UnityEngine.UIElements.UIR.Utility::EngineUpdate
Action_tD00B0A84D7945E50C2DFFC28EFEE6ED44ED2AD07* ___EngineUpdate_1;
// System.Action UnityEngine.UIElements.UIR.Utility::FlushPendingResources
Action_tD00B0A84D7945E50C2DFFC28EFEE6ED44ED2AD07* ___FlushPendingResources_2;
// System.Action`1<UnityEngine.Camera> UnityEngine.UIElements.UIR.Utility::RegisterIntermediateRenderers
Action_1_t268986DA4CF361AC17B40338506A83AFB35832EA* ___RegisterIntermediateRenderers_3;
// System.Action`1<System.IntPtr> UnityEngine.UIElements.UIR.Utility::RenderNodeAdd
Action_1_t2DF1ED40E3084E997390FF52F462390882271FE2* ___RenderNodeAdd_4;
// System.Action`1<System.IntPtr> UnityEngine.UIElements.UIR.Utility::RenderNodeExecute
Action_1_t2DF1ED40E3084E997390FF52F462390882271FE2* ___RenderNodeExecute_5;
// System.Action`1<System.IntPtr> UnityEngine.UIElements.UIR.Utility::RenderNodeCleanup
Action_1_t2DF1ED40E3084E997390FF52F462390882271FE2* ___RenderNodeCleanup_6;
// Unity.Profiling.ProfilerMarker UnityEngine.UIElements.UIR.Utility::s_MarkerRaiseEngineUpdate
ProfilerMarker_tA256E18DA86EDBC5528CE066FC91C96EE86501AD ___s_MarkerRaiseEngineUpdate_7;
};
// UnityEngine.UIElements.UxmlAttributeDescription
struct UxmlAttributeDescription_t742D021489DB2B564142146CAAAC3F9191825EF2 : public RuntimeObject
{
// System.String UnityEngine.UIElements.UxmlAttributeDescription::<name>k__BackingField
String_t* ___U3CnameU3Ek__BackingField_0;
// System.String[] UnityEngine.UIElements.UxmlAttributeDescription::m_ObsoleteNames
StringU5BU5D_t7674CD946EC0CE7B3AE0BE70E6EE85F2ECD9F248* ___m_ObsoleteNames_1;
// System.String UnityEngine.UIElements.UxmlAttributeDescription::<type>k__BackingField
String_t* ___U3CtypeU3Ek__BackingField_2;
// System.String UnityEngine.UIElements.UxmlAttributeDescription::<typeNamespace>k__BackingField
String_t* ___U3CtypeNamespaceU3Ek__BackingField_3;
// UnityEngine.UIElements.UxmlAttributeDescription/Use UnityEngine.UIElements.UxmlAttributeDescription::<use>k__BackingField
int32_t ___U3CuseU3Ek__BackingField_4;
// UnityEngine.UIElements.UxmlTypeRestriction UnityEngine.UIElements.UxmlAttributeDescription::<restriction>k__BackingField
UxmlTypeRestriction_t2C4CE1ED76502CDF80010880E058AF0582910A92* ___U3CrestrictionU3Ek__BackingField_5;
};
// UnityEngine.Camera/RenderRequest
struct RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A
{
// UnityEngine.Camera/RenderRequestMode UnityEngine.Camera/RenderRequest::m_CameraRenderMode
int32_t ___m_CameraRenderMode_0;
// UnityEngine.RenderTexture UnityEngine.Camera/RenderRequest::m_ResultRT
RenderTexture_tBA90C4C3AD9EECCFDDCC632D97C29FAB80D60D27* ___m_ResultRT_1;
// UnityEngine.Camera/RenderRequestOutputSpace UnityEngine.Camera/RenderRequest::m_OutputSpace
int32_t ___m_OutputSpace_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.Camera/RenderRequest
struct RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A_marshaled_pinvoke
{
int32_t ___m_CameraRenderMode_0;
RenderTexture_tBA90C4C3AD9EECCFDDCC632D97C29FAB80D60D27* ___m_ResultRT_1;
int32_t ___m_OutputSpace_2;
};
// Native definition for COM marshalling of UnityEngine.Camera/RenderRequest
struct RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A_marshaled_com
{
int32_t ___m_CameraRenderMode_0;
RenderTexture_tBA90C4C3AD9EECCFDDCC632D97C29FAB80D60D27* ___m_ResultRT_1;
int32_t ___m_OutputSpace_2;
};
// UnityEngine.UIElements.StyleComplexSelector/PseudoStateData
struct PseudoStateData_tE5B3EBF682E8DE88E9325F44841D5B95FEB6F3A8
{
// UnityEngine.UIElements.PseudoStates UnityEngine.UIElements.StyleComplexSelector/PseudoStateData::state
int32_t ___state_0;
// System.Boolean UnityEngine.UIElements.StyleComplexSelector/PseudoStateData::negate
bool ___negate_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.StyleComplexSelector/PseudoStateData
struct PseudoStateData_tE5B3EBF682E8DE88E9325F44841D5B95FEB6F3A8_marshaled_pinvoke
{
int32_t ___state_0;
int32_t ___negate_1;
};
// Native definition for COM marshalling of UnityEngine.UIElements.StyleComplexSelector/PseudoStateData
struct PseudoStateData_tE5B3EBF682E8DE88E9325F44841D5B95FEB6F3A8_marshaled_com
{
int32_t ___state_0;
int32_t ___negate_1;
};
// UnityEngine.Timeline.TimeNotificationBehaviour/NotificationEntry
struct NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62
{
// System.Double UnityEngine.Timeline.TimeNotificationBehaviour/NotificationEntry::time
double ___time_0;
// UnityEngine.Playables.INotification UnityEngine.Timeline.TimeNotificationBehaviour/NotificationEntry::payload
RuntimeObject* ___payload_1;
// System.Boolean UnityEngine.Timeline.TimeNotificationBehaviour/NotificationEntry::notificationFired
bool ___notificationFired_2;
// UnityEngine.Timeline.NotificationFlags UnityEngine.Timeline.TimeNotificationBehaviour/NotificationEntry::flags
int16_t ___flags_3;
};
// Native definition for P/Invoke marshalling of UnityEngine.Timeline.TimeNotificationBehaviour/NotificationEntry
struct NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62_marshaled_pinvoke
{
double ___time_0;
RuntimeObject* ___payload_1;
int32_t ___notificationFired_2;
int16_t ___flags_3;
};
// Native definition for COM marshalling of UnityEngine.Timeline.TimeNotificationBehaviour/NotificationEntry
struct NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62_marshaled_com
{
double ___time_0;
RuntimeObject* ___payload_1;
int32_t ___notificationFired_2;
int16_t ___flags_3;
};
// Cinemachine.TargetPositionCache/CacheEntry/RecordingItem
struct RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E
{
// System.Single Cinemachine.TargetPositionCache/CacheEntry/RecordingItem::Time
float ___Time_0;
// System.Boolean Cinemachine.TargetPositionCache/CacheEntry/RecordingItem::IsCut
bool ___IsCut_1;
// Cinemachine.TargetPositionCache/CacheCurve/Item Cinemachine.TargetPositionCache/CacheEntry/RecordingItem::Item
Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E ___Item_2;
};
// Native definition for P/Invoke marshalling of Cinemachine.TargetPositionCache/CacheEntry/RecordingItem
struct RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E_marshaled_pinvoke
{
float ___Time_0;
int32_t ___IsCut_1;
Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E ___Item_2;
};
// Native definition for COM marshalling of Cinemachine.TargetPositionCache/CacheEntry/RecordingItem
struct RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E_marshaled_com
{
float ___Time_0;
int32_t ___IsCut_1;
Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E ___Item_2;
};
// System.Action`2<UnityEngine.UIElements.VisualElement,System.Object>
struct Action_2_t481D6C6BCDB085CB7BE1AA1DBD81F4DC0C04D1F2 : public MulticastDelegate_t
{
};
// System.Action`2<UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.Experimental.StyleValues>
struct Action_2_tCFAD9DC5CF83678682A1102DCD1B12DE9FCA395A : public MulticastDelegate_t
{
};
// Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>
struct AlignOfHelper_1_tC14085A002766BE215E2A570FCDA1F263125AA18
{
// System.Byte Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::dummy
uint8_t ___dummy_0;
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1::data
LightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21 ___data_1;
};
// System.Func`2<System.Single,System.Single>
struct Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2 : public MulticastDelegate_t
{
};
// System.Func`2<UnityEngine.UIElements.VisualElement,System.Object>
struct Func_2_t9AAA83BE20528E7FBB1DCCFF8E9640E7061D5BE3 : public MulticastDelegate_t
{
};
// System.Func`2<UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.Experimental.StyleValues>
struct Func_2_t87FB5A45506EB8DF671CF8BEB31A0FD5A00FA227 : public MulticastDelegate_t
{
};
// System.Func`3<System.String,System.Boolean,System.Boolean>
struct Func_3_t62BC9D925DCAC8F5784BA97C793F4E593496CDA7 : public MulticastDelegate_t
{
};
// System.Func`3<System.String,System.Int32,System.Int32>
struct Func_3_t0620ECF6AB73866242850ABCE518B069D201DA79 : public MulticastDelegate_t
{
};
// System.Func`3<System.String,System.Int32Enum,System.Int32Enum>
struct Func_3_t538A8E697534A282316BC2DF71DE83E68360C8B9 : public MulticastDelegate_t
{
};
// System.Func`3<System.String,System.Int64,System.Int64>
struct Func_3_tD3C5141B184A528ABF7649D429906DA08C68E4A7 : public MulticastDelegate_t
{
};
// System.Func`3<System.String,System.Object,System.Object>
struct Func_3_tBFBF2C1D5A7EE5485A61C55BA580F7AF50AABBF0 : public MulticastDelegate_t
{
};
// System.Func`3<System.String,System.Single,System.Single>
struct Func_3_t5328A430FC4208B44C52E4E89DC5F686DE6A6A1B : public MulticastDelegate_t
{
};
// System.Buffers.SpanAction`2<System.Char,System.ValueTuple`3<System.Object,System.Int32,System.Int32>>
struct SpanAction_2_t65B015FEFE1F64814AC2EFA0E19A38B1CFC53178 : public MulticastDelegate_t
{
};
// System.Buffers.SpanAction`2<System.Char,System.ValueTuple`5<System.IntPtr,System.Int32,System.IntPtr,System.Int32,System.Boolean>>
struct SpanAction_2_t84FDFFEECCC96A9A407DCB490E60340E38185947 : public MulticastDelegate_t
{
};
// System.Buffers.SpanAction`2<System.Char,System.Object>
struct SpanAction_2_t0CB19FBAD63F42C01432B842C5169FC10C1777E3 : public MulticastDelegate_t
{
};
// System.ArgumentException
struct ArgumentException_tAD90411542A20A9C72D5CDA3A84181D8B947A263 : public SystemException_tCC48D868298F4C0705279823E34B00F4FBDB7295
{
// System.String System.ArgumentException::_paramName
String_t* ____paramName_18;
};
// UnityEngine.Playables.PlayableAsset
struct PlayableAsset_t6964211C3DAE503FEEDD04089ED6B962945D271E : public ScriptableObject_tB3BFDB921A1B1795B38A5417D3B97A89A140436A
{
};
// UnityEngine.UIElements.UIR.RenderChainVEData
struct RenderChainVEData_t582DE9DA38C6B608A9A38286FCF6FA70398B5847
{
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.UIR.RenderChainVEData::prev
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___prev_0;
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.UIR.RenderChainVEData::next
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___next_1;
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.UIR.RenderChainVEData::groupTransformAncestor
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___groupTransformAncestor_2;
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.UIR.RenderChainVEData::boneTransformAncestor
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___boneTransformAncestor_3;
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.UIR.RenderChainVEData::prevDirty
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___prevDirty_4;
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.UIR.RenderChainVEData::nextDirty
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___nextDirty_5;
// System.Int32 UnityEngine.UIElements.UIR.RenderChainVEData::hierarchyDepth
int32_t ___hierarchyDepth_6;
// UnityEngine.UIElements.UIR.RenderDataDirtyTypes UnityEngine.UIElements.UIR.RenderChainVEData::dirtiedValues
int32_t ___dirtiedValues_7;
// System.UInt32 UnityEngine.UIElements.UIR.RenderChainVEData::dirtyID
uint32_t ___dirtyID_8;
// UnityEngine.UIElements.UIR.RenderChainCommand UnityEngine.UIElements.UIR.RenderChainVEData::firstCommand
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___firstCommand_9;
// UnityEngine.UIElements.UIR.RenderChainCommand UnityEngine.UIElements.UIR.RenderChainVEData::lastCommand
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___lastCommand_10;
// UnityEngine.UIElements.UIR.RenderChainCommand UnityEngine.UIElements.UIR.RenderChainVEData::firstClosingCommand
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___firstClosingCommand_11;
// UnityEngine.UIElements.UIR.RenderChainCommand UnityEngine.UIElements.UIR.RenderChainVEData::lastClosingCommand
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___lastClosingCommand_12;
// System.Boolean UnityEngine.UIElements.UIR.RenderChainVEData::isInChain
bool ___isInChain_13;
// System.Boolean UnityEngine.UIElements.UIR.RenderChainVEData::isHierarchyHidden
bool ___isHierarchyHidden_14;
// System.Boolean UnityEngine.UIElements.UIR.RenderChainVEData::localFlipsWinding
bool ___localFlipsWinding_15;
// System.Boolean UnityEngine.UIElements.UIR.RenderChainVEData::worldFlipsWinding
bool ___worldFlipsWinding_16;
// UnityEngine.UIElements.UIR.Implementation.ClipMethod UnityEngine.UIElements.UIR.RenderChainVEData::clipMethod
int32_t ___clipMethod_17;
// System.Int32 UnityEngine.UIElements.UIR.RenderChainVEData::childrenStencilRef
int32_t ___childrenStencilRef_18;
// System.Int32 UnityEngine.UIElements.UIR.RenderChainVEData::childrenMaskDepth
int32_t ___childrenMaskDepth_19;
// System.Boolean UnityEngine.UIElements.UIR.RenderChainVEData::disableNudging
bool ___disableNudging_20;
// System.Boolean UnityEngine.UIElements.UIR.RenderChainVEData::usesLegacyText
bool ___usesLegacyText_21;
// UnityEngine.UIElements.UIR.MeshHandle UnityEngine.UIElements.UIR.RenderChainVEData::data
MeshHandle_tC1E9A7ECCFDAEFDE064B8D58B35B9CEE5A70A22E* ___data_22;
// UnityEngine.UIElements.UIR.MeshHandle UnityEngine.UIElements.UIR.RenderChainVEData::closingData
MeshHandle_tC1E9A7ECCFDAEFDE064B8D58B35B9CEE5A70A22E* ___closingData_23;
// UnityEngine.Matrix4x4 UnityEngine.UIElements.UIR.RenderChainVEData::verticesSpace
Matrix4x4_tDB70CF134A14BA38190C59AA700BCE10E2AED3E6 ___verticesSpace_24;
// System.Int32 UnityEngine.UIElements.UIR.RenderChainVEData::displacementUVStart
int32_t ___displacementUVStart_25;
// System.Int32 UnityEngine.UIElements.UIR.RenderChainVEData::displacementUVEnd
int32_t ___displacementUVEnd_26;
// UnityEngine.UIElements.UIR.BMPAlloc UnityEngine.UIElements.UIR.RenderChainVEData::transformID
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___transformID_27;
// UnityEngine.UIElements.UIR.BMPAlloc UnityEngine.UIElements.UIR.RenderChainVEData::clipRectID
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___clipRectID_28;
// UnityEngine.UIElements.UIR.BMPAlloc UnityEngine.UIElements.UIR.RenderChainVEData::opacityID
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___opacityID_29;
// UnityEngine.UIElements.UIR.BMPAlloc UnityEngine.UIElements.UIR.RenderChainVEData::textCoreSettingsID
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___textCoreSettingsID_30;
// UnityEngine.UIElements.UIR.BMPAlloc UnityEngine.UIElements.UIR.RenderChainVEData::colorID
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___colorID_31;
// UnityEngine.UIElements.UIR.BMPAlloc UnityEngine.UIElements.UIR.RenderChainVEData::backgroundColorID
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___backgroundColorID_32;
// UnityEngine.UIElements.UIR.BMPAlloc UnityEngine.UIElements.UIR.RenderChainVEData::borderLeftColorID
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___borderLeftColorID_33;
// UnityEngine.UIElements.UIR.BMPAlloc UnityEngine.UIElements.UIR.RenderChainVEData::borderTopColorID
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___borderTopColorID_34;
// UnityEngine.UIElements.UIR.BMPAlloc UnityEngine.UIElements.UIR.RenderChainVEData::borderRightColorID
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___borderRightColorID_35;
// UnityEngine.UIElements.UIR.BMPAlloc UnityEngine.UIElements.UIR.RenderChainVEData::borderBottomColorID
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___borderBottomColorID_36;
// UnityEngine.UIElements.UIR.BMPAlloc UnityEngine.UIElements.UIR.RenderChainVEData::tintColorID
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___tintColorID_37;
// System.Single UnityEngine.UIElements.UIR.RenderChainVEData::compositeOpacity
float ___compositeOpacity_38;
// UnityEngine.Color UnityEngine.UIElements.UIR.RenderChainVEData::backgroundColor
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___backgroundColor_39;
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.UIR.RenderChainVEData::prevText
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___prevText_40;
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.UIR.RenderChainVEData::nextText
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___nextText_41;
// System.Collections.Generic.List`1<UnityEngine.UIElements.UIR.RenderChainTextEntry> UnityEngine.UIElements.UIR.RenderChainVEData::textEntries
List_1_t3ADC2CEE608F7E0043EBE4FD425E6C9AE43E19CC* ___textEntries_42;
// UnityEngine.UIElements.UIR.BasicNode`1<UnityEngine.UIElements.UIR.TextureEntry> UnityEngine.UIElements.UIR.RenderChainVEData::textures
BasicNode_1_t7B4D545DCD6949B2E1C85D63DF038E44602F7DDB* ___textures_43;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.UIR.RenderChainVEData
struct RenderChainVEData_t582DE9DA38C6B608A9A38286FCF6FA70398B5847_marshaled_pinvoke
{
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___prev_0;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___next_1;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___groupTransformAncestor_2;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___boneTransformAncestor_3;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___prevDirty_4;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___nextDirty_5;
int32_t ___hierarchyDepth_6;
int32_t ___dirtiedValues_7;
uint32_t ___dirtyID_8;
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___firstCommand_9;
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___lastCommand_10;
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___firstClosingCommand_11;
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___lastClosingCommand_12;
int32_t ___isInChain_13;
int32_t ___isHierarchyHidden_14;
int32_t ___localFlipsWinding_15;
int32_t ___worldFlipsWinding_16;
int32_t ___clipMethod_17;
int32_t ___childrenStencilRef_18;
int32_t ___childrenMaskDepth_19;
int32_t ___disableNudging_20;
int32_t ___usesLegacyText_21;
MeshHandle_tC1E9A7ECCFDAEFDE064B8D58B35B9CEE5A70A22E* ___data_22;
MeshHandle_tC1E9A7ECCFDAEFDE064B8D58B35B9CEE5A70A22E* ___closingData_23;
Matrix4x4_tDB70CF134A14BA38190C59AA700BCE10E2AED3E6 ___verticesSpace_24;
int32_t ___displacementUVStart_25;
int32_t ___displacementUVEnd_26;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___transformID_27;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___clipRectID_28;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___opacityID_29;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___textCoreSettingsID_30;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___colorID_31;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___backgroundColorID_32;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___borderLeftColorID_33;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___borderTopColorID_34;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___borderRightColorID_35;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___borderBottomColorID_36;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___tintColorID_37;
float ___compositeOpacity_38;
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___backgroundColor_39;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___prevText_40;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___nextText_41;
List_1_t3ADC2CEE608F7E0043EBE4FD425E6C9AE43E19CC* ___textEntries_42;
BasicNode_1_t7B4D545DCD6949B2E1C85D63DF038E44602F7DDB* ___textures_43;
};
// Native definition for COM marshalling of UnityEngine.UIElements.UIR.RenderChainVEData
struct RenderChainVEData_t582DE9DA38C6B608A9A38286FCF6FA70398B5847_marshaled_com
{
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___prev_0;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___next_1;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___groupTransformAncestor_2;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___boneTransformAncestor_3;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___prevDirty_4;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___nextDirty_5;
int32_t ___hierarchyDepth_6;
int32_t ___dirtiedValues_7;
uint32_t ___dirtyID_8;
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___firstCommand_9;
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___lastCommand_10;
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___firstClosingCommand_11;
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___lastClosingCommand_12;
int32_t ___isInChain_13;
int32_t ___isHierarchyHidden_14;
int32_t ___localFlipsWinding_15;
int32_t ___worldFlipsWinding_16;
int32_t ___clipMethod_17;
int32_t ___childrenStencilRef_18;
int32_t ___childrenMaskDepth_19;
int32_t ___disableNudging_20;
int32_t ___usesLegacyText_21;
MeshHandle_tC1E9A7ECCFDAEFDE064B8D58B35B9CEE5A70A22E* ___data_22;
MeshHandle_tC1E9A7ECCFDAEFDE064B8D58B35B9CEE5A70A22E* ___closingData_23;
Matrix4x4_tDB70CF134A14BA38190C59AA700BCE10E2AED3E6 ___verticesSpace_24;
int32_t ___displacementUVStart_25;
int32_t ___displacementUVEnd_26;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___transformID_27;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___clipRectID_28;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___opacityID_29;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___textCoreSettingsID_30;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___colorID_31;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___backgroundColorID_32;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___borderLeftColorID_33;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___borderTopColorID_34;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___borderRightColorID_35;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___borderBottomColorID_36;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___tintColorID_37;
float ___compositeOpacity_38;
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___backgroundColor_39;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___prevText_40;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___nextText_41;
List_1_t3ADC2CEE608F7E0043EBE4FD425E6C9AE43E19CC* ___textEntries_42;
BasicNode_1_t7B4D545DCD6949B2E1C85D63DF038E44602F7DDB* ___textures_43;
};
// UnityEngine.UIElements.Rotate
struct Rotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7
{
// UnityEngine.UIElements.Angle UnityEngine.UIElements.Rotate::m_Angle
Angle_t0229F612898D65B3CC646C40A32D93D8A33C1DFC ___m_Angle_0;
// UnityEngine.Vector3 UnityEngine.UIElements.Rotate::m_Axis
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___m_Axis_1;
// System.Boolean UnityEngine.UIElements.Rotate::m_IsNone
bool ___m_IsNone_2;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.Rotate
struct Rotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7_marshaled_pinvoke
{
Angle_t0229F612898D65B3CC646C40A32D93D8A33C1DFC ___m_Angle_0;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___m_Axis_1;
int32_t ___m_IsNone_2;
};
// Native definition for COM marshalling of UnityEngine.UIElements.Rotate
struct Rotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7_marshaled_com
{
Angle_t0229F612898D65B3CC646C40A32D93D8A33C1DFC ___m_Angle_0;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 ___m_Axis_1;
int32_t ___m_IsNone_2;
};
// UnityEngine.UIElements.StyleSheets.StylePropertyValue
struct StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2
{
// UnityEngine.UIElements.StyleSheet UnityEngine.UIElements.StyleSheets.StylePropertyValue::sheet
StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428* ___sheet_0;
// UnityEngine.UIElements.StyleValueHandle UnityEngine.UIElements.StyleSheets.StylePropertyValue::handle
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D ___handle_1;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.StyleSheets.StylePropertyValue
struct StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2_marshaled_pinvoke
{
StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428* ___sheet_0;
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D ___handle_1;
};
// Native definition for COM marshalling of UnityEngine.UIElements.StyleSheets.StylePropertyValue
struct StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2_marshaled_com
{
StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428* ___sheet_0;
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D ___handle_1;
};
// UnityEngine.UIElements.StyleSheet
struct StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428 : public ScriptableObject_tB3BFDB921A1B1795B38A5417D3B97A89A140436A
{
// System.Boolean UnityEngine.UIElements.StyleSheet::m_ImportedWithErrors
bool ___m_ImportedWithErrors_4;
// System.Boolean UnityEngine.UIElements.StyleSheet::m_ImportedWithWarnings
bool ___m_ImportedWithWarnings_5;
// UnityEngine.UIElements.StyleRule[] UnityEngine.UIElements.StyleSheet::m_Rules
StyleRuleU5BU5D_t7897A39D88CA043B2BFB5B28C53B41564EBA3AF3* ___m_Rules_6;
// UnityEngine.UIElements.StyleComplexSelector[] UnityEngine.UIElements.StyleSheet::m_ComplexSelectors
StyleComplexSelectorU5BU5D_tF7B5239DE9BF477DECF97EFBA7CB1D71C45DB857* ___m_ComplexSelectors_7;
// System.Single[] UnityEngine.UIElements.StyleSheet::floats
SingleU5BU5D_t89DEFE97BCEDB5857010E79ECE0F52CF6E93B87C* ___floats_8;
// UnityEngine.UIElements.StyleSheets.Dimension[] UnityEngine.UIElements.StyleSheet::dimensions
DimensionU5BU5D_t1EE1B3F9368D444E779CAB3E1CBD9959F8762F4B* ___dimensions_9;
// UnityEngine.Color[] UnityEngine.UIElements.StyleSheet::colors
ColorU5BU5D_t612261CF293F6FFC3D80AB52259FF0DC2B2CC389* ___colors_10;
// System.String[] UnityEngine.UIElements.StyleSheet::strings
StringU5BU5D_t7674CD946EC0CE7B3AE0BE70E6EE85F2ECD9F248* ___strings_11;
// UnityEngine.Object[] UnityEngine.UIElements.StyleSheet::assets
ObjectU5BU5D_tD4BF1BEC72A31DF6611C0B8FA3112AF128FC3F8A* ___assets_12;
// UnityEngine.UIElements.StyleSheet/ImportStruct[] UnityEngine.UIElements.StyleSheet::imports
ImportStructU5BU5D_t42D231FD5BB4B620965D7BED87D56D531B4C7AE9* ___imports_13;
// System.Collections.Generic.List`1<UnityEngine.UIElements.StyleSheet> UnityEngine.UIElements.StyleSheet::m_FlattenedImportedStyleSheets
List_1_tEA16F82F7871418E28EB6F551D77A8AD9F2E337F* ___m_FlattenedImportedStyleSheets_14;
// System.Int32 UnityEngine.UIElements.StyleSheet::m_ContentHash
int32_t ___m_ContentHash_15;
// UnityEngine.UIElements.StyleSheets.ScalableImage[] UnityEngine.UIElements.StyleSheet::scalableImages
ScalableImageU5BU5D_t8C989174900062AED19A057FDCF0529F8C594A52* ___scalableImages_16;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.UIElements.StyleComplexSelector> UnityEngine.UIElements.StyleSheet::orderedNameSelectors
Dictionary_2_t00B3CBC13D1439C8660D9FC33442C5620590706F* ___orderedNameSelectors_17;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.UIElements.StyleComplexSelector> UnityEngine.UIElements.StyleSheet::orderedTypeSelectors
Dictionary_2_t00B3CBC13D1439C8660D9FC33442C5620590706F* ___orderedTypeSelectors_18;
// System.Collections.Generic.Dictionary`2<System.String,UnityEngine.UIElements.StyleComplexSelector> UnityEngine.UIElements.StyleSheet::orderedClassSelectors
Dictionary_2_t00B3CBC13D1439C8660D9FC33442C5620590706F* ___orderedClassSelectors_19;
// System.Boolean UnityEngine.UIElements.StyleSheet::m_IsDefaultStyleSheet
bool ___m_IsDefaultStyleSheet_20;
};
struct StyleSheet_t6FAF43FCDB45BC6BED0522A222FD4C1A9BB10428_StaticFields
{
// System.String UnityEngine.UIElements.StyleSheet::kCustomPropertyMarker
String_t* ___kCustomPropertyMarker_21;
};
// UnityEngine.UIElements.StyleSheets.StyleValue
struct StyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5
{
union
{
#pragma pack(push, tp, 1)
struct
{
// UnityEngine.UIElements.StyleSheets.StylePropertyId UnityEngine.UIElements.StyleSheets.StyleValue::id
int32_t ___id_0;
};
#pragma pack(pop, tp)
struct
{
int32_t ___id_0_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___keyword_1_OffsetPadding[4];
// UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.StyleSheets.StyleValue::keyword
int32_t ___keyword_1;
};
#pragma pack(pop, tp)
struct
{
char ___keyword_1_OffsetPadding_forAlignmentOnly[4];
int32_t ___keyword_1_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___number_2_OffsetPadding[8];
// System.Single UnityEngine.UIElements.StyleSheets.StyleValue::number
float ___number_2;
};
#pragma pack(pop, tp)
struct
{
char ___number_2_OffsetPadding_forAlignmentOnly[8];
float ___number_2_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___length_3_OffsetPadding[8];
// UnityEngine.UIElements.Length UnityEngine.UIElements.StyleSheets.StyleValue::length
Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 ___length_3;
};
#pragma pack(pop, tp)
struct
{
char ___length_3_OffsetPadding_forAlignmentOnly[8];
Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 ___length_3_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___color_4_OffsetPadding[8];
// UnityEngine.Color UnityEngine.UIElements.StyleSheets.StyleValue::color
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___color_4;
};
#pragma pack(pop, tp)
struct
{
char ___color_4_OffsetPadding_forAlignmentOnly[8];
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___color_4_forAlignmentOnly;
};
#pragma pack(push, tp, 1)
struct
{
char ___resource_5_OffsetPadding[8];
// System.Runtime.InteropServices.GCHandle UnityEngine.UIElements.StyleSheets.StyleValue::resource
GCHandle_tC44F6F72EE68BD4CFABA24309DA7A179D41127DC ___resource_5;
};
#pragma pack(pop, tp)
struct
{
char ___resource_5_OffsetPadding_forAlignmentOnly[8];
GCHandle_tC44F6F72EE68BD4CFABA24309DA7A179D41127DC ___resource_5_forAlignmentOnly;
};
};
};
// UnityEngine.Texture2D
struct Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4 : public Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700
{
};
// UnityEngine.UIElements.TransformOrigin
struct TransformOrigin_tD11A368A96C0771398EBB4E6D435318AC0EF8502
{
// UnityEngine.UIElements.Length UnityEngine.UIElements.TransformOrigin::m_X
Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 ___m_X_0;
// UnityEngine.UIElements.Length UnityEngine.UIElements.TransformOrigin::m_Y
Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 ___m_Y_1;
// System.Single UnityEngine.UIElements.TransformOrigin::m_Z
float ___m_Z_2;
};
// UnityEngine.UIElements.Translate
struct Translate_t494F6E802F8A640D67819C9D26BE62DED1218A8E
{
// UnityEngine.UIElements.Length UnityEngine.UIElements.Translate::m_X
Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 ___m_X_0;
// UnityEngine.UIElements.Length UnityEngine.UIElements.Translate::m_Y
Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 ___m_Y_1;
// System.Single UnityEngine.UIElements.Translate::m_Z
float ___m_Z_2;
// System.Boolean UnityEngine.UIElements.Translate::m_isNone
bool ___m_isNone_3;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.Translate
struct Translate_t494F6E802F8A640D67819C9D26BE62DED1218A8E_marshaled_pinvoke
{
Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 ___m_X_0;
Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 ___m_Y_1;
float ___m_Z_2;
int32_t ___m_isNone_3;
};
// Native definition for COM marshalling of UnityEngine.UIElements.Translate
struct Translate_t494F6E802F8A640D67819C9D26BE62DED1218A8E_marshaled_com
{
Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 ___m_X_0;
Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 ___m_Y_1;
float ___m_Z_2;
int32_t ___m_isNone_3;
};
// UnityEngine.Timeline.AnimationOutputWeightProcessor/WeightInfo
struct WeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0
{
// UnityEngine.Playables.Playable UnityEngine.Timeline.AnimationOutputWeightProcessor/WeightInfo::mixer
Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F ___mixer_0;
// UnityEngine.Playables.Playable UnityEngine.Timeline.AnimationOutputWeightProcessor/WeightInfo::parentMixer
Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F ___parentMixer_1;
// System.Int32 UnityEngine.Timeline.AnimationOutputWeightProcessor/WeightInfo::port
int32_t ___port_2;
};
// UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry
struct Entry_tB8765CA56422E2C92887314844384843688DCB9F
{
// Unity.Collections.NativeSlice`1<UnityEngine.UIElements.Vertex> UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry::vertices
NativeSlice_1_t66375568C4FF313931F4D2F646D64FE6A406BAD2 ___vertices_0;
// Unity.Collections.NativeSlice`1<System.UInt16> UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry::indices
NativeSlice_1_t0D1A1AB7A9C4768B84EB7420D04A90920533C78A ___indices_1;
// UnityEngine.Material UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry::material
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___material_2;
// System.Single UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry::fontTexSDFScale
float ___fontTexSDFScale_3;
// UnityEngine.UIElements.TextureId UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry::texture
TextureId_tFF4B4AAE53408AB10B0B89CCA5F7B50CF2535E58 ___texture_4;
// UnityEngine.UIElements.UIR.RenderChainCommand UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry::customCommand
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___customCommand_5;
// UnityEngine.UIElements.UIR.BMPAlloc UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry::clipRectID
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___clipRectID_6;
// UnityEngine.UIElements.UIR.VertexFlags UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry::addFlags
int32_t ___addFlags_7;
// System.Boolean UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry::uvIsDisplacement
bool ___uvIsDisplacement_8;
// System.Boolean UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry::isTextEntry
bool ___isTextEntry_9;
// System.Boolean UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry::isClipRegisterEntry
bool ___isClipRegisterEntry_10;
// System.Int32 UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry::stencilRef
int32_t ___stencilRef_11;
// System.Int32 UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry::maskDepth
int32_t ___maskDepth_12;
};
// Native definition for P/Invoke marshalling of UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry
struct Entry_tB8765CA56422E2C92887314844384843688DCB9F_marshaled_pinvoke
{
NativeSlice_1_t66375568C4FF313931F4D2F646D64FE6A406BAD2 ___vertices_0;
NativeSlice_1_t0D1A1AB7A9C4768B84EB7420D04A90920533C78A ___indices_1;
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___material_2;
float ___fontTexSDFScale_3;
TextureId_tFF4B4AAE53408AB10B0B89CCA5F7B50CF2535E58 ___texture_4;
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___customCommand_5;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___clipRectID_6;
int32_t ___addFlags_7;
int32_t ___uvIsDisplacement_8;
int32_t ___isTextEntry_9;
int32_t ___isClipRegisterEntry_10;
int32_t ___stencilRef_11;
int32_t ___maskDepth_12;
};
// Native definition for COM marshalling of UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry
struct Entry_tB8765CA56422E2C92887314844384843688DCB9F_marshaled_com
{
NativeSlice_1_t66375568C4FF313931F4D2F646D64FE6A406BAD2 ___vertices_0;
NativeSlice_1_t0D1A1AB7A9C4768B84EB7420D04A90920533C78A ___indices_1;
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___material_2;
float ___fontTexSDFScale_3;
TextureId_tFF4B4AAE53408AB10B0B89CCA5F7B50CF2535E58 ___texture_4;
RenderChainCommand_t4F70E36AF4BC3645C8F9C822B7A3ACE9CB815727* ___customCommand_5;
BMPAlloc_t29DA9D09157B8BAD2D5643711A53A5F11D216D30 ___clipRectID_6;
int32_t ___addFlags_7;
int32_t ___uvIsDisplacement_8;
int32_t ___isTextEntry_9;
int32_t ___isClipRegisterEntry_10;
int32_t ___stencilRef_11;
int32_t ___maskDepth_12;
};
// System.ArgumentNullException
struct ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129 : public ArgumentException_tAD90411542A20A9C72D5CDA3A84181D8B947A263
{
};
// System.ArgumentOutOfRangeException
struct ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F : public ArgumentException_tAD90411542A20A9C72D5CDA3A84181D8B947A263
{
// System.Object System.ArgumentOutOfRangeException::_actualValue
RuntimeObject* ____actualValue_19;
};
// UnityEngine.Timeline.TimelineAsset
struct TimelineAsset_tE400C944B07CA9D1349BAD84545E24075ADB3496 : public PlayableAsset_t6964211C3DAE503FEEDD04089ED6B962945D271E
{
// System.Int32 UnityEngine.Timeline.TimelineAsset::m_Version
int32_t ___m_Version_5;
// System.Collections.Generic.List`1<UnityEngine.ScriptableObject> UnityEngine.Timeline.TimelineAsset::m_Tracks
List_1_tF941E9C3FEB6F1C2D20E73A90AA7F6319EB3F828* ___m_Tracks_6;
// System.Double UnityEngine.Timeline.TimelineAsset::m_FixedDuration
double ___m_FixedDuration_7;
// UnityEngine.Timeline.TrackAsset[] UnityEngine.Timeline.TimelineAsset::m_CacheOutputTracks
TrackAssetU5BU5D_tE6935AFD32D0BE4B0C69D1CCE96B55D383BCF88C* ___m_CacheOutputTracks_8;
// System.Collections.Generic.List`1<UnityEngine.Timeline.TrackAsset> UnityEngine.Timeline.TimelineAsset::m_CacheRootTracks
List_1_t6908BEEFB57470CB30420983896AA06BFB8796F0* ___m_CacheRootTracks_9;
// UnityEngine.Timeline.TrackAsset[] UnityEngine.Timeline.TimelineAsset::m_CacheFlattenedTracks
TrackAssetU5BU5D_tE6935AFD32D0BE4B0C69D1CCE96B55D383BCF88C* ___m_CacheFlattenedTracks_10;
// UnityEngine.Timeline.TimelineAsset/EditorSettings UnityEngine.Timeline.TimelineAsset::m_EditorSettings
EditorSettings_t3A8D02A80F57944B75911D9692FECDF6B7081DFF* ___m_EditorSettings_11;
// UnityEngine.Timeline.TimelineAsset/DurationMode UnityEngine.Timeline.TimelineAsset::m_DurationMode
int32_t ___m_DurationMode_12;
// UnityEngine.Timeline.MarkerTrack UnityEngine.Timeline.TimelineAsset::m_MarkerTrack
MarkerTrack_tE18594CE52CCC412606B1B5A147DD3A4F7D056C2* ___m_MarkerTrack_13;
};
// UnityEngine.Timeline.TrackAsset
struct TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96 : public PlayableAsset_t6964211C3DAE503FEEDD04089ED6B962945D271E
{
// System.Int32 UnityEngine.Timeline.TrackAsset::m_Version
int32_t ___m_Version_5;
// UnityEngine.AnimationClip UnityEngine.Timeline.TrackAsset::m_AnimClip
AnimationClip_t00BD2F131D308A4AD2C6B0BF66644FC25FECE712* ___m_AnimClip_6;
// System.Boolean UnityEngine.Timeline.TrackAsset::m_Locked
bool ___m_Locked_11;
// System.Boolean UnityEngine.Timeline.TrackAsset::m_Muted
bool ___m_Muted_12;
// System.String UnityEngine.Timeline.TrackAsset::m_CustomPlayableFullTypename
String_t* ___m_CustomPlayableFullTypename_13;
// UnityEngine.AnimationClip UnityEngine.Timeline.TrackAsset::m_Curves
AnimationClip_t00BD2F131D308A4AD2C6B0BF66644FC25FECE712* ___m_Curves_14;
// UnityEngine.Playables.PlayableAsset UnityEngine.Timeline.TrackAsset::m_Parent
PlayableAsset_t6964211C3DAE503FEEDD04089ED6B962945D271E* ___m_Parent_15;
// System.Collections.Generic.List`1<UnityEngine.ScriptableObject> UnityEngine.Timeline.TrackAsset::m_Children
List_1_tF941E9C3FEB6F1C2D20E73A90AA7F6319EB3F828* ___m_Children_16;
// System.Int32 UnityEngine.Timeline.TrackAsset::m_ItemsHash
int32_t ___m_ItemsHash_17;
// UnityEngine.Timeline.TimelineClip[] UnityEngine.Timeline.TrackAsset::m_ClipsCache
TimelineClipU5BU5D_t37945156A55BC896C442C4FE59198216769A4E64* ___m_ClipsCache_18;
// UnityEngine.Timeline.DiscreteTime UnityEngine.Timeline.TrackAsset::m_Start
DiscreteTime_t1598D60B0B2432F702E2A6120D04369EE54600A6 ___m_Start_19;
// UnityEngine.Timeline.DiscreteTime UnityEngine.Timeline.TrackAsset::m_End
DiscreteTime_t1598D60B0B2432F702E2A6120D04369EE54600A6 ___m_End_20;
// System.Boolean UnityEngine.Timeline.TrackAsset::m_CacheSorted
bool ___m_CacheSorted_21;
// System.Nullable`1<System.Boolean> UnityEngine.Timeline.TrackAsset::m_SupportsNotifications
Nullable_1_t78F453FADB4A9F50F267A4E349019C34410D1A01 ___m_SupportsNotifications_22;
// System.Collections.Generic.IEnumerable`1<UnityEngine.Timeline.TrackAsset> UnityEngine.Timeline.TrackAsset::m_ChildTrackCache
RuntimeObject* ___m_ChildTrackCache_24;
// System.Collections.Generic.List`1<UnityEngine.Timeline.TimelineClip> UnityEngine.Timeline.TrackAsset::m_Clips
List_1_tD78196B4DE777C4B74ADAD24051A9978F5191506* ___m_Clips_26;
// UnityEngine.Timeline.MarkerList UnityEngine.Timeline.TrackAsset::m_Markers
MarkerList_tD4B632EBA98CE678EB8D108A1AF559F734FA7698 ___m_Markers_27;
};
struct TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96_StaticFields
{
// UnityEngine.Timeline.TrackAsset/TransientBuildData UnityEngine.Timeline.TrackAsset::s_BuildData
TransientBuildData_t3BE8EF6B5113561AEE7D53FDF3DB331D39BE194F ___s_BuildData_7;
// System.Action`3<UnityEngine.Timeline.TimelineClip,UnityEngine.GameObject,UnityEngine.Playables.Playable> UnityEngine.Timeline.TrackAsset::OnClipPlayableCreate
Action_3_t3638A0A401CA68AF6FECFB956B602BBF7B9EFA72* ___OnClipPlayableCreate_9;
// System.Action`3<UnityEngine.Timeline.TrackAsset,UnityEngine.GameObject,UnityEngine.Playables.Playable> UnityEngine.Timeline.TrackAsset::OnTrackAnimationPlayableCreate
Action_3_t8A9161BC98843636E3BF066B37CBCC15C593B73E* ___OnTrackAnimationPlayableCreate_10;
// UnityEngine.Timeline.TrackAsset[] UnityEngine.Timeline.TrackAsset::s_EmptyCache
TrackAssetU5BU5D_tE6935AFD32D0BE4B0C69D1CCE96B55D383BCF88C* ___s_EmptyCache_23;
// System.Collections.Generic.Dictionary`2<System.Type,UnityEngine.Timeline.TrackBindingTypeAttribute> UnityEngine.Timeline.TrackAsset::s_TrackBindingTypeAttributeCache
Dictionary_2_tF0368534E8881FC0469B58E4901741C5B0CC1D79* ___s_TrackBindingTypeAttributeCache_25;
};
// UnityEngine.UIElements.VisualElement
struct VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115 : public Focusable_t39F2BAF0AF6CA465BC2BEDAF9B5B2CF379B846D0
{
// System.Int32 UnityEngine.UIElements.VisualElement::<UnityEngine.UIElements.IStylePropertyAnimations.runningAnimationCount>k__BackingField
int32_t ___U3CUnityEngine_UIElements_IStylePropertyAnimations_runningAnimationCountU3Ek__BackingField_8;
// System.Int32 UnityEngine.UIElements.VisualElement::<UnityEngine.UIElements.IStylePropertyAnimations.completedAnimationCount>k__BackingField
int32_t ___U3CUnityEngine_UIElements_IStylePropertyAnimations_completedAnimationCountU3Ek__BackingField_9;
// System.String UnityEngine.UIElements.VisualElement::m_Name
String_t* ___m_Name_14;
// System.Collections.Generic.List`1<System.String> UnityEngine.UIElements.VisualElement::m_ClassList
List_1_tF470A3BE5C1B5B68E1325EF3F109D172E60BD7CD* ___m_ClassList_15;
// System.Collections.Generic.List`1<System.Collections.Generic.KeyValuePair`2<UnityEngine.PropertyName,System.Object>> UnityEngine.UIElements.VisualElement::m_PropertyBag
List_1_t60F39D768DAD2345527AD3EE73FAB2667DF4F260* ___m_PropertyBag_16;
// UnityEngine.UIElements.VisualElementFlags UnityEngine.UIElements.VisualElement::m_Flags
int32_t ___m_Flags_17;
// System.String UnityEngine.UIElements.VisualElement::m_ViewDataKey
String_t* ___m_ViewDataKey_18;
// UnityEngine.UIElements.RenderHints UnityEngine.UIElements.VisualElement::m_RenderHints
int32_t ___m_RenderHints_19;
// UnityEngine.Rect UnityEngine.UIElements.VisualElement::lastLayout
Rect_tA04E0F8A1830E767F40FB27ECD8D309303571F0D ___lastLayout_20;
// UnityEngine.Rect UnityEngine.UIElements.VisualElement::lastPseudoPadding
Rect_tA04E0F8A1830E767F40FB27ECD8D309303571F0D ___lastPseudoPadding_21;
// UnityEngine.UIElements.UIR.RenderChainVEData UnityEngine.UIElements.VisualElement::renderChainData
RenderChainVEData_t582DE9DA38C6B608A9A38286FCF6FA70398B5847 ___renderChainData_22;
// UnityEngine.Rect UnityEngine.UIElements.VisualElement::m_Layout
Rect_tA04E0F8A1830E767F40FB27ECD8D309303571F0D ___m_Layout_23;
// UnityEngine.Rect UnityEngine.UIElements.VisualElement::m_BoundingBox
Rect_tA04E0F8A1830E767F40FB27ECD8D309303571F0D ___m_BoundingBox_24;
// UnityEngine.Rect UnityEngine.UIElements.VisualElement::m_WorldBoundingBox
Rect_tA04E0F8A1830E767F40FB27ECD8D309303571F0D ___m_WorldBoundingBox_25;
// UnityEngine.Matrix4x4 UnityEngine.UIElements.VisualElement::m_WorldTransformCache
Matrix4x4_tDB70CF134A14BA38190C59AA700BCE10E2AED3E6 ___m_WorldTransformCache_26;
// UnityEngine.Matrix4x4 UnityEngine.UIElements.VisualElement::m_WorldTransformInverseCache
Matrix4x4_tDB70CF134A14BA38190C59AA700BCE10E2AED3E6 ___m_WorldTransformInverseCache_27;
// UnityEngine.Rect UnityEngine.UIElements.VisualElement::m_WorldClip
Rect_tA04E0F8A1830E767F40FB27ECD8D309303571F0D ___m_WorldClip_28;
// UnityEngine.Rect UnityEngine.UIElements.VisualElement::m_WorldClipMinusGroup
Rect_tA04E0F8A1830E767F40FB27ECD8D309303571F0D ___m_WorldClipMinusGroup_29;
// System.Boolean UnityEngine.UIElements.VisualElement::m_WorldClipIsInfinite
bool ___m_WorldClipIsInfinite_30;
// UnityEngine.UIElements.PseudoStates UnityEngine.UIElements.VisualElement::triggerPseudoMask
int32_t ___triggerPseudoMask_32;
// UnityEngine.UIElements.PseudoStates UnityEngine.UIElements.VisualElement::dependencyPseudoMask
int32_t ___dependencyPseudoMask_33;
// UnityEngine.UIElements.PseudoStates UnityEngine.UIElements.VisualElement::m_PseudoStates
int32_t ___m_PseudoStates_34;
// UnityEngine.UIElements.PickingMode UnityEngine.UIElements.VisualElement::<pickingMode>k__BackingField
int32_t ___U3CpickingModeU3Ek__BackingField_35;
// UnityEngine.Yoga.YogaNode UnityEngine.UIElements.VisualElement::<yogaNode>k__BackingField
YogaNode_t4B5B593220CCB315B5A60CB48BA4795636F04DDA* ___U3CyogaNodeU3Ek__BackingField_36;
// UnityEngine.UIElements.ComputedStyle UnityEngine.UIElements.VisualElement::m_Style
ComputedStyle_t8B08CCCEE20525528B3FFDAC6D3F58F101AAF54C ___m_Style_37;
// UnityEngine.UIElements.StyleVariableContext UnityEngine.UIElements.VisualElement::variableContext
StyleVariableContext_tF74F2787CE1F6BEBBFBFF0771CF493AC9E403527* ___variableContext_38;
// System.Int32 UnityEngine.UIElements.VisualElement::inheritedStylesHash
int32_t ___inheritedStylesHash_39;
// System.UInt32 UnityEngine.UIElements.VisualElement::controlid
uint32_t ___controlid_40;
// System.Int32 UnityEngine.UIElements.VisualElement::imguiContainerDescendantCount
int32_t ___imguiContainerDescendantCount_41;
// System.Boolean UnityEngine.UIElements.VisualElement::<enabledSelf>k__BackingField
bool ___U3CenabledSelfU3Ek__BackingField_42;
// System.Action`1<UnityEngine.UIElements.MeshGenerationContext> UnityEngine.UIElements.VisualElement::<generateVisualContent>k__BackingField
Action_1_t3DC3411926243F1DB9C330F8E105B904E38C1A0B* ___U3CgenerateVisualContentU3Ek__BackingField_43;
// Unity.Profiling.ProfilerMarker UnityEngine.UIElements.VisualElement::k_GenerateVisualContentMarker
ProfilerMarker_tA256E18DA86EDBC5528CE066FC91C96EE86501AD ___k_GenerateVisualContentMarker_44;
// UnityEngine.UIElements.VisualElement/RenderTargetMode UnityEngine.UIElements.VisualElement::m_SubRenderTargetMode
int32_t ___m_SubRenderTargetMode_45;
// UnityEngine.Material UnityEngine.UIElements.VisualElement::m_defaultMaterial
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___m_defaultMaterial_47;
// System.Collections.Generic.List`1<UnityEngine.UIElements.Experimental.IValueAnimationUpdate> UnityEngine.UIElements.VisualElement::m_RunningAnimations
List_1_t96E9133B70FB6765E6B138E810D33E18901715DA* ___m_RunningAnimations_48;
// System.UInt32 UnityEngine.UIElements.VisualElement::m_NextParentCachedVersion
uint32_t ___m_NextParentCachedVersion_50;
// System.UInt32 UnityEngine.UIElements.VisualElement::m_NextParentRequiredVersion
uint32_t ___m_NextParentRequiredVersion_51;
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.VisualElement::m_CachedNextParentWithEventCallback
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___m_CachedNextParentWithEventCallback_52;
// System.Int32 UnityEngine.UIElements.VisualElement::m_EventCallbackCategories
int32_t ___m_EventCallbackCategories_53;
// System.Int32 UnityEngine.UIElements.VisualElement::m_CachedEventCallbackParentCategories
int32_t ___m_CachedEventCallbackParentCategories_54;
// System.Int32 UnityEngine.UIElements.VisualElement::m_DefaultActionEventCategories
int32_t ___m_DefaultActionEventCategories_55;
// System.Int32 UnityEngine.UIElements.VisualElement::m_DefaultActionAtTargetEventCategories
int32_t ___m_DefaultActionAtTargetEventCategories_56;
// UnityEngine.UIElements.VisualElement/Hierarchy UnityEngine.UIElements.VisualElement::<hierarchy>k__BackingField
Hierarchy_t4CF226F0EDE9C117C51C505730FC80641B1F1677 ___U3ChierarchyU3Ek__BackingField_58;
// System.Boolean UnityEngine.UIElements.VisualElement::<isRootVisualContainer>k__BackingField
bool ___U3CisRootVisualContainerU3Ek__BackingField_59;
// System.Boolean UnityEngine.UIElements.VisualElement::<cacheAsBitmap>k__BackingField
bool ___U3CcacheAsBitmapU3Ek__BackingField_60;
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.VisualElement::m_PhysicalParent
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___m_PhysicalParent_61;
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.VisualElement::m_LogicalParent
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___m_LogicalParent_62;
// System.Collections.Generic.List`1<UnityEngine.UIElements.VisualElement> UnityEngine.UIElements.VisualElement::m_Children
List_1_t6115BBE78FE9310B180A2027321DF46F2A06AC95* ___m_Children_64;
// UnityEngine.UIElements.BaseVisualElementPanel UnityEngine.UIElements.VisualElement::<elementPanel>k__BackingField
BaseVisualElementPanel_tE3811F3D1474B72CB6CD5BCEECFF5B5CBEC1E303* ___U3CelementPanelU3Ek__BackingField_65;
// UnityEngine.UIElements.VisualTreeAsset UnityEngine.UIElements.VisualElement::m_VisualTreeAssetSource
VisualTreeAsset_tFB5BF81F0780A412AE5A7C2C552B3EEA64EA2EEB* ___m_VisualTreeAssetSource_66;
// UnityEngine.UIElements.InlineStyleAccess UnityEngine.UIElements.VisualElement::inlineStyleAccess
InlineStyleAccess_t5CA7877999C9442491A220AE50D605C84D09A165* ___inlineStyleAccess_68;
// System.Collections.Generic.List`1<UnityEngine.UIElements.StyleSheet> UnityEngine.UIElements.VisualElement::styleSheetList
List_1_tEA16F82F7871418E28EB6F551D77A8AD9F2E337F* ___styleSheetList_69;
// UnityEngine.UIElements.VisualElement/TypeData UnityEngine.UIElements.VisualElement::m_TypeData
TypeData_t01D670B4E71B5571B38C7412B1E652A47D6AF66A* ___m_TypeData_73;
};
struct VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115_StaticFields
{
// System.UInt32 UnityEngine.UIElements.VisualElement::s_NextId
uint32_t ___s_NextId_10;
// System.Collections.Generic.List`1<System.String> UnityEngine.UIElements.VisualElement::s_EmptyClassList
List_1_tF470A3BE5C1B5B68E1325EF3F109D172E60BD7CD* ___s_EmptyClassList_11;
// UnityEngine.PropertyName UnityEngine.UIElements.VisualElement::userDataPropertyKey
PropertyName_tE4B4AAA58AF3BF2C0CD95509EB7B786F096901C2 ___userDataPropertyKey_12;
// System.String UnityEngine.UIElements.VisualElement::disabledUssClassName
String_t* ___disabledUssClassName_13;
// UnityEngine.Rect UnityEngine.UIElements.VisualElement::s_InfiniteRect
Rect_tA04E0F8A1830E767F40FB27ECD8D309303571F0D ___s_InfiniteRect_31;
// UnityEngine.Material UnityEngine.UIElements.VisualElement::s_runtimeMaterial
Material_t18053F08F347D0DCA5E1140EC7EC4533DD8A14E3* ___s_runtimeMaterial_46;
// System.UInt32 UnityEngine.UIElements.VisualElement::s_NextParentVersion
uint32_t ___s_NextParentVersion_49;
// System.Collections.Generic.List`1<UnityEngine.UIElements.VisualElement> UnityEngine.UIElements.VisualElement::s_EmptyList
List_1_t6115BBE78FE9310B180A2027321DF46F2A06AC95* ___s_EmptyList_63;
// UnityEngine.UIElements.VisualElement/CustomStyleAccess UnityEngine.UIElements.VisualElement::s_CustomStyleAccess
CustomStyleAccess_t170C852102B4D09FB478B620A75B14D096F9F2B1* ___s_CustomStyleAccess_67;
// System.Text.RegularExpressions.Regex UnityEngine.UIElements.VisualElement::s_InternalStyleSheetPath
Regex_tE773142C2BE45C5D362B0F815AFF831707A51772* ___s_InternalStyleSheetPath_70;
// UnityEngine.PropertyName UnityEngine.UIElements.VisualElement::tooltipPropertyKey
PropertyName_tE4B4AAA58AF3BF2C0CD95509EB7B786F096901C2 ___tooltipPropertyKey_71;
// System.Collections.Generic.Dictionary`2<System.Type,UnityEngine.UIElements.VisualElement/TypeData> UnityEngine.UIElements.VisualElement::s_TypeData
Dictionary_2_t4055F6540F36F21F9FEDAFB92D8E0089B38EBBC8* ___s_TypeData_72;
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
// UnityEngine.Color[]
struct ColorU5BU5D_t612261CF293F6FFC3D80AB52259FF0DC2B2CC389 : public RuntimeArray
{
ALIGN_FIELD (8) Color_tD001788D726C3A7F1379BEED0260B9591F440C1F m_Items[1];
inline Color_tD001788D726C3A7F1379BEED0260B9591F440C1F GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Color_tD001788D726C3A7F1379BEED0260B9591F440C1F* 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, Color_tD001788D726C3A7F1379BEED0260B9591F440C1F value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline Color_tD001788D726C3A7F1379BEED0260B9591F440C1F GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Color_tD001788D726C3A7F1379BEED0260B9591F440C1F* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Color_tD001788D726C3A7F1379BEED0260B9591F440C1F value)
{
m_Items[index] = value;
}
};
// System.Object[]
struct ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918 : public RuntimeArray
{
ALIGN_FIELD (8) RuntimeObject* m_Items[1];
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);
}
};
// UnityEngine.UIElements.StyleSheets.Dimension[]
struct DimensionU5BU5D_t1EE1B3F9368D444E779CAB3E1CBD9959F8762F4B : public RuntimeArray
{
ALIGN_FIELD (8) Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8 m_Items[1];
inline Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8* 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, Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8 value)
{
m_Items[index] = value;
}
};
// UnityEngine.UIElements.StyleSheets.ScalableImage[]
struct ScalableImageU5BU5D_t8C989174900062AED19A057FDCF0529F8C594A52 : public RuntimeArray
{
ALIGN_FIELD (8) ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F m_Items[1];
inline ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F* 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, ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___normalImage_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___highResolutionImage_1), (void*)NULL);
#endif
}
inline ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___normalImage_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___highResolutionImage_1), (void*)NULL);
#endif
}
};
// System.Single[]
struct SingleU5BU5D_t89DEFE97BCEDB5857010E79ECE0F52CF6E93B87C : public RuntimeArray
{
ALIGN_FIELD (8) float m_Items[1];
inline float GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline float* 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, float value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline float GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline float* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, float value)
{
m_Items[index] = value;
}
};
// System.Int32[]
struct Int32U5BU5D_t19C97395396A72ECAF310612F0760F165060314C : public RuntimeArray
{
ALIGN_FIELD (8) int32_t m_Items[1];
inline int32_t GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline int32_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, int32_t value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline int32_t GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline int32_t* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, int32_t value)
{
m_Items[index] = value;
}
};
// UnityEngine.TextCore.Text.LinkInfo[]
struct LinkInfoU5BU5D_tB7EB23E47AF29CCBEC884F9D0DB95BC97F62AE51 : public RuntimeArray
{
ALIGN_FIELD (8) LinkInfo_tE85DDAFDFBDA635E6405C88EE4FD5941A9243DD8 m_Items[1];
inline LinkInfo_tE85DDAFDFBDA635E6405C88EE4FD5941A9243DD8 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline LinkInfo_tE85DDAFDFBDA635E6405C88EE4FD5941A9243DD8* 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, LinkInfo_tE85DDAFDFBDA635E6405C88EE4FD5941A9243DD8 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___linkId_5), (void*)NULL);
}
inline LinkInfo_tE85DDAFDFBDA635E6405C88EE4FD5941A9243DD8 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline LinkInfo_tE85DDAFDFBDA635E6405C88EE4FD5941A9243DD8* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, LinkInfo_tE85DDAFDFBDA635E6405C88EE4FD5941A9243DD8 value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___linkId_5), (void*)NULL);
}
};
// UnityEngine.TextCore.Text.WordInfo[]
struct WordInfoU5BU5D_tAD74C9720883D7BB229A20FFAE9EFD2CF9963F7B : public RuntimeArray
{
ALIGN_FIELD (8) WordInfo_tA466206097891A5A2590896EE164AFC406EB060D m_Items[1];
inline WordInfo_tA466206097891A5A2590896EE164AFC406EB060D GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline WordInfo_tA466206097891A5A2590896EE164AFC406EB060D* 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, WordInfo_tA466206097891A5A2590896EE164AFC406EB060D value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline WordInfo_tA466206097891A5A2590896EE164AFC406EB060D GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline WordInfo_tA466206097891A5A2590896EE164AFC406EB060D* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, WordInfo_tA466206097891A5A2590896EE164AFC406EB060D value)
{
m_Items[index] = value;
}
};
// UnityEngine.TextCore.Text.MeshInfo[]
struct MeshInfoU5BU5D_t3DF8B75BF4A213334EED197AD25E432212894AC6 : public RuntimeArray
{
ALIGN_FIELD (8) MeshInfo_tE55C4A8846CC2C399CCC3FE989476D987B86AB2F m_Items[1];
inline MeshInfo_tE55C4A8846CC2C399CCC3FE989476D987B86AB2F GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline MeshInfo_tE55C4A8846CC2C399CCC3FE989476D987B86AB2F* 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, MeshInfo_tE55C4A8846CC2C399CCC3FE989476D987B86AB2F value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___vertices_2), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___uvs0_3), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___uvs2_4), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___colors32_5), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___triangles_6), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___material_7), (void*)NULL);
#endif
}
inline MeshInfo_tE55C4A8846CC2C399CCC3FE989476D987B86AB2F GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline MeshInfo_tE55C4A8846CC2C399CCC3FE989476D987B86AB2F* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, MeshInfo_tE55C4A8846CC2C399CCC3FE989476D987B86AB2F value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___vertices_2), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___uvs0_3), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___uvs2_4), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___colors32_5), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___triangles_6), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___material_7), (void*)NULL);
#endif
}
};
// UnityEngine.TextCore.Text.PageInfo[]
struct PageInfoU5BU5D_tFEA2CF88695491CFC2F2A2EF6BDCC56E52B0A6D4 : public RuntimeArray
{
ALIGN_FIELD (8) PageInfo_tFFF6B289E9A37E4D69353B32F941421180DA5909 m_Items[1];
inline PageInfo_tFFF6B289E9A37E4D69353B32F941421180DA5909 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline PageInfo_tFFF6B289E9A37E4D69353B32F941421180DA5909* 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, PageInfo_tFFF6B289E9A37E4D69353B32F941421180DA5909 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
}
inline PageInfo_tFFF6B289E9A37E4D69353B32F941421180DA5909 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline PageInfo_tFFF6B289E9A37E4D69353B32F941421180DA5909* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, PageInfo_tFFF6B289E9A37E4D69353B32F941421180DA5909 value)
{
m_Items[index] = value;
}
};
// UnityEngine.TextCore.Text.TextElementInfo[]
struct TextElementInfoU5BU5D_tEC28C9B72883EE21AA798913497C69E179A15C4E : public RuntimeArray
{
ALIGN_FIELD (8) TextElementInfo_tDD7A12E319505510E0B350E342BD55F32AB5F976 m_Items[1];
inline TextElementInfo_tDD7A12E319505510E0B350E342BD55F32AB5F976 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline TextElementInfo_tDD7A12E319505510E0B350E342BD55F32AB5F976* 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, TextElementInfo_tDD7A12E319505510E0B350E342BD55F32AB5F976 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___textElement_3), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___fontAsset_4), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___spriteAsset_5), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___material_7), (void*)NULL);
#endif
}
inline TextElementInfo_tDD7A12E319505510E0B350E342BD55F32AB5F976 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline TextElementInfo_tDD7A12E319505510E0B350E342BD55F32AB5F976* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, TextElementInfo_tDD7A12E319505510E0B350E342BD55F32AB5F976 value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___textElement_3), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___fontAsset_4), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___spriteAsset_5), (void*)NULL);
#endif
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___material_7), (void*)NULL);
#endif
}
};
// UnityEngine.UIElements.StyleSelector[]
struct StyleSelectorU5BU5D_t11A633455FC601606B3DF3CEDDDAB1625B54708D : public RuntimeArray
{
ALIGN_FIELD (8) StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362* m_Items[1];
inline StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362* GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362** 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, StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362* value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
inline StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362* GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362** GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362* value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)m_Items + index, (void*)value);
}
};
// UnityEngine.UIElements.StyleSelectorPart[]
struct StyleSelectorPartU5BU5D_tBA574FB3E75E94E52874FDB7B05B9048E8A5421B : public RuntimeArray
{
ALIGN_FIELD (8) StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 m_Items[1];
inline StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 GetAt(il2cpp_array_size_t index) const
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
return m_Items[index];
}
inline StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470* 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, StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 value)
{
IL2CPP_ARRAY_BOUNDS_CHECK(index, (uint32_t)(this)->max_length);
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___m_Value_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___tempData_2), (void*)NULL);
#endif
}
inline StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 GetAtUnchecked(il2cpp_array_size_t index) const
{
return m_Items[index];
}
inline StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470* GetAddressAtUnchecked(il2cpp_array_size_t index)
{
return m_Items + index;
}
inline void SetAtUnchecked(il2cpp_array_size_t index, StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 value)
{
m_Items[index] = value;
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___m_Value_0), (void*)NULL);
#if IL2CPP_ENABLE_STRICT_WRITE_BARRIERS
Il2CppCodeGenWriteBarrier((void**)&((m_Items + index)->___tempData_2), (void*)NULL);
#endif
}
};
// System.Void System.Span`1<System.Char>::.ctor(T&,System.Int32)
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void Span_1__ctor_mC9BE2938B716B46BB6B9070B94DBE5CE814BC0E2_gshared_inline (Span_1_tEDDF15FCF9EC6DEBA0F696BAACDDBAB9D92C252D* __this, Il2CppChar* ___ptr0, int32_t ___length1, const RuntimeMethod* method) ;
// System.Void System.Collections.Generic.Dictionary`2<System.Int32Enum,System.Object>::set_Item(TKey,TValue)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Dictionary_2_set_Item_m78DDC81EE49FB9D4194E83685FFED445DFDB75CA_gshared (Dictionary_2_t514396B90715EDD83BB0470C76C2F426F9381C71* __this, int32_t ___key0, RuntimeObject* ___value1, const RuntimeMethod* method) ;
// System.Boolean System.Collections.Generic.List`1<System.Object>::Contains(T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool List_1_Contains_m4C9139C2A6B23E9343D3F87807B32C6E2CFE660D_gshared (List_1_tA239CB83DE5615F348BB0507E45F490F4F7C9A8D* __this, RuntimeObject* ___item0, const RuntimeMethod* method) ;
// System.Void System.Collections.Generic.List`1<System.Object>::Add(T)
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void List_1_Add_mEBCF994CC3814631017F46A387B1A192ED6C85C7_gshared_inline (List_1_tA239CB83DE5615F348BB0507E45F490F4F7C9A8D* __this, RuntimeObject* ___item0, const RuntimeMethod* method) ;
// System.Void* Unity.Collections.LowLevel.Unsafe.NativeSliceUnsafeUtility::GetUnsafePtr<UnityEngine.UIElements.UIR.DrawBufferRange>(Unity.Collections.NativeSlice`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void* NativeSliceUnsafeUtility_GetUnsafePtr_TisDrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4_m5682E2958E30CCCFB6477FB04847917857BEFAFA_gshared (NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974 ___nativeSlice0, const RuntimeMethod* method) ;
// System.Int32 Unity.Collections.NativeSlice`1<UnityEngine.UIElements.UIR.DrawBufferRange>::get_Length()
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR int32_t NativeSlice_1_get_Length_m2566843C81FEFDDF6407962D4E34F13C3133028D_gshared_inline (NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974* __this, const RuntimeMethod* method) ;
// UnityEngine.UIElements.UQueryState`1<T> UnityEngine.UIElements.UQueryState`1<System.Object>::RebuildOn(UnityEngine.UIElements.VisualElement)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UQueryState_1_tDA47936DEF27643350186CA4E1DED7053A3D02B2 UQueryState_1_RebuildOn_mF29E43348045B1219A757EBBF43C892C32EEA5DC_gshared (UQueryState_1_tDA47936DEF27643350186CA4E1DED7053A3D02B2* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___element0, const RuntimeMethod* method) ;
// T System.Collections.Generic.List`1<UnityEngine.UIElements.RuleMatcher>::get_Item(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68_gshared (List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC* __this, int32_t ___index0, const RuntimeMethod* method) ;
// T UnityEngine.UIElements.UQueryState`1<System.Object>::First()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* UQueryState_1_First_m19FF1885E9D1D57D0EBA715820CA3C02C2C9C363_gshared (UQueryState_1_tDA47936DEF27643350186CA4E1DED7053A3D02B2* __this, const RuntimeMethod* method) ;
// System.Int32 Unity.Collections.NativeSlice`1<UnityEngine.UIElements.UIR.Transform3x4>::get_Length()
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR int32_t NativeSlice_1_get_Length_mC069C9254C3F61C678293E03E3E7C51F245F52E9_gshared_inline (NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370* __this, const RuntimeMethod* method) ;
// System.Int32 Unity.Collections.NativeSlice`1<UnityEngine.UIElements.UIR.Transform3x4>::get_Stride()
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR int32_t NativeSlice_1_get_Stride_mE29B800705645CDD49B576BB3B9B328811F27C90_gshared_inline (NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370* __this, const RuntimeMethod* method) ;
// System.Int32 Unity.Collections.NativeSlice`1<UnityEngine.Vector4>::get_Length()
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR int32_t NativeSlice_1_get_Length_mED822A5A5476BEBA72E429C395644A7B41F78F50_gshared_inline (NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F* __this, const RuntimeMethod* method) ;
// System.Int32 Unity.Collections.NativeSlice`1<UnityEngine.Vector4>::get_Stride()
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR int32_t NativeSlice_1_get_Stride_m2BC6AD2264EE2D02A38D29E30D382DEA9B5A9E29_gshared_inline (NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F* __this, const RuntimeMethod* method) ;
// System.IntPtr System.IntPtr::op_Explicit(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR intptr_t IntPtr_op_Explicit_mB06D1B6CFBA72B5C55FBEC1BA3BC25958AB60EB1 (int32_t ___value0, const RuntimeMethod* method) ;
// System.IntPtr System.IntPtr::op_Addition(System.IntPtr,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR intptr_t IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE (intptr_t ___pointer0, int32_t ___offset1, const RuntimeMethod* method) ;
// System.Void* System.IntPtr::op_Explicit(System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void* IntPtr_op_Explicit_m693F2F9E685EE117D4AC080342B8959DAF684294 (intptr_t ___value0, const RuntimeMethod* method) ;
// System.Boolean System.Char::Equals(System.Char)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Char_Equals_mEA7BFB45790C973DF6352091FA924B3FB2EFCE4B (Il2CppChar* __this, Il2CppChar ___obj0, const RuntimeMethod* method) ;
// System.Void System.ArgumentNullException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ArgumentNullException__ctor_m444AE141157E333844FC1A9500224C2F9FD24F4B (ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129* __this, String_t* ___paramName0, const RuntimeMethod* method) ;
// System.Void System.ArgumentOutOfRangeException::.ctor(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ArgumentOutOfRangeException__ctor_mBC1D5DEEA1BA41DE77228CB27D6BAFEB6DCCBF4A (ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F* __this, String_t* ___paramName0, const RuntimeMethod* method) ;
// System.String System.String::FastAllocateString(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_FastAllocateString_mF8E983B7ABC42CA6EB80C5052243D21E81CC2112 (int32_t ___length0, const RuntimeMethod* method) ;
// System.Char& System.String::GetRawStringData()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar* String_GetRawStringData_m87BC50B7B314C055E27A28032D1003D42FDE411D (String_t* __this, const RuntimeMethod* method) ;
// System.Void System.Span`1<System.Char>::.ctor(T&,System.Int32)
inline void Span_1__ctor_mC9BE2938B716B46BB6B9070B94DBE5CE814BC0E2_inline (Span_1_tEDDF15FCF9EC6DEBA0F696BAACDDBAB9D92C252D* __this, Il2CppChar* ___ptr0, int32_t ___length1, const RuntimeMethod* method)
{
(( void (*) (Span_1_tEDDF15FCF9EC6DEBA0F696BAACDDBAB9D92C252D*, Il2CppChar*, int32_t, const RuntimeMethod*))Span_1__ctor_mC9BE2938B716B46BB6B9070B94DBE5CE814BC0E2_gshared_inline)(__this, ___ptr0, ___length1, method);
}
// System.Globalization.CultureInfo System.Globalization.CultureInfo::get_CurrentCulture()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0* CultureInfo_get_CurrentCulture_m43D1E4E50AB1F62ADC7C1884F28F918B53871522 (const RuntimeMethod* method) ;
// System.String System.Int32::ToString(System.String,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* Int32_ToString_mE871810BC163EE4EF88E7C7682A6AD39911173B8 (int32_t* __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method) ;
// System.Text.StringBuilder System.Text.StringBuilder::Append(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StringBuilder_t* StringBuilder_Append_m08904D74E0C78E5F36DCD9C9303BDD07886D9F7D (StringBuilder_t* __this, String_t* ___value0, const RuntimeMethod* method) ;
// System.String System.UInt32::ToString(System.String,System.IFormatProvider)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* UInt32_ToString_m464396B0FE2115F3CEA38AEECDDB0FACC3AADADE (uint32_t* __this, String_t* ___format0, RuntimeObject* ___provider1, const RuntimeMethod* method) ;
// System.Void System.Collections.Generic.Dictionary`2<UnityEngine.UIElements.StyleSheets.StylePropertyId,UnityEngine.UIElements.StylePropertyAnimationSystem/Values>::set_Item(TKey,TValue)
inline void Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273 (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* __this, int32_t ___key0, Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24* ___value1, const RuntimeMethod* method)
{
(( void (*) (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7*, int32_t, Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*, const RuntimeMethod*))Dictionary_2_set_Item_m78DDC81EE49FB9D4194E83685FFED445DFDB75CA_gshared)(__this, ___key0, ___value1, method);
}
// System.Int64 UnityEngine.UIElements.StylePropertyAnimationSystem::CurrentTimeMs()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t StylePropertyAnimationSystem_CurrentTimeMs_m3B079B6B759368132A67B8F2E6052A270A7A49B6 (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, const RuntimeMethod* method) ;
// System.Boolean System.Collections.Generic.List`1<UnityEngine.UIElements.StylePropertyAnimationSystem/Values>::Contains(T)
inline bool List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4 (List_1_t491E344573B9D6F61E36AF56132B7412453928C9* __this, Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24* ___item0, const RuntimeMethod* method)
{
return (( bool (*) (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*, Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*, const RuntimeMethod*))List_1_Contains_m4C9139C2A6B23E9343D3F87807B32C6E2CFE660D_gshared)(__this, ___item0, method);
}
// System.Void System.Collections.Generic.List`1<UnityEngine.UIElements.StylePropertyAnimationSystem/Values>::Add(T)
inline void List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_inline (List_1_t491E344573B9D6F61E36AF56132B7412453928C9* __this, Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24* ___item0, const RuntimeMethod* method)
{
(( void (*) (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*, Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*, const RuntimeMethod*))List_1_Add_mEBCF994CC3814631017F46A387B1A192ED6C85C7_gshared_inline)(__this, ___item0, method);
}
// UnityEngine.UIElements.StyleValueType UnityEngine.UIElements.StyleValueHandle::get_valueType()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9 (StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D* __this, const RuntimeMethod* method) ;
// System.Void UnityEngine.Debug::LogErrorFormat(System.String,System.Object[])
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Debug_LogErrorFormat_mA33C95EF832A60D72A7EE26074E13A86BE7E30C6 (String_t* ___format0, ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* ___args1, const RuntimeMethod* method) ;
// System.Void UnityEngine.Debug::LogError(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Debug_LogError_m059825802BB6AF7EA9693FEBEEB0D85F59A3E38E (RuntimeObject* ___message0, const RuntimeMethod* method) ;
// System.String System.String::Format(System.String,System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30 (String_t* ___format0, RuntimeObject* ___arg01, const RuntimeMethod* method) ;
// System.Boolean System.Threading.CancellationToken::get_IsCancellationRequested()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool CancellationToken_get_IsCancellationRequested_m9744F7A1A82946FDD1DC68E905F1ED826471D350 (CancellationToken_t51142D9C6D7C02D314DA34A6A7988C528992FFED* __this, const RuntimeMethod* method) ;
// System.Int32 UnityEngine.Mathf::NextPowerOfTwo(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Mathf_NextPowerOfTwo_m25B17CBCFB02762842BE3725618DD97C7C4B1014 (int32_t ___value0, const RuntimeMethod* method) ;
// UnityEngine.UnityException UnityEngine.Texture::CreateNonReadableException(UnityEngine.Texture)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UnityException_tA1EC1E95ADE689CF6EB7FAFF77C160AE1F559067* Texture_CreateNonReadableException_m29786CD930E89C281564A9B341FD4088FBC8C94F (Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700* __this, Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700* ___t0, const RuntimeMethod* method) ;
// System.IntPtr UnityEngine.Texture2D::GetWritableImageData(System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR intptr_t Texture2D_GetWritableImageData_m8E26026A332040F8713E5A2A13C5545797159A5E (Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* __this, int32_t ___frame0, const RuntimeMethod* method) ;
// System.Int64 UnityEngine.Texture2D::GetRawImageDataSize()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t Texture2D_GetRawImageDataSize_m690AA2A7E6B0A207BC6DCA00A6313C3407CE3418 (Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* __this, const RuntimeMethod* method) ;
// System.Void System.ThrowHelper::ThrowArgumentNullException(System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF (int32_t ___argument0, const RuntimeMethod* method) ;
// System.Type System.Type::GetTypeFromHandle(System.RuntimeTypeHandle)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Type_t* Type_GetTypeFromHandle_m2570A2A5B32A5E9D9F0F38B37459DA18736C823E (RuntimeTypeHandle_t332A452B8B6179E4469B69525D0FE82A88030F7B ___handle0, const RuntimeMethod* method) ;
// UnityEngine.Timeline.TrackAsset UnityEngine.Timeline.TimelineAsset::CreateTrack(System.Type,UnityEngine.Timeline.TrackAsset,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96* TimelineAsset_CreateTrack_m327D088F33507A544DE566503CDF6593C024C1ED (TimelineAsset_tE400C944B07CA9D1349BAD84545E24075ADB3496* __this, Type_t* ___type0, TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96* ___parent1, String_t* ___name2, const RuntimeMethod* method) ;
// UnityEngine.Timeline.TimelineClip UnityEngine.Timeline.TrackAsset::CreateClip(System.Type)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TimelineClip_t003008F08E56A75F3A47FD9ADE7C066988A3371D* TrackAsset_CreateClip_mA7D1A7B6ACCF5CCF9FB416E86C483BD2EC31A45F (TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96* __this, Type_t* ___requestedType0, const RuntimeMethod* method) ;
// UnityEngine.Timeline.IMarker UnityEngine.Timeline.TrackAsset::CreateMarker(System.Type,System.Double)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* TrackAsset_CreateMarker_mD4F5715387220B12D0EF244C7C02F83F6040638A (TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96* __this, Type_t* ___type0, double ___time1, const RuntimeMethod* method) ;
// System.Void* Unity.Collections.LowLevel.Unsafe.NativeSliceUnsafeUtility::GetUnsafePtr<UnityEngine.UIElements.UIR.DrawBufferRange>(Unity.Collections.NativeSlice`1<T>)
inline void* NativeSliceUnsafeUtility_GetUnsafePtr_TisDrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4_m5682E2958E30CCCFB6477FB04847917857BEFAFA (NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974 ___nativeSlice0, const RuntimeMethod* method)
{
return (( void* (*) (NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974, const RuntimeMethod*))NativeSliceUnsafeUtility_GetUnsafePtr_TisDrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4_m5682E2958E30CCCFB6477FB04847917857BEFAFA_gshared)(___nativeSlice0, method);
}
// System.Void System.IntPtr::.ctor(System.Void*)
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void IntPtr__ctor_m4F9A9B80F01996B610D5AE4797F20B98ECD0A3D9_inline (intptr_t* __this, void* ___value0, const RuntimeMethod* method) ;
// System.Int32 Unity.Collections.NativeSlice`1<UnityEngine.UIElements.UIR.DrawBufferRange>::get_Length()
inline int32_t NativeSlice_1_get_Length_m2566843C81FEFDDF6407962D4E34F13C3133028D_inline (NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974* __this, const RuntimeMethod* method)
{
return (( int32_t (*) (NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974*, const RuntimeMethod*))NativeSlice_1_get_Length_m2566843C81FEFDDF6407962D4E34F13C3133028D_gshared_inline)(__this, method);
}
// System.Void UnityEngine.UIElements.UIR.Utility::DrawRanges(System.IntPtr,System.IntPtr*,System.Int32,System.IntPtr,System.Int32,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Utility_DrawRanges_m5C054AC5885504B35399A861D70E9492DBC957A6 (intptr_t ___ib0, intptr_t* ___vertexStreams1, int32_t ___streamCount2, intptr_t ___ranges3, int32_t ___rangeCount4, intptr_t ___vertexDecl5, const RuntimeMethod* method) ;
// UnityEngine.UIElements.VisualElement UnityEngine.UIElements.UQueryExtensions::Q(UnityEngine.UIElements.VisualElement,System.String,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* UQueryExtensions_Q_m625363964EA8275D50A9767F1E3468901C1B0BEC (VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___e0, String_t* ___name1, String_t* ___className2, const RuntimeMethod* method) ;
// UnityEngine.UIElements.UQueryState`1<T> UnityEngine.UIElements.UQueryState`1<UnityEngine.UIElements.VisualElement>::RebuildOn(UnityEngine.UIElements.VisualElement)
inline UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA UQueryState_1_RebuildOn_m6A44E1618AB0FD0EDCBEEF093B74FDEA03723004 (UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___element0, const RuntimeMethod* method)
{
return (( UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA (*) (UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA*, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115*, const RuntimeMethod*))UQueryState_1_RebuildOn_mF29E43348045B1219A757EBBF43C892C32EEA5DC_gshared)(__this, ___element0, method);
}
// T System.Collections.Generic.List`1<UnityEngine.UIElements.RuleMatcher>::get_Item(System.Int32)
inline RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68 (List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC* __this, int32_t ___index0, const RuntimeMethod* method)
{
return (( RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E (*) (List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC*, int32_t, const RuntimeMethod*))List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68_gshared)(__this, ___index0, method);
}
// UnityEngine.UIElements.StyleSelector[] UnityEngine.UIElements.StyleComplexSelector::get_selectors()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleSelectorU5BU5D_t11A633455FC601606B3DF3CEDDDAB1625B54708D* StyleComplexSelector_get_selectors_m54911D4E758E1A19A16E948D6D10BEB5795ADC02 (StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* __this, const RuntimeMethod* method) ;
// UnityEngine.UIElements.StyleSelectorPart[] UnityEngine.UIElements.StyleSelector::get_parts()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleSelectorPartU5BU5D_tBA574FB3E75E94E52874FDB7B05B9048E8A5421B* StyleSelector_get_parts_mE6EEAE6825862DDA89947B892B661A865D463CEF (StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362* __this, const RuntimeMethod* method) ;
// UnityEngine.UIElements.StyleSelectorPart UnityEngine.UIElements.StyleSelectorPart::CreatePredicate(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 StyleSelectorPart_CreatePredicate_mB47D568BDD71A75929CCF6BD1981FE0565687EDD (RuntimeObject* ___predicate0, const RuntimeMethod* method) ;
// T UnityEngine.UIElements.UQueryState`1<UnityEngine.UIElements.VisualElement>::First()
inline VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* UQueryState_1_First_m0E66C612BCBDFFA32D636D936B37CF56C0C2BA94 (UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA* __this, const RuntimeMethod* method)
{
return (( VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* (*) (UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA*, const RuntimeMethod*))UQueryState_1_First_m19FF1885E9D1D57D0EBA715820CA3C02C2C9C363_gshared)(__this, method);
}
// UnityEngine.UIElements.StyleSelectorPart UnityEngine.UIElements.StyleSelectorPart::CreateClass(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 StyleSelectorPart_CreateClass_m35749E6336C3E92EADB130D6BF196FD7AAB9F066 (String_t* ___className0, const RuntimeMethod* method) ;
// UnityEngine.UIElements.StyleSelectorPart UnityEngine.UIElements.StyleSelectorPart::CreateId(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 StyleSelectorPart_CreateId_m0D9ACD2EEC4D2CA1081B8158ED53F268840568E4 (String_t* ___Id0, const RuntimeMethod* method) ;
// System.IntPtr System.IntPtr::op_Explicit(System.Void*)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR intptr_t IntPtr_op_Explicit_m04BEF6277775C13DD8A986812AAA3FCEC32DCCBE (void* ___value0, const RuntimeMethod* method) ;
// System.Int32 Unity.Collections.NativeSlice`1<UnityEngine.UIElements.UIR.Transform3x4>::get_Length()
inline int32_t NativeSlice_1_get_Length_mC069C9254C3F61C678293E03E3E7C51F245F52E9_inline (NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370* __this, const RuntimeMethod* method)
{
return (( int32_t (*) (NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370*, const RuntimeMethod*))NativeSlice_1_get_Length_mC069C9254C3F61C678293E03E3E7C51F245F52E9_gshared_inline)(__this, method);
}
// System.Int32 Unity.Collections.NativeSlice`1<UnityEngine.UIElements.UIR.Transform3x4>::get_Stride()
inline int32_t NativeSlice_1_get_Stride_mE29B800705645CDD49B576BB3B9B328811F27C90_inline (NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370* __this, const RuntimeMethod* method)
{
return (( int32_t (*) (NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370*, const RuntimeMethod*))NativeSlice_1_get_Stride_mE29B800705645CDD49B576BB3B9B328811F27C90_gshared_inline)(__this, method);
}
// System.Void UnityEngine.UIElements.UIR.Utility::SetVectorArray(UnityEngine.MaterialPropertyBlock,System.Int32,System.IntPtr,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Utility_SetVectorArray_m6C8F08342C9D3D33A183B29536DA13B07E2763FA (MaterialPropertyBlock_t2308669579033A857EFE6E4831909F638B27411D* ___props0, int32_t ___name1, intptr_t ___vector4s2, int32_t ___count3, const RuntimeMethod* method) ;
// System.Int32 Unity.Collections.NativeSlice`1<UnityEngine.Vector4>::get_Length()
inline int32_t NativeSlice_1_get_Length_mED822A5A5476BEBA72E429C395644A7B41F78F50_inline (NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F* __this, const RuntimeMethod* method)
{
return (( int32_t (*) (NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F*, const RuntimeMethod*))NativeSlice_1_get_Length_mED822A5A5476BEBA72E429C395644A7B41F78F50_gshared_inline)(__this, method);
}
// System.Int32 Unity.Collections.NativeSlice`1<UnityEngine.Vector4>::get_Stride()
inline int32_t NativeSlice_1_get_Stride_m2BC6AD2264EE2D02A38D29E30D382DEA9B5A9E29_inline (NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F* __this, const RuntimeMethod* method)
{
return (( int32_t (*) (NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F*, const RuntimeMethod*))NativeSlice_1_get_Stride_m2BC6AD2264EE2D02A38D29E30D382DEA9B5A9E29_gshared_inline)(__this, method);
}
// System.Boolean UnityEngine.UIElements.UxmlAttributeDescription::TryGetValueFromBagAsString(UnityEngine.UIElements.IUxmlAttributes,UnityEngine.UIElements.CreationContext,System.String&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UxmlAttributeDescription_TryGetValueFromBagAsString_mF08874E8E58AD04C20041C076E2447E9AF57C9ED (UxmlAttributeDescription_t742D021489DB2B564142146CAAAC3F9191825EF2* __this, RuntimeObject* ___bag0, CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 ___cc1, String_t** ___value2, const RuntimeMethod* method) ;
// UnityEngine.UIElements.IVisualTreeUpdater UnityEngine.UIElements.VisualTreeUpdater/UpdaterArray::get_Item(UnityEngine.UIElements.VisualTreeUpdatePhase)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* UpdaterArray_get_Item_m6DADA11557BD3FE2E6680F3C1F6F828DB4EE255C (UpdaterArray_tF8D43D2A3598E7C17ABB5308E83FDECF1F36A449* __this, int32_t ___phase0, const RuntimeMethod* method) ;
// System.Void UnityEngine.UIElements.VisualTreeUpdater/UpdaterArray::set_Item(UnityEngine.UIElements.VisualTreeUpdatePhase,UnityEngine.UIElements.IVisualTreeUpdater)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UpdaterArray_set_Item_m2961BC09E3C22E6D3887BB8E48A367BAEF847A11 (UpdaterArray_tF8D43D2A3598E7C17ABB5308E83FDECF1F36A449* __this, int32_t ___phase0, RuntimeObject* ___value1, const RuntimeMethod* method) ;
// System.Int32 System.SpanHelpers::IndexOf<System.Object>(T&,T,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t SpanHelpers_IndexOf_TisRuntimeObject_m9D3BF0167C10D932AB529D840AC14E953243EAFA_gshared (RuntimeObject** ___searchSpace0, RuntimeObject* ___value1, int32_t ___length2, const RuntimeMethod* method)
{
intptr_t V_0;
memset((&V_0), 0, sizeof(V_0));
{
intptr_t L_0;
L_0 = IntPtr_op_Explicit_mB06D1B6CFBA72B5C55FBEC1BA3BC25958AB60EB1(0, NULL);
V_0 = L_0;
goto IL_0133;
}
IL_000c:
{
int32_t L_1 = ___length2;
___length2 = ((int32_t)il2cpp_codegen_subtract(L_1, 8));
RuntimeObject** L_2 = ___searchSpace0;
intptr_t L_3 = V_0;
RuntimeObject** L_4;
L_4 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_2, L_3, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_5 = (*(RuntimeObject**)L_4);
bool L_6;
L_6 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 2), (RuntimeObject*)(___value1), L_5);
if (L_6)
{
goto IL_0202;
}
}
{
RuntimeObject** L_7 = ___searchSpace0;
intptr_t L_8 = V_0;
intptr_t L_9;
L_9 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_8, 1, NULL);
RuntimeObject** L_10;
L_10 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_7, L_9, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_11 = (*(RuntimeObject**)L_10);
bool L_12;
L_12 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 2), (RuntimeObject*)(___value1), L_11);
if (L_12)
{
goto IL_020a;
}
}
{
RuntimeObject** L_13 = ___searchSpace0;
intptr_t L_14 = V_0;
intptr_t L_15;
L_15 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_14, 2, NULL);
RuntimeObject** L_16;
L_16 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_13, L_15, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_17 = (*(RuntimeObject**)L_16);
bool L_18;
L_18 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 2), (RuntimeObject*)(___value1), L_17);
if (L_18)
{
goto IL_0218;
}
}
{
RuntimeObject** L_19 = ___searchSpace0;
intptr_t L_20 = V_0;
intptr_t L_21;
L_21 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_20, 3, NULL);
RuntimeObject** L_22;
L_22 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_19, L_21, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_23 = (*(RuntimeObject**)L_22);
bool L_24;
L_24 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 2), (RuntimeObject*)(___value1), L_23);
if (L_24)
{
goto IL_0226;
}
}
{
RuntimeObject** L_25 = ___searchSpace0;
intptr_t L_26 = V_0;
intptr_t L_27;
L_27 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_26, 4, NULL);
RuntimeObject** L_28;
L_28 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_25, L_27, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_29 = (*(RuntimeObject**)L_28);
bool L_30;
L_30 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 2), (RuntimeObject*)(___value1), L_29);
if (L_30)
{
goto IL_0234;
}
}
{
RuntimeObject** L_31 = ___searchSpace0;
intptr_t L_32 = V_0;
intptr_t L_33;
L_33 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_32, 5, NULL);
RuntimeObject** L_34;
L_34 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_31, L_33, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_35 = (*(RuntimeObject**)L_34);
bool L_36;
L_36 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 2), (RuntimeObject*)(___value1), L_35);
if (L_36)
{
goto IL_0242;
}
}
{
RuntimeObject** L_37 = ___searchSpace0;
intptr_t L_38 = V_0;
intptr_t L_39;
L_39 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_38, 6, NULL);
RuntimeObject** L_40;
L_40 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_37, L_39, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_41 = (*(RuntimeObject**)L_40);
bool L_42;
L_42 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 2), (RuntimeObject*)(___value1), L_41);
if (L_42)
{
goto IL_0250;
}
}
{
RuntimeObject** L_43 = ___searchSpace0;
intptr_t L_44 = V_0;
intptr_t L_45;
L_45 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_44, 7, NULL);
RuntimeObject** L_46;
L_46 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_43, L_45, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_47 = (*(RuntimeObject**)L_46);
bool L_48;
L_48 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 2), (RuntimeObject*)(___value1), L_47);
if (L_48)
{
goto IL_025e;
}
}
{
intptr_t L_49 = V_0;
intptr_t L_50;
L_50 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_49, 8, NULL);
V_0 = L_50;
}
IL_0133:
{
int32_t L_51 = ___length2;
if ((((int32_t)L_51) >= ((int32_t)8)))
{
goto IL_000c;
}
}
{
int32_t L_52 = ___length2;
if ((((int32_t)L_52) < ((int32_t)4)))
{
goto IL_01fc;
}
}
{
int32_t L_53 = ___length2;
___length2 = ((int32_t)il2cpp_codegen_subtract(L_53, 4));
RuntimeObject** L_54 = ___searchSpace0;
intptr_t L_55 = V_0;
RuntimeObject** L_56;
L_56 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_54, L_55, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_57 = (*(RuntimeObject**)L_56);
bool L_58;
L_58 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 2), (RuntimeObject*)(___value1), L_57);
if (L_58)
{
goto IL_0202;
}
}
{
RuntimeObject** L_59 = ___searchSpace0;
intptr_t L_60 = V_0;
intptr_t L_61;
L_61 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_60, 1, NULL);
RuntimeObject** L_62;
L_62 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_59, L_61, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_63 = (*(RuntimeObject**)L_62);
bool L_64;
L_64 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 2), (RuntimeObject*)(___value1), L_63);
if (L_64)
{
goto IL_020a;
}
}
{
RuntimeObject** L_65 = ___searchSpace0;
intptr_t L_66 = V_0;
intptr_t L_67;
L_67 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_66, 2, NULL);
RuntimeObject** L_68;
L_68 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_65, L_67, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_69 = (*(RuntimeObject**)L_68);
bool L_70;
L_70 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 2), (RuntimeObject*)(___value1), L_69);
if (L_70)
{
goto IL_0218;
}
}
{
RuntimeObject** L_71 = ___searchSpace0;
intptr_t L_72 = V_0;
intptr_t L_73;
L_73 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_72, 3, NULL);
RuntimeObject** L_74;
L_74 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_71, L_73, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_75 = (*(RuntimeObject**)L_74);
bool L_76;
L_76 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 2), (RuntimeObject*)(___value1), L_75);
if (L_76)
{
goto IL_0226;
}
}
{
intptr_t L_77 = V_0;
intptr_t L_78;
L_78 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_77, 4, NULL);
V_0 = L_78;
goto IL_01fc;
}
IL_01d4:
{
RuntimeObject** L_79 = ___searchSpace0;
intptr_t L_80 = V_0;
RuntimeObject** L_81;
L_81 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_79, L_80, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_82 = (*(RuntimeObject**)L_81);
bool L_83;
L_83 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 2), (RuntimeObject*)(___value1), L_82);
if (L_83)
{
goto IL_0202;
}
}
{
intptr_t L_84 = V_0;
intptr_t L_85;
L_85 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_84, 1, NULL);
V_0 = L_85;
int32_t L_86 = ___length2;
___length2 = ((int32_t)il2cpp_codegen_subtract(L_86, 1));
}
IL_01fc:
{
int32_t L_87 = ___length2;
if ((((int32_t)L_87) > ((int32_t)0)))
{
goto IL_01d4;
}
}
{
return (-1);
}
IL_0202:
{
intptr_t L_88 = V_0;
void* L_89;
L_89 = IntPtr_op_Explicit_m693F2F9E685EE117D4AC080342B8959DAF684294(L_88, NULL);
return ((int32_t)(intptr_t)L_89);
}
IL_020a:
{
intptr_t L_90 = V_0;
intptr_t L_91;
L_91 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_90, 1, NULL);
void* L_92;
L_92 = IntPtr_op_Explicit_m693F2F9E685EE117D4AC080342B8959DAF684294(L_91, NULL);
return ((int32_t)(intptr_t)L_92);
}
IL_0218:
{
intptr_t L_93 = V_0;
intptr_t L_94;
L_94 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_93, 2, NULL);
void* L_95;
L_95 = IntPtr_op_Explicit_m693F2F9E685EE117D4AC080342B8959DAF684294(L_94, NULL);
return ((int32_t)(intptr_t)L_95);
}
IL_0226:
{
intptr_t L_96 = V_0;
intptr_t L_97;
L_97 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_96, 3, NULL);
void* L_98;
L_98 = IntPtr_op_Explicit_m693F2F9E685EE117D4AC080342B8959DAF684294(L_97, NULL);
return ((int32_t)(intptr_t)L_98);
}
IL_0234:
{
intptr_t L_99 = V_0;
intptr_t L_100;
L_100 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_99, 4, NULL);
void* L_101;
L_101 = IntPtr_op_Explicit_m693F2F9E685EE117D4AC080342B8959DAF684294(L_100, NULL);
return ((int32_t)(intptr_t)L_101);
}
IL_0242:
{
intptr_t L_102 = V_0;
intptr_t L_103;
L_103 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_102, 5, NULL);
void* L_104;
L_104 = IntPtr_op_Explicit_m693F2F9E685EE117D4AC080342B8959DAF684294(L_103, NULL);
return ((int32_t)(intptr_t)L_104);
}
IL_0250:
{
intptr_t L_105 = V_0;
intptr_t L_106;
L_106 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_105, 6, NULL);
void* L_107;
L_107 = IntPtr_op_Explicit_m693F2F9E685EE117D4AC080342B8959DAF684294(L_106, NULL);
return ((int32_t)(intptr_t)L_107);
}
IL_025e:
{
intptr_t L_108 = V_0;
intptr_t L_109;
L_109 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_108, 7, NULL);
void* L_110;
L_110 = IntPtr_op_Explicit_m693F2F9E685EE117D4AC080342B8959DAF684294(L_109, NULL);
return ((int32_t)(intptr_t)L_110);
}
}
// System.Boolean System.SpanHelpers::SequenceEqual<System.Char>(T&,T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool SpanHelpers_SequenceEqual_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_mC5F508F4FBF6832CC2DF1F8D4A3803C757817B41_gshared (Il2CppChar* ___first0, Il2CppChar* ___second1, int32_t ___length2, const RuntimeMethod* method)
{
intptr_t V_0;
memset((&V_0), 0, sizeof(V_0));
{
Il2CppChar* L_0 = ___first0;
Il2CppChar* L_1 = ___second1;
bool L_2;
L_2 = (( bool (*) (Il2CppChar*, Il2CppChar*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_0, L_1, il2cpp_rgctx_method(method->rgctx_data, 0));
if (L_2)
{
goto IL_0289;
}
}
{
intptr_t L_3;
L_3 = IntPtr_op_Explicit_mB06D1B6CFBA72B5C55FBEC1BA3BC25958AB60EB1(0, NULL);
V_0 = L_3;
goto IL_0191;
}
IL_0018:
{
int32_t L_4 = ___length2;
___length2 = ((int32_t)il2cpp_codegen_subtract(L_4, 8));
Il2CppChar* L_5 = ___first0;
intptr_t L_6 = V_0;
Il2CppChar* L_7;
L_7 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_5, L_6, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar* L_8 = ___second1;
intptr_t L_9 = V_0;
Il2CppChar* L_10;
L_10 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_8, L_9, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar L_11 = (*(Il2CppChar*)L_10);
bool L_12;
L_12 = Char_Equals_mEA7BFB45790C973DF6352091FA924B3FB2EFCE4B(L_7, L_11, il2cpp_rgctx_method(method->rgctx_data, 4));
if (!L_12)
{
goto IL_028b;
}
}
{
Il2CppChar* L_13 = ___first0;
intptr_t L_14 = V_0;
intptr_t L_15;
L_15 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_14, 1, NULL);
Il2CppChar* L_16;
L_16 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_13, L_15, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar* L_17 = ___second1;
intptr_t L_18 = V_0;
intptr_t L_19;
L_19 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_18, 1, NULL);
Il2CppChar* L_20;
L_20 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_17, L_19, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar L_21 = (*(Il2CppChar*)L_20);
bool L_22;
L_22 = Char_Equals_mEA7BFB45790C973DF6352091FA924B3FB2EFCE4B(L_16, L_21, il2cpp_rgctx_method(method->rgctx_data, 4));
if (!L_22)
{
goto IL_028b;
}
}
{
Il2CppChar* L_23 = ___first0;
intptr_t L_24 = V_0;
intptr_t L_25;
L_25 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_24, 2, NULL);
Il2CppChar* L_26;
L_26 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_23, L_25, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar* L_27 = ___second1;
intptr_t L_28 = V_0;
intptr_t L_29;
L_29 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_28, 2, NULL);
Il2CppChar* L_30;
L_30 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_27, L_29, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar L_31 = (*(Il2CppChar*)L_30);
bool L_32;
L_32 = Char_Equals_mEA7BFB45790C973DF6352091FA924B3FB2EFCE4B(L_26, L_31, il2cpp_rgctx_method(method->rgctx_data, 4));
if (!L_32)
{
goto IL_028b;
}
}
{
Il2CppChar* L_33 = ___first0;
intptr_t L_34 = V_0;
intptr_t L_35;
L_35 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_34, 3, NULL);
Il2CppChar* L_36;
L_36 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_33, L_35, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar* L_37 = ___second1;
intptr_t L_38 = V_0;
intptr_t L_39;
L_39 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_38, 3, NULL);
Il2CppChar* L_40;
L_40 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_37, L_39, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar L_41 = (*(Il2CppChar*)L_40);
bool L_42;
L_42 = Char_Equals_mEA7BFB45790C973DF6352091FA924B3FB2EFCE4B(L_36, L_41, il2cpp_rgctx_method(method->rgctx_data, 4));
if (!L_42)
{
goto IL_028b;
}
}
{
Il2CppChar* L_43 = ___first0;
intptr_t L_44 = V_0;
intptr_t L_45;
L_45 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_44, 4, NULL);
Il2CppChar* L_46;
L_46 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_43, L_45, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar* L_47 = ___second1;
intptr_t L_48 = V_0;
intptr_t L_49;
L_49 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_48, 4, NULL);
Il2CppChar* L_50;
L_50 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_47, L_49, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar L_51 = (*(Il2CppChar*)L_50);
bool L_52;
L_52 = Char_Equals_mEA7BFB45790C973DF6352091FA924B3FB2EFCE4B(L_46, L_51, il2cpp_rgctx_method(method->rgctx_data, 4));
if (!L_52)
{
goto IL_028b;
}
}
{
Il2CppChar* L_53 = ___first0;
intptr_t L_54 = V_0;
intptr_t L_55;
L_55 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_54, 5, NULL);
Il2CppChar* L_56;
L_56 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_53, L_55, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar* L_57 = ___second1;
intptr_t L_58 = V_0;
intptr_t L_59;
L_59 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_58, 5, NULL);
Il2CppChar* L_60;
L_60 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_57, L_59, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar L_61 = (*(Il2CppChar*)L_60);
bool L_62;
L_62 = Char_Equals_mEA7BFB45790C973DF6352091FA924B3FB2EFCE4B(L_56, L_61, il2cpp_rgctx_method(method->rgctx_data, 4));
if (!L_62)
{
goto IL_028b;
}
}
{
Il2CppChar* L_63 = ___first0;
intptr_t L_64 = V_0;
intptr_t L_65;
L_65 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_64, 6, NULL);
Il2CppChar* L_66;
L_66 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_63, L_65, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar* L_67 = ___second1;
intptr_t L_68 = V_0;
intptr_t L_69;
L_69 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_68, 6, NULL);
Il2CppChar* L_70;
L_70 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_67, L_69, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar L_71 = (*(Il2CppChar*)L_70);
bool L_72;
L_72 = Char_Equals_mEA7BFB45790C973DF6352091FA924B3FB2EFCE4B(L_66, L_71, il2cpp_rgctx_method(method->rgctx_data, 4));
if (!L_72)
{
goto IL_028b;
}
}
{
Il2CppChar* L_73 = ___first0;
intptr_t L_74 = V_0;
intptr_t L_75;
L_75 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_74, 7, NULL);
Il2CppChar* L_76;
L_76 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_73, L_75, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar* L_77 = ___second1;
intptr_t L_78 = V_0;
intptr_t L_79;
L_79 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_78, 7, NULL);
Il2CppChar* L_80;
L_80 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_77, L_79, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar L_81 = (*(Il2CppChar*)L_80);
bool L_82;
L_82 = Char_Equals_mEA7BFB45790C973DF6352091FA924B3FB2EFCE4B(L_76, L_81, il2cpp_rgctx_method(method->rgctx_data, 4));
if (!L_82)
{
goto IL_028b;
}
}
{
intptr_t L_83 = V_0;
intptr_t L_84;
L_84 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_83, 8, NULL);
V_0 = L_84;
}
IL_0191:
{
int32_t L_85 = ___length2;
if ((((int32_t)L_85) >= ((int32_t)8)))
{
goto IL_0018;
}
}
{
int32_t L_86 = ___length2;
if ((((int32_t)L_86) < ((int32_t)4)))
{
goto IL_0285;
}
}
{
int32_t L_87 = ___length2;
___length2 = ((int32_t)il2cpp_codegen_subtract(L_87, 4));
Il2CppChar* L_88 = ___first0;
intptr_t L_89 = V_0;
Il2CppChar* L_90;
L_90 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_88, L_89, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar* L_91 = ___second1;
intptr_t L_92 = V_0;
Il2CppChar* L_93;
L_93 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_91, L_92, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar L_94 = (*(Il2CppChar*)L_93);
bool L_95;
L_95 = Char_Equals_mEA7BFB45790C973DF6352091FA924B3FB2EFCE4B(L_90, L_94, il2cpp_rgctx_method(method->rgctx_data, 4));
if (!L_95)
{
goto IL_028b;
}
}
{
Il2CppChar* L_96 = ___first0;
intptr_t L_97 = V_0;
intptr_t L_98;
L_98 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_97, 1, NULL);
Il2CppChar* L_99;
L_99 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_96, L_98, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar* L_100 = ___second1;
intptr_t L_101 = V_0;
intptr_t L_102;
L_102 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_101, 1, NULL);
Il2CppChar* L_103;
L_103 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_100, L_102, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar L_104 = (*(Il2CppChar*)L_103);
bool L_105;
L_105 = Char_Equals_mEA7BFB45790C973DF6352091FA924B3FB2EFCE4B(L_99, L_104, il2cpp_rgctx_method(method->rgctx_data, 4));
if (!L_105)
{
goto IL_028b;
}
}
{
Il2CppChar* L_106 = ___first0;
intptr_t L_107 = V_0;
intptr_t L_108;
L_108 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_107, 2, NULL);
Il2CppChar* L_109;
L_109 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_106, L_108, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar* L_110 = ___second1;
intptr_t L_111 = V_0;
intptr_t L_112;
L_112 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_111, 2, NULL);
Il2CppChar* L_113;
L_113 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_110, L_112, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar L_114 = (*(Il2CppChar*)L_113);
bool L_115;
L_115 = Char_Equals_mEA7BFB45790C973DF6352091FA924B3FB2EFCE4B(L_109, L_114, il2cpp_rgctx_method(method->rgctx_data, 4));
if (!L_115)
{
goto IL_028b;
}
}
{
Il2CppChar* L_116 = ___first0;
intptr_t L_117 = V_0;
intptr_t L_118;
L_118 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_117, 3, NULL);
Il2CppChar* L_119;
L_119 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_116, L_118, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar* L_120 = ___second1;
intptr_t L_121 = V_0;
intptr_t L_122;
L_122 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_121, 3, NULL);
Il2CppChar* L_123;
L_123 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_120, L_122, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar L_124 = (*(Il2CppChar*)L_123);
bool L_125;
L_125 = Char_Equals_mEA7BFB45790C973DF6352091FA924B3FB2EFCE4B(L_119, L_124, il2cpp_rgctx_method(method->rgctx_data, 4));
if (!L_125)
{
goto IL_028b;
}
}
{
intptr_t L_126 = V_0;
intptr_t L_127;
L_127 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_126, 4, NULL);
V_0 = L_127;
goto IL_0285;
}
IL_0258:
{
Il2CppChar* L_128 = ___first0;
intptr_t L_129 = V_0;
Il2CppChar* L_130;
L_130 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_128, L_129, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar* L_131 = ___second1;
intptr_t L_132 = V_0;
Il2CppChar* L_133;
L_133 = (( Il2CppChar* (*) (Il2CppChar*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_131, L_132, il2cpp_rgctx_method(method->rgctx_data, 1));
Il2CppChar L_134 = (*(Il2CppChar*)L_133);
bool L_135;
L_135 = Char_Equals_mEA7BFB45790C973DF6352091FA924B3FB2EFCE4B(L_130, L_134, il2cpp_rgctx_method(method->rgctx_data, 4));
if (!L_135)
{
goto IL_028b;
}
}
{
intptr_t L_136 = V_0;
intptr_t L_137;
L_137 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_136, 1, NULL);
V_0 = L_137;
int32_t L_138 = ___length2;
___length2 = ((int32_t)il2cpp_codegen_subtract(L_138, 1));
}
IL_0285:
{
int32_t L_139 = ___length2;
if ((((int32_t)L_139) > ((int32_t)0)))
{
goto IL_0258;
}
}
IL_0289:
{
return (bool)1;
}
IL_028b:
{
return (bool)0;
}
}
// System.Boolean System.SpanHelpers::SequenceEqual<System.Object>(T&,T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool SpanHelpers_SequenceEqual_TisRuntimeObject_m07C45A815A79B26EE1674D4E916ED15AE30E23D5_gshared (RuntimeObject** ___first0, RuntimeObject** ___second1, int32_t ___length2, const RuntimeMethod* method)
{
intptr_t V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject** L_0 = ___first0;
RuntimeObject** L_1 = ___second1;
bool L_2;
L_2 = (( bool (*) (RuntimeObject**, RuntimeObject**, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_0, L_1, il2cpp_rgctx_method(method->rgctx_data, 0));
if (L_2)
{
goto IL_0289;
}
}
{
intptr_t L_3;
L_3 = IntPtr_op_Explicit_mB06D1B6CFBA72B5C55FBEC1BA3BC25958AB60EB1(0, NULL);
V_0 = L_3;
goto IL_0191;
}
IL_0018:
{
int32_t L_4 = ___length2;
___length2 = ((int32_t)il2cpp_codegen_subtract(L_4, 8));
RuntimeObject** L_5 = ___first0;
intptr_t L_6 = V_0;
RuntimeObject** L_7;
L_7 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_5, L_6, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject** L_8 = ___second1;
intptr_t L_9 = V_0;
RuntimeObject** L_10;
L_10 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_8, L_9, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject* L_11 = (*(RuntimeObject**)L_10);
bool L_12;
L_12 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 3), (RuntimeObject*)(*L_7), L_11);
if (!L_12)
{
goto IL_028b;
}
}
{
RuntimeObject** L_13 = ___first0;
intptr_t L_14 = V_0;
intptr_t L_15;
L_15 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_14, 1, NULL);
RuntimeObject** L_16;
L_16 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_13, L_15, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject** L_17 = ___second1;
intptr_t L_18 = V_0;
intptr_t L_19;
L_19 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_18, 1, NULL);
RuntimeObject** L_20;
L_20 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_17, L_19, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject* L_21 = (*(RuntimeObject**)L_20);
bool L_22;
L_22 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 3), (RuntimeObject*)(*L_16), L_21);
if (!L_22)
{
goto IL_028b;
}
}
{
RuntimeObject** L_23 = ___first0;
intptr_t L_24 = V_0;
intptr_t L_25;
L_25 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_24, 2, NULL);
RuntimeObject** L_26;
L_26 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_23, L_25, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject** L_27 = ___second1;
intptr_t L_28 = V_0;
intptr_t L_29;
L_29 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_28, 2, NULL);
RuntimeObject** L_30;
L_30 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_27, L_29, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject* L_31 = (*(RuntimeObject**)L_30);
bool L_32;
L_32 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 3), (RuntimeObject*)(*L_26), L_31);
if (!L_32)
{
goto IL_028b;
}
}
{
RuntimeObject** L_33 = ___first0;
intptr_t L_34 = V_0;
intptr_t L_35;
L_35 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_34, 3, NULL);
RuntimeObject** L_36;
L_36 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_33, L_35, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject** L_37 = ___second1;
intptr_t L_38 = V_0;
intptr_t L_39;
L_39 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_38, 3, NULL);
RuntimeObject** L_40;
L_40 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_37, L_39, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject* L_41 = (*(RuntimeObject**)L_40);
bool L_42;
L_42 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 3), (RuntimeObject*)(*L_36), L_41);
if (!L_42)
{
goto IL_028b;
}
}
{
RuntimeObject** L_43 = ___first0;
intptr_t L_44 = V_0;
intptr_t L_45;
L_45 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_44, 4, NULL);
RuntimeObject** L_46;
L_46 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_43, L_45, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject** L_47 = ___second1;
intptr_t L_48 = V_0;
intptr_t L_49;
L_49 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_48, 4, NULL);
RuntimeObject** L_50;
L_50 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_47, L_49, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject* L_51 = (*(RuntimeObject**)L_50);
bool L_52;
L_52 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 3), (RuntimeObject*)(*L_46), L_51);
if (!L_52)
{
goto IL_028b;
}
}
{
RuntimeObject** L_53 = ___first0;
intptr_t L_54 = V_0;
intptr_t L_55;
L_55 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_54, 5, NULL);
RuntimeObject** L_56;
L_56 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_53, L_55, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject** L_57 = ___second1;
intptr_t L_58 = V_0;
intptr_t L_59;
L_59 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_58, 5, NULL);
RuntimeObject** L_60;
L_60 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_57, L_59, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject* L_61 = (*(RuntimeObject**)L_60);
bool L_62;
L_62 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 3), (RuntimeObject*)(*L_56), L_61);
if (!L_62)
{
goto IL_028b;
}
}
{
RuntimeObject** L_63 = ___first0;
intptr_t L_64 = V_0;
intptr_t L_65;
L_65 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_64, 6, NULL);
RuntimeObject** L_66;
L_66 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_63, L_65, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject** L_67 = ___second1;
intptr_t L_68 = V_0;
intptr_t L_69;
L_69 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_68, 6, NULL);
RuntimeObject** L_70;
L_70 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_67, L_69, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject* L_71 = (*(RuntimeObject**)L_70);
bool L_72;
L_72 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 3), (RuntimeObject*)(*L_66), L_71);
if (!L_72)
{
goto IL_028b;
}
}
{
RuntimeObject** L_73 = ___first0;
intptr_t L_74 = V_0;
intptr_t L_75;
L_75 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_74, 7, NULL);
RuntimeObject** L_76;
L_76 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_73, L_75, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject** L_77 = ___second1;
intptr_t L_78 = V_0;
intptr_t L_79;
L_79 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_78, 7, NULL);
RuntimeObject** L_80;
L_80 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_77, L_79, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject* L_81 = (*(RuntimeObject**)L_80);
bool L_82;
L_82 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 3), (RuntimeObject*)(*L_76), L_81);
if (!L_82)
{
goto IL_028b;
}
}
{
intptr_t L_83 = V_0;
intptr_t L_84;
L_84 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_83, 8, NULL);
V_0 = L_84;
}
IL_0191:
{
int32_t L_85 = ___length2;
if ((((int32_t)L_85) >= ((int32_t)8)))
{
goto IL_0018;
}
}
{
int32_t L_86 = ___length2;
if ((((int32_t)L_86) < ((int32_t)4)))
{
goto IL_0285;
}
}
{
int32_t L_87 = ___length2;
___length2 = ((int32_t)il2cpp_codegen_subtract(L_87, 4));
RuntimeObject** L_88 = ___first0;
intptr_t L_89 = V_0;
RuntimeObject** L_90;
L_90 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_88, L_89, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject** L_91 = ___second1;
intptr_t L_92 = V_0;
RuntimeObject** L_93;
L_93 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_91, L_92, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject* L_94 = (*(RuntimeObject**)L_93);
bool L_95;
L_95 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 3), (RuntimeObject*)(*L_90), L_94);
if (!L_95)
{
goto IL_028b;
}
}
{
RuntimeObject** L_96 = ___first0;
intptr_t L_97 = V_0;
intptr_t L_98;
L_98 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_97, 1, NULL);
RuntimeObject** L_99;
L_99 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_96, L_98, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject** L_100 = ___second1;
intptr_t L_101 = V_0;
intptr_t L_102;
L_102 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_101, 1, NULL);
RuntimeObject** L_103;
L_103 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_100, L_102, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject* L_104 = (*(RuntimeObject**)L_103);
bool L_105;
L_105 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 3), (RuntimeObject*)(*L_99), L_104);
if (!L_105)
{
goto IL_028b;
}
}
{
RuntimeObject** L_106 = ___first0;
intptr_t L_107 = V_0;
intptr_t L_108;
L_108 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_107, 2, NULL);
RuntimeObject** L_109;
L_109 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_106, L_108, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject** L_110 = ___second1;
intptr_t L_111 = V_0;
intptr_t L_112;
L_112 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_111, 2, NULL);
RuntimeObject** L_113;
L_113 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_110, L_112, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject* L_114 = (*(RuntimeObject**)L_113);
bool L_115;
L_115 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 3), (RuntimeObject*)(*L_109), L_114);
if (!L_115)
{
goto IL_028b;
}
}
{
RuntimeObject** L_116 = ___first0;
intptr_t L_117 = V_0;
intptr_t L_118;
L_118 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_117, 3, NULL);
RuntimeObject** L_119;
L_119 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_116, L_118, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject** L_120 = ___second1;
intptr_t L_121 = V_0;
intptr_t L_122;
L_122 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_121, 3, NULL);
RuntimeObject** L_123;
L_123 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_120, L_122, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject* L_124 = (*(RuntimeObject**)L_123);
bool L_125;
L_125 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 3), (RuntimeObject*)(*L_119), L_124);
if (!L_125)
{
goto IL_028b;
}
}
{
intptr_t L_126 = V_0;
intptr_t L_127;
L_127 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_126, 4, NULL);
V_0 = L_127;
goto IL_0285;
}
IL_0258:
{
RuntimeObject** L_128 = ___first0;
intptr_t L_129 = V_0;
RuntimeObject** L_130;
L_130 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_128, L_129, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject** L_131 = ___second1;
intptr_t L_132 = V_0;
RuntimeObject** L_133;
L_133 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_131, L_132, il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject* L_134 = (*(RuntimeObject**)L_133);
bool L_135;
L_135 = InterfaceFuncInvoker1< bool, RuntimeObject* >::Invoke(0 /* System.Boolean System.IEquatable`1<System.Object>::Equals(T) */, il2cpp_rgctx_data(method->rgctx_data, 3), (RuntimeObject*)(*L_130), L_134);
if (!L_135)
{
goto IL_028b;
}
}
{
intptr_t L_136 = V_0;
intptr_t L_137;
L_137 = IntPtr_op_Addition_mC0EBEFD80883C26CF2FE4BFD7DEDECAD61480CFE(L_136, 1, NULL);
V_0 = L_137;
int32_t L_138 = ___length2;
___length2 = ((int32_t)il2cpp_codegen_subtract(L_138, 1));
}
IL_0285:
{
int32_t L_139 = ___length2;
if ((((int32_t)L_139) > ((int32_t)0)))
{
goto IL_0258;
}
}
IL_0289:
{
return (bool)1;
}
IL_028b:
{
return (bool)0;
}
}
// System.String System.String::Create<System.ValueTuple`3<System.Object,System.Int32,System.Int32>>(System.Int32,TState,System.Buffers.SpanAction`2<System.Char,TState>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Create_TisValueTuple_3_tFD2ADB3DA89E958885034AAFEF1ABDA8C814D987_m5E409288A7637C431B8D0248F411CC1378386DE4_gshared (int32_t ___length0, ValueTuple_3_tFD2ADB3DA89E958885034AAFEF1ABDA8C814D987 ___state1, SpanAction_2_t65B015FEFE1F64814AC2EFA0E19A38B1CFC53178* ___action2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Span_1__ctor_mC9BE2938B716B46BB6B9070B94DBE5CE814BC0E2_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
{
SpanAction_2_t65B015FEFE1F64814AC2EFA0E19A38B1CFC53178* L_0 = ___action2;
if (L_0)
{
goto IL_000e;
}
}
{
ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129* L_1 = (ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129*)il2cpp_codegen_object_new(((RuntimeClass*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129_il2cpp_TypeInfo_var)));
ArgumentNullException__ctor_m444AE141157E333844FC1A9500224C2F9FD24F4B(L_1, ((String_t*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&_stringLiteralF9010398F7F524C05AB19445BDCE02E617A3E267)), NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&String_Create_TisValueTuple_3_tFD2ADB3DA89E958885034AAFEF1ABDA8C814D987_m5E409288A7637C431B8D0248F411CC1378386DE4_RuntimeMethod_var)));
}
IL_000e:
{
int32_t L_2 = ___length0;
if ((((int32_t)L_2) > ((int32_t)0)))
{
goto IL_0026;
}
}
{
int32_t L_3 = ___length0;
if (L_3)
{
goto IL_001b;
}
}
{
String_t* L_4 = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->___Empty_6;
return L_4;
}
IL_001b:
{
ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F* L_5 = (ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F*)il2cpp_codegen_object_new(((RuntimeClass*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F_il2cpp_TypeInfo_var)));
ArgumentOutOfRangeException__ctor_mBC1D5DEEA1BA41DE77228CB27D6BAFEB6DCCBF4A(L_5, ((String_t*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&_stringLiteralE8744A8B8BD390EB66CA0CAE2376C973E6904FFB)), NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_5, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&String_Create_TisValueTuple_3_tFD2ADB3DA89E958885034AAFEF1ABDA8C814D987_m5E409288A7637C431B8D0248F411CC1378386DE4_RuntimeMethod_var)));
}
IL_0026:
{
int32_t L_6 = ___length0;
String_t* L_7;
L_7 = String_FastAllocateString_mF8E983B7ABC42CA6EB80C5052243D21E81CC2112(L_6, NULL);
V_0 = L_7;
SpanAction_2_t65B015FEFE1F64814AC2EFA0E19A38B1CFC53178* L_8 = ___action2;
String_t* L_9 = V_0;
Il2CppChar* L_10;
L_10 = String_GetRawStringData_m87BC50B7B314C055E27A28032D1003D42FDE411D(L_9, NULL);
int32_t L_11 = ___length0;
Span_1_tEDDF15FCF9EC6DEBA0F696BAACDDBAB9D92C252D L_12;
memset((&L_12), 0, sizeof(L_12));
Span_1__ctor_mC9BE2938B716B46BB6B9070B94DBE5CE814BC0E2_inline((&L_12), L_10, L_11, /*hidden argument*/Span_1__ctor_mC9BE2938B716B46BB6B9070B94DBE5CE814BC0E2_RuntimeMethod_var);
ValueTuple_3_tFD2ADB3DA89E958885034AAFEF1ABDA8C814D987 L_13 = ___state1;
(( void (*) (SpanAction_2_t65B015FEFE1F64814AC2EFA0E19A38B1CFC53178*, Span_1_tEDDF15FCF9EC6DEBA0F696BAACDDBAB9D92C252D, ValueTuple_3_tFD2ADB3DA89E958885034AAFEF1ABDA8C814D987, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_8, L_12, L_13, il2cpp_rgctx_method(method->rgctx_data, 1));
String_t* L_14 = V_0;
return L_14;
}
}
// System.String System.String::Create<System.ValueTuple`5<System.IntPtr,System.Int32,System.IntPtr,System.Int32,System.Boolean>>(System.Int32,TState,System.Buffers.SpanAction`2<System.Char,TState>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Create_TisValueTuple_5_t558B9F95CA55DE5694FC58A3BEAE441BF728FB57_mF676274E492719C5208121DF9AB97D732DEC1E06_gshared (int32_t ___length0, ValueTuple_5_t558B9F95CA55DE5694FC58A3BEAE441BF728FB57 ___state1, SpanAction_2_t84FDFFEECCC96A9A407DCB490E60340E38185947* ___action2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Span_1__ctor_mC9BE2938B716B46BB6B9070B94DBE5CE814BC0E2_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
{
SpanAction_2_t84FDFFEECCC96A9A407DCB490E60340E38185947* L_0 = ___action2;
if (L_0)
{
goto IL_000e;
}
}
{
ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129* L_1 = (ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129*)il2cpp_codegen_object_new(((RuntimeClass*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129_il2cpp_TypeInfo_var)));
ArgumentNullException__ctor_m444AE141157E333844FC1A9500224C2F9FD24F4B(L_1, ((String_t*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&_stringLiteralF9010398F7F524C05AB19445BDCE02E617A3E267)), NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&String_Create_TisValueTuple_5_t558B9F95CA55DE5694FC58A3BEAE441BF728FB57_mF676274E492719C5208121DF9AB97D732DEC1E06_RuntimeMethod_var)));
}
IL_000e:
{
int32_t L_2 = ___length0;
if ((((int32_t)L_2) > ((int32_t)0)))
{
goto IL_0026;
}
}
{
int32_t L_3 = ___length0;
if (L_3)
{
goto IL_001b;
}
}
{
String_t* L_4 = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->___Empty_6;
return L_4;
}
IL_001b:
{
ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F* L_5 = (ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F*)il2cpp_codegen_object_new(((RuntimeClass*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F_il2cpp_TypeInfo_var)));
ArgumentOutOfRangeException__ctor_mBC1D5DEEA1BA41DE77228CB27D6BAFEB6DCCBF4A(L_5, ((String_t*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&_stringLiteralE8744A8B8BD390EB66CA0CAE2376C973E6904FFB)), NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_5, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&String_Create_TisValueTuple_5_t558B9F95CA55DE5694FC58A3BEAE441BF728FB57_mF676274E492719C5208121DF9AB97D732DEC1E06_RuntimeMethod_var)));
}
IL_0026:
{
int32_t L_6 = ___length0;
String_t* L_7;
L_7 = String_FastAllocateString_mF8E983B7ABC42CA6EB80C5052243D21E81CC2112(L_6, NULL);
V_0 = L_7;
SpanAction_2_t84FDFFEECCC96A9A407DCB490E60340E38185947* L_8 = ___action2;
String_t* L_9 = V_0;
Il2CppChar* L_10;
L_10 = String_GetRawStringData_m87BC50B7B314C055E27A28032D1003D42FDE411D(L_9, NULL);
int32_t L_11 = ___length0;
Span_1_tEDDF15FCF9EC6DEBA0F696BAACDDBAB9D92C252D L_12;
memset((&L_12), 0, sizeof(L_12));
Span_1__ctor_mC9BE2938B716B46BB6B9070B94DBE5CE814BC0E2_inline((&L_12), L_10, L_11, /*hidden argument*/Span_1__ctor_mC9BE2938B716B46BB6B9070B94DBE5CE814BC0E2_RuntimeMethod_var);
ValueTuple_5_t558B9F95CA55DE5694FC58A3BEAE441BF728FB57 L_13 = ___state1;
(( void (*) (SpanAction_2_t84FDFFEECCC96A9A407DCB490E60340E38185947*, Span_1_tEDDF15FCF9EC6DEBA0F696BAACDDBAB9D92C252D, ValueTuple_5_t558B9F95CA55DE5694FC58A3BEAE441BF728FB57, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_8, L_12, L_13, il2cpp_rgctx_method(method->rgctx_data, 1));
String_t* L_14 = V_0;
return L_14;
}
}
// System.String System.String::Create<System.Object>(System.Int32,TState,System.Buffers.SpanAction`2<System.Char,TState>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* String_Create_TisRuntimeObject_m4B49E10375F1BE32439BE26CBBB4F960EDD45B05_gshared (int32_t ___length0, RuntimeObject* ___state1, SpanAction_2_t0CB19FBAD63F42C01432B842C5169FC10C1777E3* ___action2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Span_1__ctor_mC9BE2938B716B46BB6B9070B94DBE5CE814BC0E2_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&String_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
{
SpanAction_2_t0CB19FBAD63F42C01432B842C5169FC10C1777E3* L_0 = ___action2;
if (L_0)
{
goto IL_000e;
}
}
{
ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129* L_1 = (ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129*)il2cpp_codegen_object_new(((RuntimeClass*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129_il2cpp_TypeInfo_var)));
ArgumentNullException__ctor_m444AE141157E333844FC1A9500224C2F9FD24F4B(L_1, ((String_t*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&_stringLiteralF9010398F7F524C05AB19445BDCE02E617A3E267)), NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&String_Create_TisRuntimeObject_m4B49E10375F1BE32439BE26CBBB4F960EDD45B05_RuntimeMethod_var)));
}
IL_000e:
{
int32_t L_2 = ___length0;
if ((((int32_t)L_2) > ((int32_t)0)))
{
goto IL_0026;
}
}
{
int32_t L_3 = ___length0;
if (L_3)
{
goto IL_001b;
}
}
{
String_t* L_4 = ((String_t_StaticFields*)il2cpp_codegen_static_fields_for(String_t_il2cpp_TypeInfo_var))->___Empty_6;
return L_4;
}
IL_001b:
{
ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F* L_5 = (ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F*)il2cpp_codegen_object_new(((RuntimeClass*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F_il2cpp_TypeInfo_var)));
ArgumentOutOfRangeException__ctor_mBC1D5DEEA1BA41DE77228CB27D6BAFEB6DCCBF4A(L_5, ((String_t*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&_stringLiteralE8744A8B8BD390EB66CA0CAE2376C973E6904FFB)), NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_5, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&String_Create_TisRuntimeObject_m4B49E10375F1BE32439BE26CBBB4F960EDD45B05_RuntimeMethod_var)));
}
IL_0026:
{
int32_t L_6 = ___length0;
String_t* L_7;
L_7 = String_FastAllocateString_mF8E983B7ABC42CA6EB80C5052243D21E81CC2112(L_6, NULL);
V_0 = L_7;
SpanAction_2_t0CB19FBAD63F42C01432B842C5169FC10C1777E3* L_8 = ___action2;
String_t* L_9 = V_0;
Il2CppChar* L_10;
L_10 = String_GetRawStringData_m87BC50B7B314C055E27A28032D1003D42FDE411D(L_9, NULL);
int32_t L_11 = ___length0;
Span_1_tEDDF15FCF9EC6DEBA0F696BAACDDBAB9D92C252D L_12;
memset((&L_12), 0, sizeof(L_12));
Span_1__ctor_mC9BE2938B716B46BB6B9070B94DBE5CE814BC0E2_inline((&L_12), L_10, L_11, /*hidden argument*/Span_1__ctor_mC9BE2938B716B46BB6B9070B94DBE5CE814BC0E2_RuntimeMethod_var);
RuntimeObject* L_13 = ___state1;
(( void (*) (SpanAction_2_t0CB19FBAD63F42C01432B842C5169FC10C1777E3*, Span_1_tEDDF15FCF9EC6DEBA0F696BAACDDBAB9D92C252D, RuntimeObject*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_8, L_12, L_13, il2cpp_rgctx_method(method->rgctx_data, 1));
String_t* L_14 = V_0;
return L_14;
}
}
// System.Text.StringBuilder System.Text.StringBuilder::AppendSpanFormattable<System.Int32>(T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StringBuilder_t* StringBuilder_AppendSpanFormattable_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_m7B15D251663E1D9C147CD9DA1A8908CACF877570_gshared (StringBuilder_t* __this, int32_t ___value0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
{
il2cpp_codegen_runtime_class_init_inline(CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0_il2cpp_TypeInfo_var);
CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0* L_0;
L_0 = CultureInfo_get_CurrentCulture_m43D1E4E50AB1F62ADC7C1884F28F918B53871522(NULL);
String_t* L_1;
L_1 = Int32_ToString_mE871810BC163EE4EF88E7C7682A6AD39911173B8((&___value0), (String_t*)NULL, (RuntimeObject*)L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
StringBuilder_t* L_2;
L_2 = StringBuilder_Append_m08904D74E0C78E5F36DCD9C9303BDD07886D9F7D(__this, L_1, NULL);
return L_2;
}
}
// System.Text.StringBuilder System.Text.StringBuilder::AppendSpanFormattable<System.Object>(T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StringBuilder_t* StringBuilder_AppendSpanFormattable_TisRuntimeObject_mD51222AF7DE1F3198B5D7E15D990729A113B39E7_gshared (StringBuilder_t* __this, RuntimeObject* ___value0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&IFormattable_t235A539BD9771E1E118DB99384BA8385D2F971CA_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
{
il2cpp_codegen_runtime_class_init_inline(CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0_il2cpp_TypeInfo_var);
CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0* L_0;
L_0 = CultureInfo_get_CurrentCulture_m43D1E4E50AB1F62ADC7C1884F28F918B53871522(NULL);
String_t* L_1;
L_1 = InterfaceFuncInvoker2< String_t*, String_t*, RuntimeObject* >::Invoke(0 /* System.String System.IFormattable::ToString(System.String,System.IFormatProvider) */, IFormattable_t235A539BD9771E1E118DB99384BA8385D2F971CA_il2cpp_TypeInfo_var, (RuntimeObject*)(___value0), (String_t*)NULL, (RuntimeObject*)L_0);
StringBuilder_t* L_2;
L_2 = StringBuilder_Append_m08904D74E0C78E5F36DCD9C9303BDD07886D9F7D(__this, L_1, NULL);
return L_2;
}
}
// System.Text.StringBuilder System.Text.StringBuilder::AppendSpanFormattable<System.UInt32>(T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StringBuilder_t* StringBuilder_AppendSpanFormattable_TisUInt32_t1833D51FFA667B18A5AA4B8D34DE284F8495D29B_m61F274B553164EF6FB0CB7D16AED9687CE7CA5FC_gshared (StringBuilder_t* __this, uint32_t ___value0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
{
il2cpp_codegen_runtime_class_init_inline(CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0_il2cpp_TypeInfo_var);
CultureInfo_t9BA817D41AD55AC8BD07480DD8AC22F8FFA378E0* L_0;
L_0 = CultureInfo_get_CurrentCulture_m43D1E4E50AB1F62ADC7C1884F28F918B53871522(NULL);
String_t* L_1;
L_1 = UInt32_ToString_m464396B0FE2115F3CEA38AEECDDB0FACC3AADADE((&___value0), (String_t*)NULL, (RuntimeObject*)L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
StringBuilder_t* L_2;
L_2 = StringBuilder_Append_m08904D74E0C78E5F36DCD9C9303BDD07886D9F7D(__this, L_1, NULL);
return L_2;
}
}
// T UnityEngine.UIElements.StylePropertyAnimationSystem::GetOrCreate<System.Object>(T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* StylePropertyAnimationSystem_GetOrCreate_TisRuntimeObject_m2AE01111C79CB41221F9DBF2E5DB3A5AA22BA2CB_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, RuntimeObject** ___values0, const RuntimeMethod* method)
{
RuntimeObject* V_0 = NULL;
RuntimeObject* V_1 = NULL;
RuntimeObject* V_2 = NULL;
RuntimeObject* G_B3_0 = NULL;
{
RuntimeObject** L_0 = ___values0;
RuntimeObject* L_1 = (*(RuntimeObject**)L_0);
V_0 = L_1;
RuntimeObject* L_2 = V_0;
if (L_2)
{
goto IL_0020;
}
}
{
RuntimeObject** L_3 = ___values0;
RuntimeObject* L_4;
L_4 = (( RuntimeObject* (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
RuntimeObject* L_5 = L_4;
V_1 = L_5;
*(RuntimeObject**)L_3 = L_5;
Il2CppCodeGenWriteBarrier((void**)(RuntimeObject**)L_3, (void*)L_5);
RuntimeObject* L_6 = V_1;
G_B3_0 = L_6;
goto IL_0021;
}
IL_0020:
{
RuntimeObject* L_7 = V_0;
G_B3_0 = L_7;
}
IL_0021:
{
V_2 = G_B3_0;
goto IL_0024;
}
IL_0024:
{
RuntimeObject* L_8 = V_2;
return L_8;
}
}
// System.Boolean UnityEngine.UIElements.StylePropertyAnimationSystem::StartTransition<UnityEngine.UIElements.Background>(UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.StyleSheets.StylePropertyId,T,T,System.Int32,System.Int32,System.Func`2<System.Single,System.Single>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StylePropertyAnimationSystem_StartTransition_TisBackground_t3C720DED4FAF016332D29FB86C9BE8D5D0D8F0C8_m4681675678ACD0B638F1DE5B61E1FB551007A685_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___owner0, int32_t ___prop1, Background_t3C720DED4FAF016332D29FB86C9BE8D5D0D8F0C8 ___startValue2, Background_t3C720DED4FAF016332D29FB86C9BE8D5D0D8F0C8 ___endValue3, int32_t ___durationMs4, int32_t ___delayMs5, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___easingCurve6, Values_1_t19A1E2B4752BCDF06B5D68597FF7E74704C6F99F* ___values7, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
{
Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* L_0 = (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7*)__this->___m_PropertyToValues_15;
int32_t L_1 = ___prop1;
Values_1_t19A1E2B4752BCDF06B5D68597FF7E74704C6F99F* L_2 = ___values7;
Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273(L_0, L_1, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_2, Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
Values_1_t19A1E2B4752BCDF06B5D68597FF7E74704C6F99F* L_3 = ___values7;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_4 = ___owner0;
int32_t L_5 = ___prop1;
Background_t3C720DED4FAF016332D29FB86C9BE8D5D0D8F0C8 L_6 = ___startValue2;
Background_t3C720DED4FAF016332D29FB86C9BE8D5D0D8F0C8 L_7 = ___endValue3;
int32_t L_8 = ___durationMs4;
int32_t L_9 = ___delayMs5;
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* L_10 = ___easingCurve6;
int64_t L_11;
L_11 = StylePropertyAnimationSystem_CurrentTimeMs_m3B079B6B759368132A67B8F2E6052A270A7A49B6(__this, NULL);
bool L_12;
L_12 = (( bool (*) (Values_1_t19A1E2B4752BCDF06B5D68597FF7E74704C6F99F*, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115*, int32_t, Background_t3C720DED4FAF016332D29FB86C9BE8D5D0D8F0C8, Background_t3C720DED4FAF016332D29FB86C9BE8D5D0D8F0C8, int32_t, int32_t, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2*, int64_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_3, L_4, L_5, L_6, L_7, L_8, L_9, L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = L_12;
Values_1_t19A1E2B4752BCDF06B5D68597FF7E74704C6F99F* L_13 = ___values7;
(( void (*) (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718*, Values_1_t19A1E2B4752BCDF06B5D68597FF7E74704C6F99F*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(__this, L_13, il2cpp_rgctx_method(method->rgctx_data, 2));
bool L_14 = V_0;
V_1 = L_14;
goto IL_0036;
}
IL_0036:
{
bool L_15 = V_1;
return L_15;
}
}
// System.Boolean UnityEngine.UIElements.StylePropertyAnimationSystem::StartTransition<UnityEngine.Color>(UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.StyleSheets.StylePropertyId,T,T,System.Int32,System.Int32,System.Func`2<System.Single,System.Single>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StylePropertyAnimationSystem_StartTransition_TisColor_tD001788D726C3A7F1379BEED0260B9591F440C1F_mA6698B8B343450BE774AAFACE5329339B620513C_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___owner0, int32_t ___prop1, Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___startValue2, Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___endValue3, int32_t ___durationMs4, int32_t ___delayMs5, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___easingCurve6, Values_1_t49C0EEE75C4A46F518DA157D93141A5AA673B5E0* ___values7, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
{
Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* L_0 = (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7*)__this->___m_PropertyToValues_15;
int32_t L_1 = ___prop1;
Values_1_t49C0EEE75C4A46F518DA157D93141A5AA673B5E0* L_2 = ___values7;
Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273(L_0, L_1, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_2, Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
Values_1_t49C0EEE75C4A46F518DA157D93141A5AA673B5E0* L_3 = ___values7;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_4 = ___owner0;
int32_t L_5 = ___prop1;
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F L_6 = ___startValue2;
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F L_7 = ___endValue3;
int32_t L_8 = ___durationMs4;
int32_t L_9 = ___delayMs5;
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* L_10 = ___easingCurve6;
int64_t L_11;
L_11 = StylePropertyAnimationSystem_CurrentTimeMs_m3B079B6B759368132A67B8F2E6052A270A7A49B6(__this, NULL);
bool L_12;
L_12 = (( bool (*) (Values_1_t49C0EEE75C4A46F518DA157D93141A5AA673B5E0*, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115*, int32_t, Color_tD001788D726C3A7F1379BEED0260B9591F440C1F, Color_tD001788D726C3A7F1379BEED0260B9591F440C1F, int32_t, int32_t, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2*, int64_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_3, L_4, L_5, L_6, L_7, L_8, L_9, L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = L_12;
Values_1_t49C0EEE75C4A46F518DA157D93141A5AA673B5E0* L_13 = ___values7;
(( void (*) (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718*, Values_1_t49C0EEE75C4A46F518DA157D93141A5AA673B5E0*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(__this, L_13, il2cpp_rgctx_method(method->rgctx_data, 2));
bool L_14 = V_0;
V_1 = L_14;
goto IL_0036;
}
IL_0036:
{
bool L_15 = V_1;
return L_15;
}
}
// System.Boolean UnityEngine.UIElements.StylePropertyAnimationSystem::StartTransition<UnityEngine.UIElements.Cursor>(UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.StyleSheets.StylePropertyId,T,T,System.Int32,System.Int32,System.Func`2<System.Single,System.Single>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StylePropertyAnimationSystem_StartTransition_TisCursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82_m51F48E35AAF3AEBE21FB96E98BB6A732B595C224_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___owner0, int32_t ___prop1, Cursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82 ___startValue2, Cursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82 ___endValue3, int32_t ___durationMs4, int32_t ___delayMs5, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___easingCurve6, Values_1_t669A6AFCA17FE6CB7D673FED4589CEDC1F145A98* ___values7, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
{
Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* L_0 = (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7*)__this->___m_PropertyToValues_15;
int32_t L_1 = ___prop1;
Values_1_t669A6AFCA17FE6CB7D673FED4589CEDC1F145A98* L_2 = ___values7;
Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273(L_0, L_1, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_2, Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
Values_1_t669A6AFCA17FE6CB7D673FED4589CEDC1F145A98* L_3 = ___values7;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_4 = ___owner0;
int32_t L_5 = ___prop1;
Cursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82 L_6 = ___startValue2;
Cursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82 L_7 = ___endValue3;
int32_t L_8 = ___durationMs4;
int32_t L_9 = ___delayMs5;
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* L_10 = ___easingCurve6;
int64_t L_11;
L_11 = StylePropertyAnimationSystem_CurrentTimeMs_m3B079B6B759368132A67B8F2E6052A270A7A49B6(__this, NULL);
bool L_12;
L_12 = (( bool (*) (Values_1_t669A6AFCA17FE6CB7D673FED4589CEDC1F145A98*, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115*, int32_t, Cursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82, Cursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82, int32_t, int32_t, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2*, int64_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_3, L_4, L_5, L_6, L_7, L_8, L_9, L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = L_12;
Values_1_t669A6AFCA17FE6CB7D673FED4589CEDC1F145A98* L_13 = ___values7;
(( void (*) (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718*, Values_1_t669A6AFCA17FE6CB7D673FED4589CEDC1F145A98*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(__this, L_13, il2cpp_rgctx_method(method->rgctx_data, 2));
bool L_14 = V_0;
V_1 = L_14;
goto IL_0036;
}
IL_0036:
{
bool L_15 = V_1;
return L_15;
}
}
// System.Boolean UnityEngine.UIElements.StylePropertyAnimationSystem::StartTransition<UnityEngine.UIElements.FontDefinition>(UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.StyleSheets.StylePropertyId,T,T,System.Int32,System.Int32,System.Func`2<System.Single,System.Single>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StylePropertyAnimationSystem_StartTransition_TisFontDefinition_t65281B0E106365C28AD3F2525DE148719AEEA30C_m8E4D16083B78CFD9ACB4C401F281E9677C1BE232_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___owner0, int32_t ___prop1, FontDefinition_t65281B0E106365C28AD3F2525DE148719AEEA30C ___startValue2, FontDefinition_t65281B0E106365C28AD3F2525DE148719AEEA30C ___endValue3, int32_t ___durationMs4, int32_t ___delayMs5, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___easingCurve6, Values_1_t45BEBFF589B2E0FB589C839603CF54DAFA8EE2B7* ___values7, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
{
Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* L_0 = (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7*)__this->___m_PropertyToValues_15;
int32_t L_1 = ___prop1;
Values_1_t45BEBFF589B2E0FB589C839603CF54DAFA8EE2B7* L_2 = ___values7;
Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273(L_0, L_1, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_2, Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
Values_1_t45BEBFF589B2E0FB589C839603CF54DAFA8EE2B7* L_3 = ___values7;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_4 = ___owner0;
int32_t L_5 = ___prop1;
FontDefinition_t65281B0E106365C28AD3F2525DE148719AEEA30C L_6 = ___startValue2;
FontDefinition_t65281B0E106365C28AD3F2525DE148719AEEA30C L_7 = ___endValue3;
int32_t L_8 = ___durationMs4;
int32_t L_9 = ___delayMs5;
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* L_10 = ___easingCurve6;
int64_t L_11;
L_11 = StylePropertyAnimationSystem_CurrentTimeMs_m3B079B6B759368132A67B8F2E6052A270A7A49B6(__this, NULL);
bool L_12;
L_12 = (( bool (*) (Values_1_t45BEBFF589B2E0FB589C839603CF54DAFA8EE2B7*, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115*, int32_t, FontDefinition_t65281B0E106365C28AD3F2525DE148719AEEA30C, FontDefinition_t65281B0E106365C28AD3F2525DE148719AEEA30C, int32_t, int32_t, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2*, int64_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_3, L_4, L_5, L_6, L_7, L_8, L_9, L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = L_12;
Values_1_t45BEBFF589B2E0FB589C839603CF54DAFA8EE2B7* L_13 = ___values7;
(( void (*) (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718*, Values_1_t45BEBFF589B2E0FB589C839603CF54DAFA8EE2B7*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(__this, L_13, il2cpp_rgctx_method(method->rgctx_data, 2));
bool L_14 = V_0;
V_1 = L_14;
goto IL_0036;
}
IL_0036:
{
bool L_15 = V_1;
return L_15;
}
}
// System.Boolean UnityEngine.UIElements.StylePropertyAnimationSystem::StartTransition<System.Int32>(UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.StyleSheets.StylePropertyId,T,T,System.Int32,System.Int32,System.Func`2<System.Single,System.Single>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StylePropertyAnimationSystem_StartTransition_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_mB97CADACE8C091B57839011BE99CE92EC7A16744_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___owner0, int32_t ___prop1, int32_t ___startValue2, int32_t ___endValue3, int32_t ___durationMs4, int32_t ___delayMs5, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___easingCurve6, Values_1_tF2422B8F8347145D2FE398C58F2EF1EAB96567A5* ___values7, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
{
Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* L_0 = (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7*)__this->___m_PropertyToValues_15;
int32_t L_1 = ___prop1;
Values_1_tF2422B8F8347145D2FE398C58F2EF1EAB96567A5* L_2 = ___values7;
Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273(L_0, L_1, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_2, Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
Values_1_tF2422B8F8347145D2FE398C58F2EF1EAB96567A5* L_3 = ___values7;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_4 = ___owner0;
int32_t L_5 = ___prop1;
int32_t L_6 = ___startValue2;
int32_t L_7 = ___endValue3;
int32_t L_8 = ___durationMs4;
int32_t L_9 = ___delayMs5;
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* L_10 = ___easingCurve6;
int64_t L_11;
L_11 = StylePropertyAnimationSystem_CurrentTimeMs_m3B079B6B759368132A67B8F2E6052A270A7A49B6(__this, NULL);
bool L_12;
L_12 = (( bool (*) (Values_1_tF2422B8F8347145D2FE398C58F2EF1EAB96567A5*, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115*, int32_t, int32_t, int32_t, int32_t, int32_t, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2*, int64_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_3, L_4, L_5, L_6, L_7, L_8, L_9, L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = L_12;
Values_1_tF2422B8F8347145D2FE398C58F2EF1EAB96567A5* L_13 = ___values7;
(( void (*) (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718*, Values_1_tF2422B8F8347145D2FE398C58F2EF1EAB96567A5*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(__this, L_13, il2cpp_rgctx_method(method->rgctx_data, 2));
bool L_14 = V_0;
V_1 = L_14;
goto IL_0036;
}
IL_0036:
{
bool L_15 = V_1;
return L_15;
}
}
// System.Boolean UnityEngine.UIElements.StylePropertyAnimationSystem::StartTransition<UnityEngine.UIElements.Length>(UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.StyleSheets.StylePropertyId,T,T,System.Int32,System.Int32,System.Func`2<System.Single,System.Single>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StylePropertyAnimationSystem_StartTransition_TisLength_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256_m35F10294C0F650E36D89179C9EBDD14F1BED06F6_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___owner0, int32_t ___prop1, Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 ___startValue2, Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 ___endValue3, int32_t ___durationMs4, int32_t ___delayMs5, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___easingCurve6, Values_1_t988DC70C892CC8E803830C5C3A4370F5177CD9A6* ___values7, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
{
Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* L_0 = (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7*)__this->___m_PropertyToValues_15;
int32_t L_1 = ___prop1;
Values_1_t988DC70C892CC8E803830C5C3A4370F5177CD9A6* L_2 = ___values7;
Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273(L_0, L_1, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_2, Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
Values_1_t988DC70C892CC8E803830C5C3A4370F5177CD9A6* L_3 = ___values7;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_4 = ___owner0;
int32_t L_5 = ___prop1;
Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 L_6 = ___startValue2;
Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 L_7 = ___endValue3;
int32_t L_8 = ___durationMs4;
int32_t L_9 = ___delayMs5;
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* L_10 = ___easingCurve6;
int64_t L_11;
L_11 = StylePropertyAnimationSystem_CurrentTimeMs_m3B079B6B759368132A67B8F2E6052A270A7A49B6(__this, NULL);
bool L_12;
L_12 = (( bool (*) (Values_1_t988DC70C892CC8E803830C5C3A4370F5177CD9A6*, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115*, int32_t, Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256, Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256, int32_t, int32_t, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2*, int64_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_3, L_4, L_5, L_6, L_7, L_8, L_9, L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = L_12;
Values_1_t988DC70C892CC8E803830C5C3A4370F5177CD9A6* L_13 = ___values7;
(( void (*) (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718*, Values_1_t988DC70C892CC8E803830C5C3A4370F5177CD9A6*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(__this, L_13, il2cpp_rgctx_method(method->rgctx_data, 2));
bool L_14 = V_0;
V_1 = L_14;
goto IL_0036;
}
IL_0036:
{
bool L_15 = V_1;
return L_15;
}
}
// System.Boolean UnityEngine.UIElements.StylePropertyAnimationSystem::StartTransition<System.Object>(UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.StyleSheets.StylePropertyId,T,T,System.Int32,System.Int32,System.Func`2<System.Single,System.Single>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StylePropertyAnimationSystem_StartTransition_TisRuntimeObject_m62E839118713353B7ACBBF88ADF1342E26A3C53A_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___owner0, int32_t ___prop1, RuntimeObject* ___startValue2, RuntimeObject* ___endValue3, int32_t ___durationMs4, int32_t ___delayMs5, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___easingCurve6, Values_1_t34227637D0C93F730700DFD895768AF8F8C7FF8D* ___values7, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
{
Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* L_0 = (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7*)__this->___m_PropertyToValues_15;
int32_t L_1 = ___prop1;
Values_1_t34227637D0C93F730700DFD895768AF8F8C7FF8D* L_2 = ___values7;
Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273(L_0, L_1, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_2, Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
Values_1_t34227637D0C93F730700DFD895768AF8F8C7FF8D* L_3 = ___values7;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_4 = ___owner0;
int32_t L_5 = ___prop1;
RuntimeObject* L_6 = ___startValue2;
RuntimeObject* L_7 = ___endValue3;
int32_t L_8 = ___durationMs4;
int32_t L_9 = ___delayMs5;
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* L_10 = ___easingCurve6;
int64_t L_11;
L_11 = StylePropertyAnimationSystem_CurrentTimeMs_m3B079B6B759368132A67B8F2E6052A270A7A49B6(__this, NULL);
bool L_12;
L_12 = (( bool (*) (Values_1_t34227637D0C93F730700DFD895768AF8F8C7FF8D*, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115*, int32_t, RuntimeObject*, RuntimeObject*, int32_t, int32_t, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2*, int64_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_3, L_4, L_5, L_6, L_7, L_8, L_9, L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = L_12;
Values_1_t34227637D0C93F730700DFD895768AF8F8C7FF8D* L_13 = ___values7;
(( void (*) (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718*, Values_1_t34227637D0C93F730700DFD895768AF8F8C7FF8D*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(__this, L_13, il2cpp_rgctx_method(method->rgctx_data, 2));
bool L_14 = V_0;
V_1 = L_14;
goto IL_0036;
}
IL_0036:
{
bool L_15 = V_1;
return L_15;
}
}
// System.Boolean UnityEngine.UIElements.StylePropertyAnimationSystem::StartTransition<UnityEngine.UIElements.Rotate>(UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.StyleSheets.StylePropertyId,T,T,System.Int32,System.Int32,System.Func`2<System.Single,System.Single>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StylePropertyAnimationSystem_StartTransition_TisRotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7_mF48ED781CBE6F243450F08A3CA66A160BA853FF1_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___owner0, int32_t ___prop1, Rotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7 ___startValue2, Rotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7 ___endValue3, int32_t ___durationMs4, int32_t ___delayMs5, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___easingCurve6, Values_1_t1B84258FDB622ABECA26BA9E2E8F638E1B6B213F* ___values7, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
{
Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* L_0 = (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7*)__this->___m_PropertyToValues_15;
int32_t L_1 = ___prop1;
Values_1_t1B84258FDB622ABECA26BA9E2E8F638E1B6B213F* L_2 = ___values7;
Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273(L_0, L_1, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_2, Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
Values_1_t1B84258FDB622ABECA26BA9E2E8F638E1B6B213F* L_3 = ___values7;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_4 = ___owner0;
int32_t L_5 = ___prop1;
Rotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7 L_6 = ___startValue2;
Rotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7 L_7 = ___endValue3;
int32_t L_8 = ___durationMs4;
int32_t L_9 = ___delayMs5;
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* L_10 = ___easingCurve6;
int64_t L_11;
L_11 = StylePropertyAnimationSystem_CurrentTimeMs_m3B079B6B759368132A67B8F2E6052A270A7A49B6(__this, NULL);
bool L_12;
L_12 = (( bool (*) (Values_1_t1B84258FDB622ABECA26BA9E2E8F638E1B6B213F*, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115*, int32_t, Rotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7, Rotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7, int32_t, int32_t, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2*, int64_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_3, L_4, L_5, L_6, L_7, L_8, L_9, L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = L_12;
Values_1_t1B84258FDB622ABECA26BA9E2E8F638E1B6B213F* L_13 = ___values7;
(( void (*) (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718*, Values_1_t1B84258FDB622ABECA26BA9E2E8F638E1B6B213F*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(__this, L_13, il2cpp_rgctx_method(method->rgctx_data, 2));
bool L_14 = V_0;
V_1 = L_14;
goto IL_0036;
}
IL_0036:
{
bool L_15 = V_1;
return L_15;
}
}
// System.Boolean UnityEngine.UIElements.StylePropertyAnimationSystem::StartTransition<UnityEngine.UIElements.Scale>(UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.StyleSheets.StylePropertyId,T,T,System.Int32,System.Int32,System.Func`2<System.Single,System.Single>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StylePropertyAnimationSystem_StartTransition_TisScale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7_mCA0F0ADA23085C05A6E20E52FAC0B7FE37E5F40F_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___owner0, int32_t ___prop1, Scale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7 ___startValue2, Scale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7 ___endValue3, int32_t ___durationMs4, int32_t ___delayMs5, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___easingCurve6, Values_1_tD710D214E4D407A033AE57CE091D4C4FBB293714* ___values7, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
{
Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* L_0 = (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7*)__this->___m_PropertyToValues_15;
int32_t L_1 = ___prop1;
Values_1_tD710D214E4D407A033AE57CE091D4C4FBB293714* L_2 = ___values7;
Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273(L_0, L_1, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_2, Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
Values_1_tD710D214E4D407A033AE57CE091D4C4FBB293714* L_3 = ___values7;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_4 = ___owner0;
int32_t L_5 = ___prop1;
Scale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7 L_6 = ___startValue2;
Scale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7 L_7 = ___endValue3;
int32_t L_8 = ___durationMs4;
int32_t L_9 = ___delayMs5;
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* L_10 = ___easingCurve6;
int64_t L_11;
L_11 = StylePropertyAnimationSystem_CurrentTimeMs_m3B079B6B759368132A67B8F2E6052A270A7A49B6(__this, NULL);
bool L_12;
L_12 = (( bool (*) (Values_1_tD710D214E4D407A033AE57CE091D4C4FBB293714*, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115*, int32_t, Scale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7, Scale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7, int32_t, int32_t, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2*, int64_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_3, L_4, L_5, L_6, L_7, L_8, L_9, L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = L_12;
Values_1_tD710D214E4D407A033AE57CE091D4C4FBB293714* L_13 = ___values7;
(( void (*) (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718*, Values_1_tD710D214E4D407A033AE57CE091D4C4FBB293714*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(__this, L_13, il2cpp_rgctx_method(method->rgctx_data, 2));
bool L_14 = V_0;
V_1 = L_14;
goto IL_0036;
}
IL_0036:
{
bool L_15 = V_1;
return L_15;
}
}
// System.Boolean UnityEngine.UIElements.StylePropertyAnimationSystem::StartTransition<System.Single>(UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.StyleSheets.StylePropertyId,T,T,System.Int32,System.Int32,System.Func`2<System.Single,System.Single>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StylePropertyAnimationSystem_StartTransition_TisSingle_t4530F2FF86FCB0DC29F35385CA1BD21BE294761C_m7DA7B0363D2265A7C217459845364E86F6D093AB_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___owner0, int32_t ___prop1, float ___startValue2, float ___endValue3, int32_t ___durationMs4, int32_t ___delayMs5, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___easingCurve6, Values_1_t0E31EAA5A590859BBD863FE74A3208C8F5722AA1* ___values7, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
{
Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* L_0 = (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7*)__this->___m_PropertyToValues_15;
int32_t L_1 = ___prop1;
Values_1_t0E31EAA5A590859BBD863FE74A3208C8F5722AA1* L_2 = ___values7;
Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273(L_0, L_1, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_2, Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
Values_1_t0E31EAA5A590859BBD863FE74A3208C8F5722AA1* L_3 = ___values7;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_4 = ___owner0;
int32_t L_5 = ___prop1;
float L_6 = ___startValue2;
float L_7 = ___endValue3;
int32_t L_8 = ___durationMs4;
int32_t L_9 = ___delayMs5;
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* L_10 = ___easingCurve6;
int64_t L_11;
L_11 = StylePropertyAnimationSystem_CurrentTimeMs_m3B079B6B759368132A67B8F2E6052A270A7A49B6(__this, NULL);
bool L_12;
L_12 = (( bool (*) (Values_1_t0E31EAA5A590859BBD863FE74A3208C8F5722AA1*, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115*, int32_t, float, float, int32_t, int32_t, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2*, int64_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_3, L_4, L_5, L_6, L_7, L_8, L_9, L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = L_12;
Values_1_t0E31EAA5A590859BBD863FE74A3208C8F5722AA1* L_13 = ___values7;
(( void (*) (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718*, Values_1_t0E31EAA5A590859BBD863FE74A3208C8F5722AA1*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(__this, L_13, il2cpp_rgctx_method(method->rgctx_data, 2));
bool L_14 = V_0;
V_1 = L_14;
goto IL_0036;
}
IL_0036:
{
bool L_15 = V_1;
return L_15;
}
}
// System.Boolean UnityEngine.UIElements.StylePropertyAnimationSystem::StartTransition<UnityEngine.UIElements.TextShadow>(UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.StyleSheets.StylePropertyId,T,T,System.Int32,System.Int32,System.Func`2<System.Single,System.Single>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StylePropertyAnimationSystem_StartTransition_TisTextShadow_t6BADF37AB90ABCB63859A225B58AC5A580950A05_mAF55C9EB61C8081E34D6DA31BB0B7749F7120DB4_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___owner0, int32_t ___prop1, TextShadow_t6BADF37AB90ABCB63859A225B58AC5A580950A05 ___startValue2, TextShadow_t6BADF37AB90ABCB63859A225B58AC5A580950A05 ___endValue3, int32_t ___durationMs4, int32_t ___delayMs5, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___easingCurve6, Values_1_tFB112CD52331C038F6B928FEAFAB19A06FD2F62C* ___values7, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
{
Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* L_0 = (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7*)__this->___m_PropertyToValues_15;
int32_t L_1 = ___prop1;
Values_1_tFB112CD52331C038F6B928FEAFAB19A06FD2F62C* L_2 = ___values7;
Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273(L_0, L_1, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_2, Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
Values_1_tFB112CD52331C038F6B928FEAFAB19A06FD2F62C* L_3 = ___values7;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_4 = ___owner0;
int32_t L_5 = ___prop1;
TextShadow_t6BADF37AB90ABCB63859A225B58AC5A580950A05 L_6 = ___startValue2;
TextShadow_t6BADF37AB90ABCB63859A225B58AC5A580950A05 L_7 = ___endValue3;
int32_t L_8 = ___durationMs4;
int32_t L_9 = ___delayMs5;
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* L_10 = ___easingCurve6;
int64_t L_11;
L_11 = StylePropertyAnimationSystem_CurrentTimeMs_m3B079B6B759368132A67B8F2E6052A270A7A49B6(__this, NULL);
bool L_12;
L_12 = (( bool (*) (Values_1_tFB112CD52331C038F6B928FEAFAB19A06FD2F62C*, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115*, int32_t, TextShadow_t6BADF37AB90ABCB63859A225B58AC5A580950A05, TextShadow_t6BADF37AB90ABCB63859A225B58AC5A580950A05, int32_t, int32_t, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2*, int64_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_3, L_4, L_5, L_6, L_7, L_8, L_9, L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = L_12;
Values_1_tFB112CD52331C038F6B928FEAFAB19A06FD2F62C* L_13 = ___values7;
(( void (*) (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718*, Values_1_tFB112CD52331C038F6B928FEAFAB19A06FD2F62C*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(__this, L_13, il2cpp_rgctx_method(method->rgctx_data, 2));
bool L_14 = V_0;
V_1 = L_14;
goto IL_0036;
}
IL_0036:
{
bool L_15 = V_1;
return L_15;
}
}
// System.Boolean UnityEngine.UIElements.StylePropertyAnimationSystem::StartTransition<UnityEngine.UIElements.TransformOrigin>(UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.StyleSheets.StylePropertyId,T,T,System.Int32,System.Int32,System.Func`2<System.Single,System.Single>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StylePropertyAnimationSystem_StartTransition_TisTransformOrigin_tD11A368A96C0771398EBB4E6D435318AC0EF8502_m6DA3A36592C69F444EC66E150A00D1E9D0D2E74F_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___owner0, int32_t ___prop1, TransformOrigin_tD11A368A96C0771398EBB4E6D435318AC0EF8502 ___startValue2, TransformOrigin_tD11A368A96C0771398EBB4E6D435318AC0EF8502 ___endValue3, int32_t ___durationMs4, int32_t ___delayMs5, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___easingCurve6, Values_1_t4B3725FE6B9D8A60439FC42ABC27E2FAE91ACBA5* ___values7, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
{
Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* L_0 = (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7*)__this->___m_PropertyToValues_15;
int32_t L_1 = ___prop1;
Values_1_t4B3725FE6B9D8A60439FC42ABC27E2FAE91ACBA5* L_2 = ___values7;
Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273(L_0, L_1, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_2, Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
Values_1_t4B3725FE6B9D8A60439FC42ABC27E2FAE91ACBA5* L_3 = ___values7;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_4 = ___owner0;
int32_t L_5 = ___prop1;
TransformOrigin_tD11A368A96C0771398EBB4E6D435318AC0EF8502 L_6 = ___startValue2;
TransformOrigin_tD11A368A96C0771398EBB4E6D435318AC0EF8502 L_7 = ___endValue3;
int32_t L_8 = ___durationMs4;
int32_t L_9 = ___delayMs5;
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* L_10 = ___easingCurve6;
int64_t L_11;
L_11 = StylePropertyAnimationSystem_CurrentTimeMs_m3B079B6B759368132A67B8F2E6052A270A7A49B6(__this, NULL);
bool L_12;
L_12 = (( bool (*) (Values_1_t4B3725FE6B9D8A60439FC42ABC27E2FAE91ACBA5*, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115*, int32_t, TransformOrigin_tD11A368A96C0771398EBB4E6D435318AC0EF8502, TransformOrigin_tD11A368A96C0771398EBB4E6D435318AC0EF8502, int32_t, int32_t, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2*, int64_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_3, L_4, L_5, L_6, L_7, L_8, L_9, L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = L_12;
Values_1_t4B3725FE6B9D8A60439FC42ABC27E2FAE91ACBA5* L_13 = ___values7;
(( void (*) (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718*, Values_1_t4B3725FE6B9D8A60439FC42ABC27E2FAE91ACBA5*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(__this, L_13, il2cpp_rgctx_method(method->rgctx_data, 2));
bool L_14 = V_0;
V_1 = L_14;
goto IL_0036;
}
IL_0036:
{
bool L_15 = V_1;
return L_15;
}
}
// System.Boolean UnityEngine.UIElements.StylePropertyAnimationSystem::StartTransition<UnityEngine.UIElements.Translate>(UnityEngine.UIElements.VisualElement,UnityEngine.UIElements.StyleSheets.StylePropertyId,T,T,System.Int32,System.Int32,System.Func`2<System.Single,System.Single>,UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StylePropertyAnimationSystem_StartTransition_TisTranslate_t494F6E802F8A640D67819C9D26BE62DED1218A8E_m0BCC34376C9BBAEB7315E9F98CF2FF0578E354B7_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___owner0, int32_t ___prop1, Translate_t494F6E802F8A640D67819C9D26BE62DED1218A8E ___startValue2, Translate_t494F6E802F8A640D67819C9D26BE62DED1218A8E ___endValue3, int32_t ___durationMs4, int32_t ___delayMs5, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* ___easingCurve6, Values_1_tF515CA326AF84CBBA1A40F1C76BC6D39AA409215* ___values7, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
{
Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7* L_0 = (Dictionary_2_t8B8AC3704119A64857E8D359CB4782C5ECEA90E7*)__this->___m_PropertyToValues_15;
int32_t L_1 = ___prop1;
Values_1_tF515CA326AF84CBBA1A40F1C76BC6D39AA409215* L_2 = ___values7;
Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273(L_0, L_1, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_2, Dictionary_2_set_Item_mE2CB2DBE9CFA9FD3FF4707BB20A9B1FE52C76273_RuntimeMethod_var);
Values_1_tF515CA326AF84CBBA1A40F1C76BC6D39AA409215* L_3 = ___values7;
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_4 = ___owner0;
int32_t L_5 = ___prop1;
Translate_t494F6E802F8A640D67819C9D26BE62DED1218A8E L_6 = ___startValue2;
Translate_t494F6E802F8A640D67819C9D26BE62DED1218A8E L_7 = ___endValue3;
int32_t L_8 = ___durationMs4;
int32_t L_9 = ___delayMs5;
Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2* L_10 = ___easingCurve6;
int64_t L_11;
L_11 = StylePropertyAnimationSystem_CurrentTimeMs_m3B079B6B759368132A67B8F2E6052A270A7A49B6(__this, NULL);
bool L_12;
L_12 = (( bool (*) (Values_1_tF515CA326AF84CBBA1A40F1C76BC6D39AA409215*, VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115*, int32_t, Translate_t494F6E802F8A640D67819C9D26BE62DED1218A8E, Translate_t494F6E802F8A640D67819C9D26BE62DED1218A8E, int32_t, int32_t, Func_2_t2A7432CC4F64D0DF6D8629208B154CF139B39AF2*, int64_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_3, L_4, L_5, L_6, L_7, L_8, L_9, L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = L_12;
Values_1_tF515CA326AF84CBBA1A40F1C76BC6D39AA409215* L_13 = ___values7;
(( void (*) (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718*, Values_1_tF515CA326AF84CBBA1A40F1C76BC6D39AA409215*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(__this, L_13, il2cpp_rgctx_method(method->rgctx_data, 2));
bool L_14 = V_0;
V_1 = L_14;
goto IL_0036;
}
IL_0036:
{
bool L_15 = V_1;
return L_15;
}
}
// System.Void UnityEngine.UIElements.StylePropertyAnimationSystem::UpdateTracking<UnityEngine.UIElements.Background>(UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StylePropertyAnimationSystem_UpdateTracking_TisBackground_t3C720DED4FAF016332D29FB86C9BE8D5D0D8F0C8_m6B58F7CB721AD15022069AB62995E1080CF1FFE4_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, Values_1_t19A1E2B4752BCDF06B5D68597FF7E74704C6F99F* ___values0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
int32_t G_B3_0 = 0;
{
Values_1_t19A1E2B4752BCDF06B5D68597FF7E74704C6F99F* L_0 = ___values0;
bool L_1;
L_1 = (( bool (*) (Values_1_t19A1E2B4752BCDF06B5D68597FF7E74704C6F99F*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
if (L_1)
{
goto IL_001a;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_2 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t19A1E2B4752BCDF06B5D68597FF7E74704C6F99F* L_3 = ___values0;
bool L_4;
L_4 = List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4(L_2, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_3, List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
G_B3_0 = ((((int32_t)L_4) == ((int32_t)0))? 1 : 0);
goto IL_001b;
}
IL_001a:
{
G_B3_0 = 0;
}
IL_001b:
{
V_0 = (bool)G_B3_0;
bool L_5 = V_0;
if (!L_5)
{
goto IL_002e;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_6 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t19A1E2B4752BCDF06B5D68597FF7E74704C6F99F* L_7 = ___values0;
List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_inline(L_6, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_7, List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
}
IL_002e:
{
return;
}
}
// System.Void UnityEngine.UIElements.StylePropertyAnimationSystem::UpdateTracking<UnityEngine.Color>(UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StylePropertyAnimationSystem_UpdateTracking_TisColor_tD001788D726C3A7F1379BEED0260B9591F440C1F_m599DF51666A284BAEABF680EF2DDFDF566F4D0BE_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, Values_1_t49C0EEE75C4A46F518DA157D93141A5AA673B5E0* ___values0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
int32_t G_B3_0 = 0;
{
Values_1_t49C0EEE75C4A46F518DA157D93141A5AA673B5E0* L_0 = ___values0;
bool L_1;
L_1 = (( bool (*) (Values_1_t49C0EEE75C4A46F518DA157D93141A5AA673B5E0*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
if (L_1)
{
goto IL_001a;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_2 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t49C0EEE75C4A46F518DA157D93141A5AA673B5E0* L_3 = ___values0;
bool L_4;
L_4 = List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4(L_2, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_3, List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
G_B3_0 = ((((int32_t)L_4) == ((int32_t)0))? 1 : 0);
goto IL_001b;
}
IL_001a:
{
G_B3_0 = 0;
}
IL_001b:
{
V_0 = (bool)G_B3_0;
bool L_5 = V_0;
if (!L_5)
{
goto IL_002e;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_6 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t49C0EEE75C4A46F518DA157D93141A5AA673B5E0* L_7 = ___values0;
List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_inline(L_6, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_7, List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
}
IL_002e:
{
return;
}
}
// System.Void UnityEngine.UIElements.StylePropertyAnimationSystem::UpdateTracking<UnityEngine.UIElements.Cursor>(UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StylePropertyAnimationSystem_UpdateTracking_TisCursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82_mFE44813A60974E0545CFF28DC61858B5F53DCB7B_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, Values_1_t669A6AFCA17FE6CB7D673FED4589CEDC1F145A98* ___values0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
int32_t G_B3_0 = 0;
{
Values_1_t669A6AFCA17FE6CB7D673FED4589CEDC1F145A98* L_0 = ___values0;
bool L_1;
L_1 = (( bool (*) (Values_1_t669A6AFCA17FE6CB7D673FED4589CEDC1F145A98*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
if (L_1)
{
goto IL_001a;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_2 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t669A6AFCA17FE6CB7D673FED4589CEDC1F145A98* L_3 = ___values0;
bool L_4;
L_4 = List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4(L_2, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_3, List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
G_B3_0 = ((((int32_t)L_4) == ((int32_t)0))? 1 : 0);
goto IL_001b;
}
IL_001a:
{
G_B3_0 = 0;
}
IL_001b:
{
V_0 = (bool)G_B3_0;
bool L_5 = V_0;
if (!L_5)
{
goto IL_002e;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_6 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t669A6AFCA17FE6CB7D673FED4589CEDC1F145A98* L_7 = ___values0;
List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_inline(L_6, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_7, List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
}
IL_002e:
{
return;
}
}
// System.Void UnityEngine.UIElements.StylePropertyAnimationSystem::UpdateTracking<UnityEngine.UIElements.FontDefinition>(UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StylePropertyAnimationSystem_UpdateTracking_TisFontDefinition_t65281B0E106365C28AD3F2525DE148719AEEA30C_m8E65DB1588D62F50E512DA2013A83BFDDC600E1E_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, Values_1_t45BEBFF589B2E0FB589C839603CF54DAFA8EE2B7* ___values0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
int32_t G_B3_0 = 0;
{
Values_1_t45BEBFF589B2E0FB589C839603CF54DAFA8EE2B7* L_0 = ___values0;
bool L_1;
L_1 = (( bool (*) (Values_1_t45BEBFF589B2E0FB589C839603CF54DAFA8EE2B7*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
if (L_1)
{
goto IL_001a;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_2 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t45BEBFF589B2E0FB589C839603CF54DAFA8EE2B7* L_3 = ___values0;
bool L_4;
L_4 = List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4(L_2, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_3, List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
G_B3_0 = ((((int32_t)L_4) == ((int32_t)0))? 1 : 0);
goto IL_001b;
}
IL_001a:
{
G_B3_0 = 0;
}
IL_001b:
{
V_0 = (bool)G_B3_0;
bool L_5 = V_0;
if (!L_5)
{
goto IL_002e;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_6 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t45BEBFF589B2E0FB589C839603CF54DAFA8EE2B7* L_7 = ___values0;
List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_inline(L_6, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_7, List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
}
IL_002e:
{
return;
}
}
// System.Void UnityEngine.UIElements.StylePropertyAnimationSystem::UpdateTracking<System.Int32>(UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StylePropertyAnimationSystem_UpdateTracking_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_m0F889CDB8903A18BE8469C93EC6831F3C1EC855E_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, Values_1_tF2422B8F8347145D2FE398C58F2EF1EAB96567A5* ___values0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
int32_t G_B3_0 = 0;
{
Values_1_tF2422B8F8347145D2FE398C58F2EF1EAB96567A5* L_0 = ___values0;
bool L_1;
L_1 = (( bool (*) (Values_1_tF2422B8F8347145D2FE398C58F2EF1EAB96567A5*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
if (L_1)
{
goto IL_001a;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_2 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_tF2422B8F8347145D2FE398C58F2EF1EAB96567A5* L_3 = ___values0;
bool L_4;
L_4 = List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4(L_2, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_3, List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
G_B3_0 = ((((int32_t)L_4) == ((int32_t)0))? 1 : 0);
goto IL_001b;
}
IL_001a:
{
G_B3_0 = 0;
}
IL_001b:
{
V_0 = (bool)G_B3_0;
bool L_5 = V_0;
if (!L_5)
{
goto IL_002e;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_6 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_tF2422B8F8347145D2FE398C58F2EF1EAB96567A5* L_7 = ___values0;
List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_inline(L_6, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_7, List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
}
IL_002e:
{
return;
}
}
// System.Void UnityEngine.UIElements.StylePropertyAnimationSystem::UpdateTracking<UnityEngine.UIElements.Length>(UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StylePropertyAnimationSystem_UpdateTracking_TisLength_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256_m3E21F3BBE0F90FD11FD85EB40B4BADEE6E1BEA7F_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, Values_1_t988DC70C892CC8E803830C5C3A4370F5177CD9A6* ___values0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
int32_t G_B3_0 = 0;
{
Values_1_t988DC70C892CC8E803830C5C3A4370F5177CD9A6* L_0 = ___values0;
bool L_1;
L_1 = (( bool (*) (Values_1_t988DC70C892CC8E803830C5C3A4370F5177CD9A6*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
if (L_1)
{
goto IL_001a;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_2 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t988DC70C892CC8E803830C5C3A4370F5177CD9A6* L_3 = ___values0;
bool L_4;
L_4 = List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4(L_2, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_3, List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
G_B3_0 = ((((int32_t)L_4) == ((int32_t)0))? 1 : 0);
goto IL_001b;
}
IL_001a:
{
G_B3_0 = 0;
}
IL_001b:
{
V_0 = (bool)G_B3_0;
bool L_5 = V_0;
if (!L_5)
{
goto IL_002e;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_6 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t988DC70C892CC8E803830C5C3A4370F5177CD9A6* L_7 = ___values0;
List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_inline(L_6, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_7, List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
}
IL_002e:
{
return;
}
}
// System.Void UnityEngine.UIElements.StylePropertyAnimationSystem::UpdateTracking<System.Object>(UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StylePropertyAnimationSystem_UpdateTracking_TisRuntimeObject_m011E3913A22A7A0E5852303442E33A2C0947DBD8_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, Values_1_t34227637D0C93F730700DFD895768AF8F8C7FF8D* ___values0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
int32_t G_B3_0 = 0;
{
Values_1_t34227637D0C93F730700DFD895768AF8F8C7FF8D* L_0 = ___values0;
bool L_1;
L_1 = (( bool (*) (Values_1_t34227637D0C93F730700DFD895768AF8F8C7FF8D*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
if (L_1)
{
goto IL_001a;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_2 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t34227637D0C93F730700DFD895768AF8F8C7FF8D* L_3 = ___values0;
bool L_4;
L_4 = List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4(L_2, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_3, List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
G_B3_0 = ((((int32_t)L_4) == ((int32_t)0))? 1 : 0);
goto IL_001b;
}
IL_001a:
{
G_B3_0 = 0;
}
IL_001b:
{
V_0 = (bool)G_B3_0;
bool L_5 = V_0;
if (!L_5)
{
goto IL_002e;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_6 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t34227637D0C93F730700DFD895768AF8F8C7FF8D* L_7 = ___values0;
List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_inline(L_6, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_7, List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
}
IL_002e:
{
return;
}
}
// System.Void UnityEngine.UIElements.StylePropertyAnimationSystem::UpdateTracking<UnityEngine.UIElements.Rotate>(UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StylePropertyAnimationSystem_UpdateTracking_TisRotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7_m1F6E455EDDEE409F3EB00AE0633DA0B5944D7768_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, Values_1_t1B84258FDB622ABECA26BA9E2E8F638E1B6B213F* ___values0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
int32_t G_B3_0 = 0;
{
Values_1_t1B84258FDB622ABECA26BA9E2E8F638E1B6B213F* L_0 = ___values0;
bool L_1;
L_1 = (( bool (*) (Values_1_t1B84258FDB622ABECA26BA9E2E8F638E1B6B213F*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
if (L_1)
{
goto IL_001a;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_2 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t1B84258FDB622ABECA26BA9E2E8F638E1B6B213F* L_3 = ___values0;
bool L_4;
L_4 = List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4(L_2, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_3, List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
G_B3_0 = ((((int32_t)L_4) == ((int32_t)0))? 1 : 0);
goto IL_001b;
}
IL_001a:
{
G_B3_0 = 0;
}
IL_001b:
{
V_0 = (bool)G_B3_0;
bool L_5 = V_0;
if (!L_5)
{
goto IL_002e;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_6 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t1B84258FDB622ABECA26BA9E2E8F638E1B6B213F* L_7 = ___values0;
List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_inline(L_6, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_7, List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
}
IL_002e:
{
return;
}
}
// System.Void UnityEngine.UIElements.StylePropertyAnimationSystem::UpdateTracking<UnityEngine.UIElements.Scale>(UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StylePropertyAnimationSystem_UpdateTracking_TisScale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7_m8E8376CC278EF4B8A71C14610A1727AB162A1989_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, Values_1_tD710D214E4D407A033AE57CE091D4C4FBB293714* ___values0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
int32_t G_B3_0 = 0;
{
Values_1_tD710D214E4D407A033AE57CE091D4C4FBB293714* L_0 = ___values0;
bool L_1;
L_1 = (( bool (*) (Values_1_tD710D214E4D407A033AE57CE091D4C4FBB293714*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
if (L_1)
{
goto IL_001a;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_2 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_tD710D214E4D407A033AE57CE091D4C4FBB293714* L_3 = ___values0;
bool L_4;
L_4 = List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4(L_2, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_3, List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
G_B3_0 = ((((int32_t)L_4) == ((int32_t)0))? 1 : 0);
goto IL_001b;
}
IL_001a:
{
G_B3_0 = 0;
}
IL_001b:
{
V_0 = (bool)G_B3_0;
bool L_5 = V_0;
if (!L_5)
{
goto IL_002e;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_6 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_tD710D214E4D407A033AE57CE091D4C4FBB293714* L_7 = ___values0;
List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_inline(L_6, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_7, List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
}
IL_002e:
{
return;
}
}
// System.Void UnityEngine.UIElements.StylePropertyAnimationSystem::UpdateTracking<System.Single>(UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StylePropertyAnimationSystem_UpdateTracking_TisSingle_t4530F2FF86FCB0DC29F35385CA1BD21BE294761C_m3060507B00DD426DEF028070603CE497F3DCE5BD_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, Values_1_t0E31EAA5A590859BBD863FE74A3208C8F5722AA1* ___values0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
int32_t G_B3_0 = 0;
{
Values_1_t0E31EAA5A590859BBD863FE74A3208C8F5722AA1* L_0 = ___values0;
bool L_1;
L_1 = (( bool (*) (Values_1_t0E31EAA5A590859BBD863FE74A3208C8F5722AA1*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
if (L_1)
{
goto IL_001a;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_2 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t0E31EAA5A590859BBD863FE74A3208C8F5722AA1* L_3 = ___values0;
bool L_4;
L_4 = List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4(L_2, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_3, List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
G_B3_0 = ((((int32_t)L_4) == ((int32_t)0))? 1 : 0);
goto IL_001b;
}
IL_001a:
{
G_B3_0 = 0;
}
IL_001b:
{
V_0 = (bool)G_B3_0;
bool L_5 = V_0;
if (!L_5)
{
goto IL_002e;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_6 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t0E31EAA5A590859BBD863FE74A3208C8F5722AA1* L_7 = ___values0;
List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_inline(L_6, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_7, List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
}
IL_002e:
{
return;
}
}
// System.Void UnityEngine.UIElements.StylePropertyAnimationSystem::UpdateTracking<UnityEngine.UIElements.TextShadow>(UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StylePropertyAnimationSystem_UpdateTracking_TisTextShadow_t6BADF37AB90ABCB63859A225B58AC5A580950A05_m7F2CEEB81287803CEDAFABB0A101DAEE2EE48FE6_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, Values_1_tFB112CD52331C038F6B928FEAFAB19A06FD2F62C* ___values0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
int32_t G_B3_0 = 0;
{
Values_1_tFB112CD52331C038F6B928FEAFAB19A06FD2F62C* L_0 = ___values0;
bool L_1;
L_1 = (( bool (*) (Values_1_tFB112CD52331C038F6B928FEAFAB19A06FD2F62C*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
if (L_1)
{
goto IL_001a;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_2 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_tFB112CD52331C038F6B928FEAFAB19A06FD2F62C* L_3 = ___values0;
bool L_4;
L_4 = List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4(L_2, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_3, List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
G_B3_0 = ((((int32_t)L_4) == ((int32_t)0))? 1 : 0);
goto IL_001b;
}
IL_001a:
{
G_B3_0 = 0;
}
IL_001b:
{
V_0 = (bool)G_B3_0;
bool L_5 = V_0;
if (!L_5)
{
goto IL_002e;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_6 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_tFB112CD52331C038F6B928FEAFAB19A06FD2F62C* L_7 = ___values0;
List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_inline(L_6, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_7, List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
}
IL_002e:
{
return;
}
}
// System.Void UnityEngine.UIElements.StylePropertyAnimationSystem::UpdateTracking<UnityEngine.UIElements.TransformOrigin>(UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StylePropertyAnimationSystem_UpdateTracking_TisTransformOrigin_tD11A368A96C0771398EBB4E6D435318AC0EF8502_m388559E066ED4D9F5DA98AFCB2A695DF8F140529_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, Values_1_t4B3725FE6B9D8A60439FC42ABC27E2FAE91ACBA5* ___values0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
int32_t G_B3_0 = 0;
{
Values_1_t4B3725FE6B9D8A60439FC42ABC27E2FAE91ACBA5* L_0 = ___values0;
bool L_1;
L_1 = (( bool (*) (Values_1_t4B3725FE6B9D8A60439FC42ABC27E2FAE91ACBA5*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
if (L_1)
{
goto IL_001a;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_2 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t4B3725FE6B9D8A60439FC42ABC27E2FAE91ACBA5* L_3 = ___values0;
bool L_4;
L_4 = List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4(L_2, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_3, List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
G_B3_0 = ((((int32_t)L_4) == ((int32_t)0))? 1 : 0);
goto IL_001b;
}
IL_001a:
{
G_B3_0 = 0;
}
IL_001b:
{
V_0 = (bool)G_B3_0;
bool L_5 = V_0;
if (!L_5)
{
goto IL_002e;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_6 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_t4B3725FE6B9D8A60439FC42ABC27E2FAE91ACBA5* L_7 = ___values0;
List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_inline(L_6, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_7, List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
}
IL_002e:
{
return;
}
}
// System.Void UnityEngine.UIElements.StylePropertyAnimationSystem::UpdateTracking<UnityEngine.UIElements.Translate>(UnityEngine.UIElements.StylePropertyAnimationSystem/Values`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StylePropertyAnimationSystem_UpdateTracking_TisTranslate_t494F6E802F8A640D67819C9D26BE62DED1218A8E_mA7261C21F9098EC4BEBB949F97A5FA9198DA105C_gshared (StylePropertyAnimationSystem_tB499821AFC54DE61DC54CFDCD392C337F5097718* __this, Values_1_tF515CA326AF84CBBA1A40F1C76BC6D39AA409215* ___values0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
int32_t G_B3_0 = 0;
{
Values_1_tF515CA326AF84CBBA1A40F1C76BC6D39AA409215* L_0 = ___values0;
bool L_1;
L_1 = (( bool (*) (Values_1_tF515CA326AF84CBBA1A40F1C76BC6D39AA409215*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
if (L_1)
{
goto IL_001a;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_2 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_tF515CA326AF84CBBA1A40F1C76BC6D39AA409215* L_3 = ___values0;
bool L_4;
L_4 = List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4(L_2, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_3, List_1_Contains_m71E6FD21D54996DACBC26526FABF5E57B9E4C3B4_RuntimeMethod_var);
G_B3_0 = ((((int32_t)L_4) == ((int32_t)0))? 1 : 0);
goto IL_001b;
}
IL_001a:
{
G_B3_0 = 0;
}
IL_001b:
{
V_0 = (bool)G_B3_0;
bool L_5 = V_0;
if (!L_5)
{
goto IL_002e;
}
}
{
List_1_t491E344573B9D6F61E36AF56132B7412453928C9* L_6 = (List_1_t491E344573B9D6F61E36AF56132B7412453928C9*)__this->___m_AllValues_14;
Values_1_tF515CA326AF84CBBA1A40F1C76BC6D39AA409215* L_7 = ___values0;
List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_inline(L_6, (Values_t810A8E7A95A5716F91CE1BDC1EE3AD25FE329E24*)L_7, List_1_Add_mA2DB3B33B757C906EBF689F682FD659A191A242B_RuntimeMethod_var);
}
IL_002e:
{
return;
}
}
// T UnityEngine.UIElements.StyleSheet::CheckAccess<UnityEngine.Color>(T[],UnityEngine.UIElements.StyleValueType,UnityEngine.UIElements.StyleValueHandle)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Color_tD001788D726C3A7F1379BEED0260B9591F440C1F StyleSheet_CheckAccess_TisColor_tD001788D726C3A7F1379BEED0260B9591F440C1F_m0D9C3D1AB7916608314A04FCA033C0DEE7DF8C9E_gshared (ColorU5BU5D_t612261CF293F6FFC3D80AB52259FF0DC2B2CC389* ___list0, int32_t ___type1, StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D ___handle2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteralC472776C9180B19630B6E4112538D935B62E3F35);
s_Il2CppMethodInitialized = true;
}
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
bool V_2 = false;
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F V_3;
memset((&V_3), 0, sizeof(V_3));
int32_t G_B6_0 = 0;
{
il2cpp_codegen_initobj((&V_0), sizeof(Color_tD001788D726C3A7F1379BEED0260B9591F440C1F));
int32_t L_0;
L_0 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_1 = ___type1;
V_1 = (bool)((((int32_t)((((int32_t)L_0) == ((int32_t)L_1))? 1 : 0)) == ((int32_t)0))? 1 : 0);
bool L_2 = V_1;
if (!L_2)
{
goto IL_0047;
}
}
{
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_3 = (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)SZArrayNew(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_4 = L_3;
int32_t L_5 = ___type1;
int32_t L_6 = L_5;
RuntimeObject* L_7 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_6);
ArrayElementTypeCheck (L_4, L_7);
(L_4)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (RuntimeObject*)L_7);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_8 = L_4;
int32_t L_9;
L_9 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_10 = L_9;
RuntimeObject* L_11 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_10);
ArrayElementTypeCheck (L_8, L_11);
(L_8)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (RuntimeObject*)L_11);
il2cpp_codegen_runtime_class_init_inline(Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
Debug_LogErrorFormat_mA33C95EF832A60D72A7EE26074E13A86BE7E30C6(_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207, L_8, NULL);
goto IL_0086;
}
IL_0047:
{
ColorU5BU5D_t612261CF293F6FFC3D80AB52259FF0DC2B2CC389* L_12 = ___list0;
if (!L_12)
{
goto IL_0063;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_13 = ___handle2;
int32_t L_14 = (int32_t)L_13.___valueIndex_1;
if ((((int32_t)L_14) < ((int32_t)0)))
{
goto IL_0063;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_15 = ___handle2;
int32_t L_16 = (int32_t)L_15.___valueIndex_1;
ColorU5BU5D_t612261CF293F6FFC3D80AB52259FF0DC2B2CC389* L_17 = ___list0;
G_B6_0 = ((((int32_t)((((int32_t)L_16) < ((int32_t)((int32_t)(((RuntimeArray*)L_17)->max_length))))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0064;
}
IL_0063:
{
G_B6_0 = 1;
}
IL_0064:
{
V_2 = (bool)G_B6_0;
bool L_18 = V_2;
if (!L_18)
{
goto IL_0077;
}
}
{
il2cpp_codegen_runtime_class_init_inline(Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
Debug_LogError_m059825802BB6AF7EA9693FEBEEB0D85F59A3E38E((RuntimeObject*)_stringLiteralC472776C9180B19630B6E4112538D935B62E3F35, NULL);
goto IL_0086;
}
IL_0077:
{
ColorU5BU5D_t612261CF293F6FFC3D80AB52259FF0DC2B2CC389* L_19 = ___list0;
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_20 = ___handle2;
int32_t L_21 = (int32_t)L_20.___valueIndex_1;
int32_t L_22 = L_21;
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F L_23 = (L_19)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_22));
V_0 = L_23;
}
IL_0086:
{
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F L_24 = V_0;
V_3 = L_24;
goto IL_008a;
}
IL_008a:
{
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F L_25 = V_3;
return L_25;
}
}
// T UnityEngine.UIElements.StyleSheet::CheckAccess<UnityEngine.UIElements.StyleSheets.Dimension>(T[],UnityEngine.UIElements.StyleValueType,UnityEngine.UIElements.StyleValueHandle)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8 StyleSheet_CheckAccess_TisDimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8_m7F7E5CCFEEF4D1E030D63B9F3A7CA4326EC93388_gshared (DimensionU5BU5D_t1EE1B3F9368D444E779CAB3E1CBD9959F8762F4B* ___list0, int32_t ___type1, StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D ___handle2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteralC472776C9180B19630B6E4112538D935B62E3F35);
s_Il2CppMethodInitialized = true;
}
Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8 V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
bool V_2 = false;
Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8 V_3;
memset((&V_3), 0, sizeof(V_3));
int32_t G_B6_0 = 0;
{
il2cpp_codegen_initobj((&V_0), sizeof(Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8));
int32_t L_0;
L_0 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_1 = ___type1;
V_1 = (bool)((((int32_t)((((int32_t)L_0) == ((int32_t)L_1))? 1 : 0)) == ((int32_t)0))? 1 : 0);
bool L_2 = V_1;
if (!L_2)
{
goto IL_0047;
}
}
{
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_3 = (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)SZArrayNew(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_4 = L_3;
int32_t L_5 = ___type1;
int32_t L_6 = L_5;
RuntimeObject* L_7 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_6);
ArrayElementTypeCheck (L_4, L_7);
(L_4)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (RuntimeObject*)L_7);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_8 = L_4;
int32_t L_9;
L_9 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_10 = L_9;
RuntimeObject* L_11 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_10);
ArrayElementTypeCheck (L_8, L_11);
(L_8)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (RuntimeObject*)L_11);
il2cpp_codegen_runtime_class_init_inline(Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
Debug_LogErrorFormat_mA33C95EF832A60D72A7EE26074E13A86BE7E30C6(_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207, L_8, NULL);
goto IL_0086;
}
IL_0047:
{
DimensionU5BU5D_t1EE1B3F9368D444E779CAB3E1CBD9959F8762F4B* L_12 = ___list0;
if (!L_12)
{
goto IL_0063;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_13 = ___handle2;
int32_t L_14 = (int32_t)L_13.___valueIndex_1;
if ((((int32_t)L_14) < ((int32_t)0)))
{
goto IL_0063;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_15 = ___handle2;
int32_t L_16 = (int32_t)L_15.___valueIndex_1;
DimensionU5BU5D_t1EE1B3F9368D444E779CAB3E1CBD9959F8762F4B* L_17 = ___list0;
G_B6_0 = ((((int32_t)((((int32_t)L_16) < ((int32_t)((int32_t)(((RuntimeArray*)L_17)->max_length))))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0064;
}
IL_0063:
{
G_B6_0 = 1;
}
IL_0064:
{
V_2 = (bool)G_B6_0;
bool L_18 = V_2;
if (!L_18)
{
goto IL_0077;
}
}
{
il2cpp_codegen_runtime_class_init_inline(Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
Debug_LogError_m059825802BB6AF7EA9693FEBEEB0D85F59A3E38E((RuntimeObject*)_stringLiteralC472776C9180B19630B6E4112538D935B62E3F35, NULL);
goto IL_0086;
}
IL_0077:
{
DimensionU5BU5D_t1EE1B3F9368D444E779CAB3E1CBD9959F8762F4B* L_19 = ___list0;
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_20 = ___handle2;
int32_t L_21 = (int32_t)L_20.___valueIndex_1;
int32_t L_22 = L_21;
Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8 L_23 = (L_19)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_22));
V_0 = L_23;
}
IL_0086:
{
Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8 L_24 = V_0;
V_3 = L_24;
goto IL_008a;
}
IL_008a:
{
Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8 L_25 = V_3;
return L_25;
}
}
// T UnityEngine.UIElements.StyleSheet::CheckAccess<System.Object>(T[],UnityEngine.UIElements.StyleValueType,UnityEngine.UIElements.StyleValueHandle)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* StyleSheet_CheckAccess_TisRuntimeObject_m9D9D724373E2EB15E7EF0B8F2C95DE5DA33E5168_gshared (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* ___list0, int32_t ___type1, StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D ___handle2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteralC472776C9180B19630B6E4112538D935B62E3F35);
s_Il2CppMethodInitialized = true;
}
RuntimeObject* V_0 = NULL;
bool V_1 = false;
bool V_2 = false;
RuntimeObject* V_3 = NULL;
int32_t G_B6_0 = 0;
{
il2cpp_codegen_initobj((&V_0), sizeof(RuntimeObject*));
int32_t L_0;
L_0 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_1 = ___type1;
V_1 = (bool)((((int32_t)((((int32_t)L_0) == ((int32_t)L_1))? 1 : 0)) == ((int32_t)0))? 1 : 0);
bool L_2 = V_1;
if (!L_2)
{
goto IL_0047;
}
}
{
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_3 = (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)SZArrayNew(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_4 = L_3;
int32_t L_5 = ___type1;
int32_t L_6 = L_5;
RuntimeObject* L_7 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_6);
ArrayElementTypeCheck (L_4, L_7);
(L_4)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (RuntimeObject*)L_7);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_8 = L_4;
int32_t L_9;
L_9 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_10 = L_9;
RuntimeObject* L_11 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_10);
ArrayElementTypeCheck (L_8, L_11);
(L_8)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (RuntimeObject*)L_11);
il2cpp_codegen_runtime_class_init_inline(Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
Debug_LogErrorFormat_mA33C95EF832A60D72A7EE26074E13A86BE7E30C6(_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207, L_8, NULL);
goto IL_0086;
}
IL_0047:
{
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_12 = ___list0;
if (!L_12)
{
goto IL_0063;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_13 = ___handle2;
int32_t L_14 = (int32_t)L_13.___valueIndex_1;
if ((((int32_t)L_14) < ((int32_t)0)))
{
goto IL_0063;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_15 = ___handle2;
int32_t L_16 = (int32_t)L_15.___valueIndex_1;
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_17 = ___list0;
G_B6_0 = ((((int32_t)((((int32_t)L_16) < ((int32_t)((int32_t)(((RuntimeArray*)L_17)->max_length))))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0064;
}
IL_0063:
{
G_B6_0 = 1;
}
IL_0064:
{
V_2 = (bool)G_B6_0;
bool L_18 = V_2;
if (!L_18)
{
goto IL_0077;
}
}
{
il2cpp_codegen_runtime_class_init_inline(Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
Debug_LogError_m059825802BB6AF7EA9693FEBEEB0D85F59A3E38E((RuntimeObject*)_stringLiteralC472776C9180B19630B6E4112538D935B62E3F35, NULL);
goto IL_0086;
}
IL_0077:
{
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_19 = ___list0;
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_20 = ___handle2;
int32_t L_21 = (int32_t)L_20.___valueIndex_1;
int32_t L_22 = L_21;
RuntimeObject* L_23 = (L_19)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_22));
V_0 = L_23;
}
IL_0086:
{
RuntimeObject* L_24 = V_0;
V_3 = L_24;
goto IL_008a;
}
IL_008a:
{
RuntimeObject* L_25 = V_3;
return L_25;
}
}
// T UnityEngine.UIElements.StyleSheet::CheckAccess<UnityEngine.UIElements.StyleSheets.ScalableImage>(T[],UnityEngine.UIElements.StyleValueType,UnityEngine.UIElements.StyleValueHandle)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F StyleSheet_CheckAccess_TisScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F_m8F9C7866AC90BBF23F5B6196FFD7157BAEFD3B8B_gshared (ScalableImageU5BU5D_t8C989174900062AED19A057FDCF0529F8C594A52* ___list0, int32_t ___type1, StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D ___handle2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteralC472776C9180B19630B6E4112538D935B62E3F35);
s_Il2CppMethodInitialized = true;
}
ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
bool V_2 = false;
ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F V_3;
memset((&V_3), 0, sizeof(V_3));
int32_t G_B6_0 = 0;
{
il2cpp_codegen_initobj((&V_0), sizeof(ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F));
int32_t L_0;
L_0 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_1 = ___type1;
V_1 = (bool)((((int32_t)((((int32_t)L_0) == ((int32_t)L_1))? 1 : 0)) == ((int32_t)0))? 1 : 0);
bool L_2 = V_1;
if (!L_2)
{
goto IL_0047;
}
}
{
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_3 = (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)SZArrayNew(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_4 = L_3;
int32_t L_5 = ___type1;
int32_t L_6 = L_5;
RuntimeObject* L_7 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_6);
ArrayElementTypeCheck (L_4, L_7);
(L_4)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (RuntimeObject*)L_7);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_8 = L_4;
int32_t L_9;
L_9 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_10 = L_9;
RuntimeObject* L_11 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_10);
ArrayElementTypeCheck (L_8, L_11);
(L_8)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (RuntimeObject*)L_11);
il2cpp_codegen_runtime_class_init_inline(Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
Debug_LogErrorFormat_mA33C95EF832A60D72A7EE26074E13A86BE7E30C6(_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207, L_8, NULL);
goto IL_0086;
}
IL_0047:
{
ScalableImageU5BU5D_t8C989174900062AED19A057FDCF0529F8C594A52* L_12 = ___list0;
if (!L_12)
{
goto IL_0063;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_13 = ___handle2;
int32_t L_14 = (int32_t)L_13.___valueIndex_1;
if ((((int32_t)L_14) < ((int32_t)0)))
{
goto IL_0063;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_15 = ___handle2;
int32_t L_16 = (int32_t)L_15.___valueIndex_1;
ScalableImageU5BU5D_t8C989174900062AED19A057FDCF0529F8C594A52* L_17 = ___list0;
G_B6_0 = ((((int32_t)((((int32_t)L_16) < ((int32_t)((int32_t)(((RuntimeArray*)L_17)->max_length))))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0064;
}
IL_0063:
{
G_B6_0 = 1;
}
IL_0064:
{
V_2 = (bool)G_B6_0;
bool L_18 = V_2;
if (!L_18)
{
goto IL_0077;
}
}
{
il2cpp_codegen_runtime_class_init_inline(Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
Debug_LogError_m059825802BB6AF7EA9693FEBEEB0D85F59A3E38E((RuntimeObject*)_stringLiteralC472776C9180B19630B6E4112538D935B62E3F35, NULL);
goto IL_0086;
}
IL_0077:
{
ScalableImageU5BU5D_t8C989174900062AED19A057FDCF0529F8C594A52* L_19 = ___list0;
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_20 = ___handle2;
int32_t L_21 = (int32_t)L_20.___valueIndex_1;
int32_t L_22 = L_21;
ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F L_23 = (L_19)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_22));
V_0 = L_23;
}
IL_0086:
{
ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F L_24 = V_0;
V_3 = L_24;
goto IL_008a;
}
IL_008a:
{
ScalableImage_t64F0F6F75D1099EF5D595E70CA1A2A7B9914E80F L_25 = V_3;
return L_25;
}
}
// T UnityEngine.UIElements.StyleSheet::CheckAccess<System.Single>(T[],UnityEngine.UIElements.StyleValueType,UnityEngine.UIElements.StyleValueHandle)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float StyleSheet_CheckAccess_TisSingle_t4530F2FF86FCB0DC29F35385CA1BD21BE294761C_mF7A39FC5324F01CAB2EC9117DA2E7EC6BC47DF4F_gshared (SingleU5BU5D_t89DEFE97BCEDB5857010E79ECE0F52CF6E93B87C* ___list0, int32_t ___type1, StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D ___handle2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteralC472776C9180B19630B6E4112538D935B62E3F35);
s_Il2CppMethodInitialized = true;
}
float V_0 = 0.0f;
bool V_1 = false;
bool V_2 = false;
float V_3 = 0.0f;
int32_t G_B6_0 = 0;
{
il2cpp_codegen_initobj((&V_0), sizeof(float));
int32_t L_0;
L_0 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_1 = ___type1;
V_1 = (bool)((((int32_t)((((int32_t)L_0) == ((int32_t)L_1))? 1 : 0)) == ((int32_t)0))? 1 : 0);
bool L_2 = V_1;
if (!L_2)
{
goto IL_0047;
}
}
{
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_3 = (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)SZArrayNew(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_4 = L_3;
int32_t L_5 = ___type1;
int32_t L_6 = L_5;
RuntimeObject* L_7 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_6);
ArrayElementTypeCheck (L_4, L_7);
(L_4)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (RuntimeObject*)L_7);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_8 = L_4;
int32_t L_9;
L_9 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_10 = L_9;
RuntimeObject* L_11 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_10);
ArrayElementTypeCheck (L_8, L_11);
(L_8)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (RuntimeObject*)L_11);
il2cpp_codegen_runtime_class_init_inline(Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
Debug_LogErrorFormat_mA33C95EF832A60D72A7EE26074E13A86BE7E30C6(_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207, L_8, NULL);
goto IL_0086;
}
IL_0047:
{
SingleU5BU5D_t89DEFE97BCEDB5857010E79ECE0F52CF6E93B87C* L_12 = ___list0;
if (!L_12)
{
goto IL_0063;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_13 = ___handle2;
int32_t L_14 = (int32_t)L_13.___valueIndex_1;
if ((((int32_t)L_14) < ((int32_t)0)))
{
goto IL_0063;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_15 = ___handle2;
int32_t L_16 = (int32_t)L_15.___valueIndex_1;
SingleU5BU5D_t89DEFE97BCEDB5857010E79ECE0F52CF6E93B87C* L_17 = ___list0;
G_B6_0 = ((((int32_t)((((int32_t)L_16) < ((int32_t)((int32_t)(((RuntimeArray*)L_17)->max_length))))? 1 : 0)) == ((int32_t)0))? 1 : 0);
goto IL_0064;
}
IL_0063:
{
G_B6_0 = 1;
}
IL_0064:
{
V_2 = (bool)G_B6_0;
bool L_18 = V_2;
if (!L_18)
{
goto IL_0077;
}
}
{
il2cpp_codegen_runtime_class_init_inline(Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
Debug_LogError_m059825802BB6AF7EA9693FEBEEB0D85F59A3E38E((RuntimeObject*)_stringLiteralC472776C9180B19630B6E4112538D935B62E3F35, NULL);
goto IL_0086;
}
IL_0077:
{
SingleU5BU5D_t89DEFE97BCEDB5857010E79ECE0F52CF6E93B87C* L_19 = ___list0;
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_20 = ___handle2;
int32_t L_21 = (int32_t)L_20.___valueIndex_1;
int32_t L_22 = L_21;
float L_23 = (L_19)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_22));
V_0 = L_23;
}
IL_0086:
{
float L_24 = V_0;
V_3 = L_24;
goto IL_008a;
}
IL_008a:
{
float L_25 = V_3;
return L_25;
}
}
// System.Boolean UnityEngine.UIElements.StyleSheet::TryCheckAccess<UnityEngine.Color>(T[],UnityEngine.UIElements.StyleValueType,UnityEngine.UIElements.StyleValueHandle,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StyleSheet_TryCheckAccess_TisColor_tD001788D726C3A7F1379BEED0260B9591F440C1F_mE333C1C8F915C3DCE13BD22B427E442B74AD8748_gshared (ColorU5BU5D_t612261CF293F6FFC3D80AB52259FF0DC2B2CC389* ___list0, int32_t ___type1, StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D ___handle2, Color_tD001788D726C3A7F1379BEED0260B9591F440C1F* ___value3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
bool V_2 = false;
int32_t G_B4_0 = 0;
{
V_0 = (bool)0;
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F* L_0 = ___value3;
il2cpp_codegen_initobj(L_0, sizeof(Color_tD001788D726C3A7F1379BEED0260B9591F440C1F));
int32_t L_1;
L_1 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_2 = ___type1;
if ((!(((uint32_t)L_1) == ((uint32_t)L_2))))
{
goto IL_002a;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_3 = ___handle2;
int32_t L_4 = (int32_t)L_3.___valueIndex_1;
if ((((int32_t)L_4) < ((int32_t)0)))
{
goto IL_002a;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_5 = ___handle2;
int32_t L_6 = (int32_t)L_5.___valueIndex_1;
ColorU5BU5D_t612261CF293F6FFC3D80AB52259FF0DC2B2CC389* L_7 = ___list0;
G_B4_0 = ((((int32_t)L_6) < ((int32_t)((int32_t)(((RuntimeArray*)L_7)->max_length))))? 1 : 0);
goto IL_002b;
}
IL_002a:
{
G_B4_0 = 0;
}
IL_002b:
{
V_1 = (bool)G_B4_0;
bool L_8 = V_1;
if (!L_8)
{
goto IL_0047;
}
}
{
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F* L_9 = ___value3;
ColorU5BU5D_t612261CF293F6FFC3D80AB52259FF0DC2B2CC389* L_10 = ___list0;
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_11 = ___handle2;
int32_t L_12 = (int32_t)L_11.___valueIndex_1;
int32_t L_13 = L_12;
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F L_14 = (L_10)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_13));
*(Color_tD001788D726C3A7F1379BEED0260B9591F440C1F*)L_9 = L_14;
V_0 = (bool)1;
goto IL_0072;
}
IL_0047:
{
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_15 = (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)SZArrayNew(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_16 = L_15;
int32_t L_17 = ___type1;
int32_t L_18 = L_17;
RuntimeObject* L_19 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_18);
ArrayElementTypeCheck (L_16, L_19);
(L_16)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (RuntimeObject*)L_19);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_20 = L_16;
int32_t L_21;
L_21 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_22 = L_21;
RuntimeObject* L_23 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_22);
ArrayElementTypeCheck (L_20, L_23);
(L_20)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (RuntimeObject*)L_23);
il2cpp_codegen_runtime_class_init_inline(Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
Debug_LogErrorFormat_mA33C95EF832A60D72A7EE26074E13A86BE7E30C6(_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207, L_20, NULL);
}
IL_0072:
{
bool L_24 = V_0;
V_2 = L_24;
goto IL_0076;
}
IL_0076:
{
bool L_25 = V_2;
return L_25;
}
}
// System.Boolean UnityEngine.UIElements.StyleSheet::TryCheckAccess<UnityEngine.UIElements.StyleSheets.Dimension>(T[],UnityEngine.UIElements.StyleValueType,UnityEngine.UIElements.StyleValueHandle,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StyleSheet_TryCheckAccess_TisDimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8_m081318AFACE293559AA0637A669052626B1A76E8_gshared (DimensionU5BU5D_t1EE1B3F9368D444E779CAB3E1CBD9959F8762F4B* ___list0, int32_t ___type1, StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D ___handle2, Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8* ___value3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
bool V_2 = false;
int32_t G_B4_0 = 0;
{
V_0 = (bool)0;
Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8* L_0 = ___value3;
il2cpp_codegen_initobj(L_0, sizeof(Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8));
int32_t L_1;
L_1 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_2 = ___type1;
if ((!(((uint32_t)L_1) == ((uint32_t)L_2))))
{
goto IL_002a;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_3 = ___handle2;
int32_t L_4 = (int32_t)L_3.___valueIndex_1;
if ((((int32_t)L_4) < ((int32_t)0)))
{
goto IL_002a;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_5 = ___handle2;
int32_t L_6 = (int32_t)L_5.___valueIndex_1;
DimensionU5BU5D_t1EE1B3F9368D444E779CAB3E1CBD9959F8762F4B* L_7 = ___list0;
G_B4_0 = ((((int32_t)L_6) < ((int32_t)((int32_t)(((RuntimeArray*)L_7)->max_length))))? 1 : 0);
goto IL_002b;
}
IL_002a:
{
G_B4_0 = 0;
}
IL_002b:
{
V_1 = (bool)G_B4_0;
bool L_8 = V_1;
if (!L_8)
{
goto IL_0047;
}
}
{
Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8* L_9 = ___value3;
DimensionU5BU5D_t1EE1B3F9368D444E779CAB3E1CBD9959F8762F4B* L_10 = ___list0;
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_11 = ___handle2;
int32_t L_12 = (int32_t)L_11.___valueIndex_1;
int32_t L_13 = L_12;
Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8 L_14 = (L_10)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_13));
*(Dimension_t5B1EAB500AE32C3789A2BCC4D43F7A29996DF3F8*)L_9 = L_14;
V_0 = (bool)1;
goto IL_0072;
}
IL_0047:
{
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_15 = (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)SZArrayNew(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_16 = L_15;
int32_t L_17 = ___type1;
int32_t L_18 = L_17;
RuntimeObject* L_19 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_18);
ArrayElementTypeCheck (L_16, L_19);
(L_16)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (RuntimeObject*)L_19);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_20 = L_16;
int32_t L_21;
L_21 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_22 = L_21;
RuntimeObject* L_23 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_22);
ArrayElementTypeCheck (L_20, L_23);
(L_20)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (RuntimeObject*)L_23);
il2cpp_codegen_runtime_class_init_inline(Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
Debug_LogErrorFormat_mA33C95EF832A60D72A7EE26074E13A86BE7E30C6(_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207, L_20, NULL);
}
IL_0072:
{
bool L_24 = V_0;
V_2 = L_24;
goto IL_0076;
}
IL_0076:
{
bool L_25 = V_2;
return L_25;
}
}
// System.Boolean UnityEngine.UIElements.StyleSheet::TryCheckAccess<System.Object>(T[],UnityEngine.UIElements.StyleValueType,UnityEngine.UIElements.StyleValueHandle,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StyleSheet_TryCheckAccess_TisRuntimeObject_m8A96906DC2E63E018B1B9C165BBC2A56E9D6F187_gshared (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* ___list0, int32_t ___type1, StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D ___handle2, RuntimeObject** ___value3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
bool V_2 = false;
int32_t G_B4_0 = 0;
{
V_0 = (bool)0;
RuntimeObject** L_0 = ___value3;
il2cpp_codegen_initobj(L_0, sizeof(RuntimeObject*));
int32_t L_1;
L_1 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_2 = ___type1;
if ((!(((uint32_t)L_1) == ((uint32_t)L_2))))
{
goto IL_002a;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_3 = ___handle2;
int32_t L_4 = (int32_t)L_3.___valueIndex_1;
if ((((int32_t)L_4) < ((int32_t)0)))
{
goto IL_002a;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_5 = ___handle2;
int32_t L_6 = (int32_t)L_5.___valueIndex_1;
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_7 = ___list0;
G_B4_0 = ((((int32_t)L_6) < ((int32_t)((int32_t)(((RuntimeArray*)L_7)->max_length))))? 1 : 0);
goto IL_002b;
}
IL_002a:
{
G_B4_0 = 0;
}
IL_002b:
{
V_1 = (bool)G_B4_0;
bool L_8 = V_1;
if (!L_8)
{
goto IL_0047;
}
}
{
RuntimeObject** L_9 = ___value3;
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_10 = ___list0;
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_11 = ___handle2;
int32_t L_12 = (int32_t)L_11.___valueIndex_1;
int32_t L_13 = L_12;
RuntimeObject* L_14 = (L_10)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_13));
*(RuntimeObject**)L_9 = L_14;
Il2CppCodeGenWriteBarrier((void**)(RuntimeObject**)L_9, (void*)L_14);
V_0 = (bool)1;
goto IL_0072;
}
IL_0047:
{
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_15 = (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)SZArrayNew(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_16 = L_15;
int32_t L_17 = ___type1;
int32_t L_18 = L_17;
RuntimeObject* L_19 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_18);
ArrayElementTypeCheck (L_16, L_19);
(L_16)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (RuntimeObject*)L_19);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_20 = L_16;
int32_t L_21;
L_21 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_22 = L_21;
RuntimeObject* L_23 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_22);
ArrayElementTypeCheck (L_20, L_23);
(L_20)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (RuntimeObject*)L_23);
il2cpp_codegen_runtime_class_init_inline(Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
Debug_LogErrorFormat_mA33C95EF832A60D72A7EE26074E13A86BE7E30C6(_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207, L_20, NULL);
}
IL_0072:
{
bool L_24 = V_0;
V_2 = L_24;
goto IL_0076;
}
IL_0076:
{
bool L_25 = V_2;
return L_25;
}
}
// System.Boolean UnityEngine.UIElements.StyleSheet::TryCheckAccess<System.Single>(T[],UnityEngine.UIElements.StyleValueType,UnityEngine.UIElements.StyleValueHandle,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool StyleSheet_TryCheckAccess_TisSingle_t4530F2FF86FCB0DC29F35385CA1BD21BE294761C_m196CB78CD695C1EB8B860CC012E05A81BC11C1DA_gshared (SingleU5BU5D_t89DEFE97BCEDB5857010E79ECE0F52CF6E93B87C* ___list0, int32_t ___type1, StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D ___handle2, float* ___value3, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207);
s_Il2CppMethodInitialized = true;
}
bool V_0 = false;
bool V_1 = false;
bool V_2 = false;
int32_t G_B4_0 = 0;
{
V_0 = (bool)0;
float* L_0 = ___value3;
il2cpp_codegen_initobj(L_0, sizeof(float));
int32_t L_1;
L_1 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_2 = ___type1;
if ((!(((uint32_t)L_1) == ((uint32_t)L_2))))
{
goto IL_002a;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_3 = ___handle2;
int32_t L_4 = (int32_t)L_3.___valueIndex_1;
if ((((int32_t)L_4) < ((int32_t)0)))
{
goto IL_002a;
}
}
{
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_5 = ___handle2;
int32_t L_6 = (int32_t)L_5.___valueIndex_1;
SingleU5BU5D_t89DEFE97BCEDB5857010E79ECE0F52CF6E93B87C* L_7 = ___list0;
G_B4_0 = ((((int32_t)L_6) < ((int32_t)((int32_t)(((RuntimeArray*)L_7)->max_length))))? 1 : 0);
goto IL_002b;
}
IL_002a:
{
G_B4_0 = 0;
}
IL_002b:
{
V_1 = (bool)G_B4_0;
bool L_8 = V_1;
if (!L_8)
{
goto IL_0047;
}
}
{
float* L_9 = ___value3;
SingleU5BU5D_t89DEFE97BCEDB5857010E79ECE0F52CF6E93B87C* L_10 = ___list0;
StyleValueHandle_t5831643AAA7AD8C5C43A4498C5E0A2545F78227D L_11 = ___handle2;
int32_t L_12 = (int32_t)L_11.___valueIndex_1;
int32_t L_13 = L_12;
float L_14 = (L_10)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_13));
*(float*)L_9 = L_14;
V_0 = (bool)1;
goto IL_0072;
}
IL_0047:
{
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_15 = (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)SZArrayNew(ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918_il2cpp_TypeInfo_var, (uint32_t)2);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_16 = L_15;
int32_t L_17 = ___type1;
int32_t L_18 = L_17;
RuntimeObject* L_19 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_18);
ArrayElementTypeCheck (L_16, L_19);
(L_16)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (RuntimeObject*)L_19);
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_20 = L_16;
int32_t L_21;
L_21 = StyleValueHandle_get_valueType_m4FC4142350A61A75D5CD80C559689A5CC2F741B9((&___handle2), NULL);
int32_t L_22 = L_21;
RuntimeObject* L_23 = Box(StyleValueType_tC3253FE046DBB95224A74D13B534D015CC4AADDE_il2cpp_TypeInfo_var, &L_22);
ArrayElementTypeCheck (L_20, L_23);
(L_20)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (RuntimeObject*)L_23);
il2cpp_codegen_runtime_class_init_inline(Debug_t8394C7EEAECA3689C2C9B9DE9C7166D73596276F_il2cpp_TypeInfo_var);
Debug_LogErrorFormat_mA33C95EF832A60D72A7EE26074E13A86BE7E30C6(_stringLiteral0A452795E040C66D151B05EE8648BF3F8016F207, L_20, NULL);
}
IL_0072:
{
bool L_24 = V_0;
V_2 = L_24;
goto IL_0076;
}
IL_0076:
{
bool L_25 = V_2;
return L_25;
}
}
// System.Void UnityEngine.UIElements.StyleValueExtensions::CopyFrom<UnityEngine.UIElements.EasingFunction>(System.Collections.Generic.List`1<T>,System.Collections.Generic.List`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StyleValueExtensions_CopyFrom_TisEasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4_mF7DF2FE58E70939B584C1311E92FC84F1327D827_gshared (List_1_tE7FB077B3CEA6371A27F72CC60962491AB71490B* ___list0, List_1_tE7FB077B3CEA6371A27F72CC60962491AB71490B* ___other1, const RuntimeMethod* method)
{
{
List_1_tE7FB077B3CEA6371A27F72CC60962491AB71490B* L_0 = ___list0;
(( void (*) (List_1_tE7FB077B3CEA6371A27F72CC60962491AB71490B*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
List_1_tE7FB077B3CEA6371A27F72CC60962491AB71490B* L_1 = ___list0;
List_1_tE7FB077B3CEA6371A27F72CC60962491AB71490B* L_2 = ___other1;
(( void (*) (List_1_tE7FB077B3CEA6371A27F72CC60962491AB71490B*, RuntimeObject*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(L_1, (RuntimeObject*)L_2, il2cpp_rgctx_method(method->rgctx_data, 2));
return;
}
}
// System.Void UnityEngine.UIElements.StyleValueExtensions::CopyFrom<System.Object>(System.Collections.Generic.List`1<T>,System.Collections.Generic.List`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StyleValueExtensions_CopyFrom_TisRuntimeObject_m070F0FC8BF9FEE13DF8CF9679B3580322FEB7CE0_gshared (List_1_tA239CB83DE5615F348BB0507E45F490F4F7C9A8D* ___list0, List_1_tA239CB83DE5615F348BB0507E45F490F4F7C9A8D* ___other1, const RuntimeMethod* method)
{
{
List_1_tA239CB83DE5615F348BB0507E45F490F4F7C9A8D* L_0 = ___list0;
(( void (*) (List_1_tA239CB83DE5615F348BB0507E45F490F4F7C9A8D*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
List_1_tA239CB83DE5615F348BB0507E45F490F4F7C9A8D* L_1 = ___list0;
List_1_tA239CB83DE5615F348BB0507E45F490F4F7C9A8D* L_2 = ___other1;
(( void (*) (List_1_tA239CB83DE5615F348BB0507E45F490F4F7C9A8D*, RuntimeObject*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(L_1, (RuntimeObject*)L_2, il2cpp_rgctx_method(method->rgctx_data, 2));
return;
}
}
// System.Void UnityEngine.UIElements.StyleValueExtensions::CopyFrom<UnityEngine.UIElements.StylePropertyName>(System.Collections.Generic.List`1<T>,System.Collections.Generic.List`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StyleValueExtensions_CopyFrom_TisStylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF_mF8602565341B45ADF061DA4D414FC6E9641E22A8_gshared (List_1_tD6F1685FEE5A196B3002ACC649A1DF5C65162268* ___list0, List_1_tD6F1685FEE5A196B3002ACC649A1DF5C65162268* ___other1, const RuntimeMethod* method)
{
{
List_1_tD6F1685FEE5A196B3002ACC649A1DF5C65162268* L_0 = ___list0;
(( void (*) (List_1_tD6F1685FEE5A196B3002ACC649A1DF5C65162268*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
List_1_tD6F1685FEE5A196B3002ACC649A1DF5C65162268* L_1 = ___list0;
List_1_tD6F1685FEE5A196B3002ACC649A1DF5C65162268* L_2 = ___other1;
(( void (*) (List_1_tD6F1685FEE5A196B3002ACC649A1DF5C65162268*, RuntimeObject*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(L_1, (RuntimeObject*)L_2, il2cpp_rgctx_method(method->rgctx_data, 2));
return;
}
}
// System.Void UnityEngine.UIElements.StyleValueExtensions::CopyFrom<UnityEngine.UIElements.TimeValue>(System.Collections.Generic.List`1<T>,System.Collections.Generic.List`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void StyleValueExtensions_CopyFrom_TisTimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E_mBDD9ABA05446168B89753E32F6683384A2E73ACB_gshared (List_1_t437B6C3879E969156A381BDC3C459CF809D39DDF* ___list0, List_1_t437B6C3879E969156A381BDC3C459CF809D39DDF* ___other1, const RuntimeMethod* method)
{
{
List_1_t437B6C3879E969156A381BDC3C459CF809D39DDF* L_0 = ___list0;
(( void (*) (List_1_t437B6C3879E969156A381BDC3C459CF809D39DDF*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
List_1_t437B6C3879E969156A381BDC3C459CF809D39DDF* L_1 = ___list0;
List_1_t437B6C3879E969156A381BDC3C459CF809D39DDF* L_2 = ___other1;
(( void (*) (List_1_t437B6C3879E969156A381BDC3C459CF809D39DDF*, RuntimeObject*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(L_1, (RuntimeObject*)L_2, il2cpp_rgctx_method(method->rgctx_data, 2));
return;
}
}
// System.String UnityEngine.UIElements.StyleValueExtensions::DebugString<UnityEngine.Color>(UnityEngine.UIElements.IStyleValue`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* StyleValueExtensions_DebugString_TisColor_tD001788D726C3A7F1379BEED0260B9591F440C1F_m75AB7542B96BDE599ADA1EB272EBBB1375FD922C_gshared (RuntimeObject* ___styleValue0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* G_B3_0 = NULL;
{
RuntimeObject* L_0 = ___styleValue0;
int32_t L_1;
L_1 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.Color>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_0);
if (L_1)
{
goto IL_0020;
}
}
{
RuntimeObject* L_2 = ___styleValue0;
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F L_3;
L_3 = InterfaceFuncInvoker0< Color_tD001788D726C3A7F1379BEED0260B9591F440C1F >::Invoke(0 /* T UnityEngine.UIElements.IStyleValue`1<UnityEngine.Color>::get_value() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_2);
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F L_4 = L_3;
RuntimeObject* L_5 = Box(il2cpp_rgctx_data(method->rgctx_data, 3), &L_4);
String_t* L_6;
L_6 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_5, NULL);
G_B3_0 = L_6;
goto IL_0035;
}
IL_0020:
{
RuntimeObject* L_7 = ___styleValue0;
int32_t L_8;
L_8 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.Color>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_7);
int32_t L_9 = L_8;
RuntimeObject* L_10 = Box(StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var, &L_9);
String_t* L_11;
L_11 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_10, NULL);
G_B3_0 = L_11;
}
IL_0035:
{
V_0 = G_B3_0;
goto IL_0038;
}
IL_0038:
{
String_t* L_12 = V_0;
return L_12;
}
}
// System.String UnityEngine.UIElements.StyleValueExtensions::DebugString<UnityEngine.UIElements.Cursor>(UnityEngine.UIElements.IStyleValue`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* StyleValueExtensions_DebugString_TisCursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82_m4C1F96E64C62B12E7BE12B70FAD37732AB15D5E8_gshared (RuntimeObject* ___styleValue0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* G_B3_0 = NULL;
{
RuntimeObject* L_0 = ___styleValue0;
int32_t L_1;
L_1 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Cursor>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_0);
if (L_1)
{
goto IL_0020;
}
}
{
RuntimeObject* L_2 = ___styleValue0;
Cursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82 L_3;
L_3 = InterfaceFuncInvoker0< Cursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82 >::Invoke(0 /* T UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Cursor>::get_value() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_2);
Cursor_t24C3B5095F65B86794C4F7EA168E324DFDA9EE82 L_4 = L_3;
RuntimeObject* L_5 = Box(il2cpp_rgctx_data(method->rgctx_data, 3), &L_4);
String_t* L_6;
L_6 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_5, NULL);
G_B3_0 = L_6;
goto IL_0035;
}
IL_0020:
{
RuntimeObject* L_7 = ___styleValue0;
int32_t L_8;
L_8 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Cursor>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_7);
int32_t L_9 = L_8;
RuntimeObject* L_10 = Box(StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var, &L_9);
String_t* L_11;
L_11 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_10, NULL);
G_B3_0 = L_11;
}
IL_0035:
{
V_0 = G_B3_0;
goto IL_0038;
}
IL_0038:
{
String_t* L_12 = V_0;
return L_12;
}
}
// System.String UnityEngine.UIElements.StyleValueExtensions::DebugString<System.Int32>(UnityEngine.UIElements.IStyleValue`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* StyleValueExtensions_DebugString_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_m85E676FA9A75CB2CB1A6CB9A91219A61D3F4223E_gshared (RuntimeObject* ___styleValue0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* G_B3_0 = NULL;
{
RuntimeObject* L_0 = ___styleValue0;
int32_t L_1;
L_1 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<System.Int32>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_0);
if (L_1)
{
goto IL_0020;
}
}
{
RuntimeObject* L_2 = ___styleValue0;
int32_t L_3;
L_3 = InterfaceFuncInvoker0< int32_t >::Invoke(0 /* T UnityEngine.UIElements.IStyleValue`1<System.Int32>::get_value() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_2);
int32_t L_4 = L_3;
RuntimeObject* L_5 = Box(il2cpp_rgctx_data(method->rgctx_data, 3), &L_4);
String_t* L_6;
L_6 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_5, NULL);
G_B3_0 = L_6;
goto IL_0035;
}
IL_0020:
{
RuntimeObject* L_7 = ___styleValue0;
int32_t L_8;
L_8 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<System.Int32>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_7);
int32_t L_9 = L_8;
RuntimeObject* L_10 = Box(StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var, &L_9);
String_t* L_11;
L_11 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_10, NULL);
G_B3_0 = L_11;
}
IL_0035:
{
V_0 = G_B3_0;
goto IL_0038;
}
IL_0038:
{
String_t* L_12 = V_0;
return L_12;
}
}
// System.String UnityEngine.UIElements.StyleValueExtensions::DebugString<System.Int32Enum>(UnityEngine.UIElements.IStyleValue`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* StyleValueExtensions_DebugString_TisInt32Enum_tCBAC8BA2BFF3A845FA599F303093BBBA374B6F0C_m3A5748EF5106669EFFC8DBBAA5911B6683D5FBB0_gshared (RuntimeObject* ___styleValue0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* G_B3_0 = NULL;
{
RuntimeObject* L_0 = ___styleValue0;
int32_t L_1;
L_1 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<System.Int32Enum>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_0);
if (L_1)
{
goto IL_0020;
}
}
{
RuntimeObject* L_2 = ___styleValue0;
int32_t L_3;
L_3 = InterfaceFuncInvoker0< int32_t >::Invoke(0 /* T UnityEngine.UIElements.IStyleValue`1<System.Int32Enum>::get_value() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_2);
int32_t L_4 = L_3;
RuntimeObject* L_5 = Box(il2cpp_rgctx_data(method->rgctx_data, 3), &L_4);
String_t* L_6;
L_6 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_5, NULL);
G_B3_0 = L_6;
goto IL_0035;
}
IL_0020:
{
RuntimeObject* L_7 = ___styleValue0;
int32_t L_8;
L_8 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<System.Int32Enum>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_7);
int32_t L_9 = L_8;
RuntimeObject* L_10 = Box(StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var, &L_9);
String_t* L_11;
L_11 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_10, NULL);
G_B3_0 = L_11;
}
IL_0035:
{
V_0 = G_B3_0;
goto IL_0038;
}
IL_0038:
{
String_t* L_12 = V_0;
return L_12;
}
}
// System.String UnityEngine.UIElements.StyleValueExtensions::DebugString<UnityEngine.UIElements.Length>(UnityEngine.UIElements.IStyleValue`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* StyleValueExtensions_DebugString_TisLength_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256_mC09C0AFC32DCC3C8BEA41F26B44B3A35BA425E5A_gshared (RuntimeObject* ___styleValue0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* G_B3_0 = NULL;
{
RuntimeObject* L_0 = ___styleValue0;
int32_t L_1;
L_1 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Length>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_0);
if (L_1)
{
goto IL_0020;
}
}
{
RuntimeObject* L_2 = ___styleValue0;
Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 L_3;
L_3 = InterfaceFuncInvoker0< Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 >::Invoke(0 /* T UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Length>::get_value() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_2);
Length_t90BB06D47DD6DB461ED21BD3E3241FAB6C824256 L_4 = L_3;
RuntimeObject* L_5 = Box(il2cpp_rgctx_data(method->rgctx_data, 3), &L_4);
String_t* L_6;
L_6 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_5, NULL);
G_B3_0 = L_6;
goto IL_0035;
}
IL_0020:
{
RuntimeObject* L_7 = ___styleValue0;
int32_t L_8;
L_8 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Length>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_7);
int32_t L_9 = L_8;
RuntimeObject* L_10 = Box(StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var, &L_9);
String_t* L_11;
L_11 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_10, NULL);
G_B3_0 = L_11;
}
IL_0035:
{
V_0 = G_B3_0;
goto IL_0038;
}
IL_0038:
{
String_t* L_12 = V_0;
return L_12;
}
}
// System.String UnityEngine.UIElements.StyleValueExtensions::DebugString<System.Object>(UnityEngine.UIElements.IStyleValue`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* StyleValueExtensions_DebugString_TisRuntimeObject_m9AD0A95E8DCC03A9639D60CBBBC4765A93C75CE0_gshared (RuntimeObject* ___styleValue0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* G_B3_0 = NULL;
{
RuntimeObject* L_0 = ___styleValue0;
int32_t L_1;
L_1 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<System.Object>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_0);
if (L_1)
{
goto IL_0020;
}
}
{
RuntimeObject* L_2 = ___styleValue0;
RuntimeObject* L_3;
L_3 = InterfaceFuncInvoker0< RuntimeObject* >::Invoke(0 /* T UnityEngine.UIElements.IStyleValue`1<System.Object>::get_value() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_2);
String_t* L_4;
L_4 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_3, NULL);
G_B3_0 = L_4;
goto IL_0035;
}
IL_0020:
{
RuntimeObject* L_5 = ___styleValue0;
int32_t L_6;
L_6 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<System.Object>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_5);
int32_t L_7 = L_6;
RuntimeObject* L_8 = Box(StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var, &L_7);
String_t* L_9;
L_9 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_8, NULL);
G_B3_0 = L_9;
}
IL_0035:
{
V_0 = G_B3_0;
goto IL_0038;
}
IL_0038:
{
String_t* L_10 = V_0;
return L_10;
}
}
// System.String UnityEngine.UIElements.StyleValueExtensions::DebugString<UnityEngine.UIElements.Rotate>(UnityEngine.UIElements.IStyleValue`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* StyleValueExtensions_DebugString_TisRotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7_m841FA43D948C7F9C669958AD6402C3F3AFCE50CB_gshared (RuntimeObject* ___styleValue0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* G_B3_0 = NULL;
{
RuntimeObject* L_0 = ___styleValue0;
int32_t L_1;
L_1 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Rotate>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_0);
if (L_1)
{
goto IL_0020;
}
}
{
RuntimeObject* L_2 = ___styleValue0;
Rotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7 L_3;
L_3 = InterfaceFuncInvoker0< Rotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7 >::Invoke(0 /* T UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Rotate>::get_value() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_2);
Rotate_tE965CA0281A547AB38B881A3416FF97756D3F4D7 L_4 = L_3;
RuntimeObject* L_5 = Box(il2cpp_rgctx_data(method->rgctx_data, 3), &L_4);
String_t* L_6;
L_6 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_5, NULL);
G_B3_0 = L_6;
goto IL_0035;
}
IL_0020:
{
RuntimeObject* L_7 = ___styleValue0;
int32_t L_8;
L_8 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Rotate>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_7);
int32_t L_9 = L_8;
RuntimeObject* L_10 = Box(StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var, &L_9);
String_t* L_11;
L_11 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_10, NULL);
G_B3_0 = L_11;
}
IL_0035:
{
V_0 = G_B3_0;
goto IL_0038;
}
IL_0038:
{
String_t* L_12 = V_0;
return L_12;
}
}
// System.String UnityEngine.UIElements.StyleValueExtensions::DebugString<UnityEngine.UIElements.Scale>(UnityEngine.UIElements.IStyleValue`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* StyleValueExtensions_DebugString_TisScale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7_mB7DDB20450B8F961F4845FF5E70FA72EB96D9AF6_gshared (RuntimeObject* ___styleValue0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* G_B3_0 = NULL;
{
RuntimeObject* L_0 = ___styleValue0;
int32_t L_1;
L_1 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Scale>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_0);
if (L_1)
{
goto IL_0020;
}
}
{
RuntimeObject* L_2 = ___styleValue0;
Scale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7 L_3;
L_3 = InterfaceFuncInvoker0< Scale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7 >::Invoke(0 /* T UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Scale>::get_value() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_2);
Scale_t5594C69C1AC9398B57ABF6C4FA0D4E791B7A4DC7 L_4 = L_3;
RuntimeObject* L_5 = Box(il2cpp_rgctx_data(method->rgctx_data, 3), &L_4);
String_t* L_6;
L_6 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_5, NULL);
G_B3_0 = L_6;
goto IL_0035;
}
IL_0020:
{
RuntimeObject* L_7 = ___styleValue0;
int32_t L_8;
L_8 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Scale>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_7);
int32_t L_9 = L_8;
RuntimeObject* L_10 = Box(StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var, &L_9);
String_t* L_11;
L_11 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_10, NULL);
G_B3_0 = L_11;
}
IL_0035:
{
V_0 = G_B3_0;
goto IL_0038;
}
IL_0038:
{
String_t* L_12 = V_0;
return L_12;
}
}
// System.String UnityEngine.UIElements.StyleValueExtensions::DebugString<System.Single>(UnityEngine.UIElements.IStyleValue`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* StyleValueExtensions_DebugString_TisSingle_t4530F2FF86FCB0DC29F35385CA1BD21BE294761C_m1CD16BC8E577DBC9A642B15F0B6D923EB2B75FED_gshared (RuntimeObject* ___styleValue0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* G_B3_0 = NULL;
{
RuntimeObject* L_0 = ___styleValue0;
int32_t L_1;
L_1 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<System.Single>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_0);
if (L_1)
{
goto IL_0020;
}
}
{
RuntimeObject* L_2 = ___styleValue0;
float L_3;
L_3 = InterfaceFuncInvoker0< float >::Invoke(0 /* T UnityEngine.UIElements.IStyleValue`1<System.Single>::get_value() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_2);
float L_4 = L_3;
RuntimeObject* L_5 = Box(il2cpp_rgctx_data(method->rgctx_data, 3), &L_4);
String_t* L_6;
L_6 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_5, NULL);
G_B3_0 = L_6;
goto IL_0035;
}
IL_0020:
{
RuntimeObject* L_7 = ___styleValue0;
int32_t L_8;
L_8 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<System.Single>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_7);
int32_t L_9 = L_8;
RuntimeObject* L_10 = Box(StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var, &L_9);
String_t* L_11;
L_11 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_10, NULL);
G_B3_0 = L_11;
}
IL_0035:
{
V_0 = G_B3_0;
goto IL_0038;
}
IL_0038:
{
String_t* L_12 = V_0;
return L_12;
}
}
// System.String UnityEngine.UIElements.StyleValueExtensions::DebugString<UnityEngine.UIElements.TextShadow>(UnityEngine.UIElements.IStyleValue`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* StyleValueExtensions_DebugString_TisTextShadow_t6BADF37AB90ABCB63859A225B58AC5A580950A05_m300F71496F5A363D854EB6F4027E90762EAD27FC_gshared (RuntimeObject* ___styleValue0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* G_B3_0 = NULL;
{
RuntimeObject* L_0 = ___styleValue0;
int32_t L_1;
L_1 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.TextShadow>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_0);
if (L_1)
{
goto IL_0020;
}
}
{
RuntimeObject* L_2 = ___styleValue0;
TextShadow_t6BADF37AB90ABCB63859A225B58AC5A580950A05 L_3;
L_3 = InterfaceFuncInvoker0< TextShadow_t6BADF37AB90ABCB63859A225B58AC5A580950A05 >::Invoke(0 /* T UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.TextShadow>::get_value() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_2);
TextShadow_t6BADF37AB90ABCB63859A225B58AC5A580950A05 L_4 = L_3;
RuntimeObject* L_5 = Box(il2cpp_rgctx_data(method->rgctx_data, 3), &L_4);
String_t* L_6;
L_6 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_5, NULL);
G_B3_0 = L_6;
goto IL_0035;
}
IL_0020:
{
RuntimeObject* L_7 = ___styleValue0;
int32_t L_8;
L_8 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.TextShadow>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_7);
int32_t L_9 = L_8;
RuntimeObject* L_10 = Box(StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var, &L_9);
String_t* L_11;
L_11 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_10, NULL);
G_B3_0 = L_11;
}
IL_0035:
{
V_0 = G_B3_0;
goto IL_0038;
}
IL_0038:
{
String_t* L_12 = V_0;
return L_12;
}
}
// System.String UnityEngine.UIElements.StyleValueExtensions::DebugString<UnityEngine.UIElements.TransformOrigin>(UnityEngine.UIElements.IStyleValue`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* StyleValueExtensions_DebugString_TisTransformOrigin_tD11A368A96C0771398EBB4E6D435318AC0EF8502_mC52A65FA49F5BA6B8B6728788541F26A790FC1FD_gshared (RuntimeObject* ___styleValue0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* G_B3_0 = NULL;
{
RuntimeObject* L_0 = ___styleValue0;
int32_t L_1;
L_1 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.TransformOrigin>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_0);
if (L_1)
{
goto IL_0020;
}
}
{
RuntimeObject* L_2 = ___styleValue0;
TransformOrigin_tD11A368A96C0771398EBB4E6D435318AC0EF8502 L_3;
L_3 = InterfaceFuncInvoker0< TransformOrigin_tD11A368A96C0771398EBB4E6D435318AC0EF8502 >::Invoke(0 /* T UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.TransformOrigin>::get_value() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_2);
TransformOrigin_tD11A368A96C0771398EBB4E6D435318AC0EF8502 L_4 = L_3;
RuntimeObject* L_5 = Box(il2cpp_rgctx_data(method->rgctx_data, 3), &L_4);
String_t* L_6;
L_6 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_5, NULL);
G_B3_0 = L_6;
goto IL_0035;
}
IL_0020:
{
RuntimeObject* L_7 = ___styleValue0;
int32_t L_8;
L_8 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.TransformOrigin>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_7);
int32_t L_9 = L_8;
RuntimeObject* L_10 = Box(StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var, &L_9);
String_t* L_11;
L_11 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_10, NULL);
G_B3_0 = L_11;
}
IL_0035:
{
V_0 = G_B3_0;
goto IL_0038;
}
IL_0038:
{
String_t* L_12 = V_0;
return L_12;
}
}
// System.String UnityEngine.UIElements.StyleValueExtensions::DebugString<UnityEngine.UIElements.Translate>(UnityEngine.UIElements.IStyleValue`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR String_t* StyleValueExtensions_DebugString_TisTranslate_t494F6E802F8A640D67819C9D26BE62DED1218A8E_m4A25D7CBE1EC10BCBE4F5A8FABFCB69EEEA72153_gshared (RuntimeObject* ___styleValue0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94);
s_Il2CppMethodInitialized = true;
}
String_t* V_0 = NULL;
String_t* G_B3_0 = NULL;
{
RuntimeObject* L_0 = ___styleValue0;
int32_t L_1;
L_1 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Translate>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_0);
if (L_1)
{
goto IL_0020;
}
}
{
RuntimeObject* L_2 = ___styleValue0;
Translate_t494F6E802F8A640D67819C9D26BE62DED1218A8E L_3;
L_3 = InterfaceFuncInvoker0< Translate_t494F6E802F8A640D67819C9D26BE62DED1218A8E >::Invoke(0 /* T UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Translate>::get_value() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_2);
Translate_t494F6E802F8A640D67819C9D26BE62DED1218A8E L_4 = L_3;
RuntimeObject* L_5 = Box(il2cpp_rgctx_data(method->rgctx_data, 3), &L_4);
String_t* L_6;
L_6 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_5, NULL);
G_B3_0 = L_6;
goto IL_0035;
}
IL_0020:
{
RuntimeObject* L_7 = ___styleValue0;
int32_t L_8;
L_8 = InterfaceFuncInvoker0< int32_t >::Invoke(1 /* UnityEngine.UIElements.StyleKeyword UnityEngine.UIElements.IStyleValue`1<UnityEngine.UIElements.Translate>::get_keyword() */, il2cpp_rgctx_data(method->rgctx_data, 0), L_7);
int32_t L_9 = L_8;
RuntimeObject* L_10 = Box(StyleKeyword_t2812E72266C15CBA8927586972DC2FD27B10E705_il2cpp_TypeInfo_var, &L_9);
String_t* L_11;
L_11 = String_Format_m8C122B26BC5AA10E2550AECA16E57DAE10F07E30(_stringLiteral23114468D04FA2B7A2DA455B545DB914D0A3ED94, L_10, NULL);
G_B3_0 = L_11;
}
IL_0035:
{
V_0 = G_B3_0;
goto IL_0038;
}
IL_0038:
{
String_t* L_12 = V_0;
return L_12;
}
}
// System.Threading.Tasks.Task`1<TResult> System.Threading.Tasks.Task::FromCancellation<System.Boolean>(System.Threading.CancellationToken)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Task_1_t824317F4B958F7512E8F7300511752937A6C6043* Task_FromCancellation_TisBoolean_t09A6377A54BE2F9E6985A8149F19234FD7DDFE22_m00F2302E3E462922A07E7B2F02F8E7A965EE45B2_gshared (CancellationToken_t51142D9C6D7C02D314DA34A6A7988C528992FFED ___cancellationToken0, const RuntimeMethod* method)
{
bool V_0 = false;
{
bool L_0;
L_0 = CancellationToken_get_IsCancellationRequested_m9744F7A1A82946FDD1DC68E905F1ED826471D350((&___cancellationToken0), NULL);
if (L_0)
{
goto IL_0014;
}
}
{
ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F* L_1 = (ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F*)il2cpp_codegen_object_new(((RuntimeClass*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F_il2cpp_TypeInfo_var)));
ArgumentOutOfRangeException__ctor_mBC1D5DEEA1BA41DE77228CB27D6BAFEB6DCCBF4A(L_1, ((String_t*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&_stringLiteralC4ADC60D7B4D387FB421586A9B670B3D4B8A0775)), NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&Task_FromCancellation_TisBoolean_t09A6377A54BE2F9E6985A8149F19234FD7DDFE22_m00F2302E3E462922A07E7B2F02F8E7A965EE45B2_RuntimeMethod_var)));
}
IL_0014:
{
il2cpp_codegen_initobj((&V_0), sizeof(bool));
bool L_2 = V_0;
CancellationToken_t51142D9C6D7C02D314DA34A6A7988C528992FFED L_3 = ___cancellationToken0;
Task_1_t824317F4B958F7512E8F7300511752937A6C6043* L_4 = (Task_1_t824317F4B958F7512E8F7300511752937A6C6043*)il2cpp_codegen_object_new(il2cpp_rgctx_data(method->rgctx_data, 0));
(( void (*) (Task_1_t824317F4B958F7512E8F7300511752937A6C6043*, bool, bool, int32_t, CancellationToken_t51142D9C6D7C02D314DA34A6A7988C528992FFED, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_4, (bool)1, L_2, (int32_t)0, L_3, il2cpp_rgctx_method(method->rgctx_data, 1));
return L_4;
}
}
// System.Threading.Tasks.Task`1<TResult> System.Threading.Tasks.Task::FromCancellation<System.Object>(System.Threading.CancellationToken)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Task_1_t0C4CD3A5BB93A184420D73218644C56C70FDA7E2* Task_FromCancellation_TisRuntimeObject_m67B91E1DC1B473B7D61E3E95256FD1269E307143_gshared (CancellationToken_t51142D9C6D7C02D314DA34A6A7988C528992FFED ___cancellationToken0, const RuntimeMethod* method)
{
RuntimeObject* V_0 = NULL;
{
bool L_0;
L_0 = CancellationToken_get_IsCancellationRequested_m9744F7A1A82946FDD1DC68E905F1ED826471D350((&___cancellationToken0), NULL);
if (L_0)
{
goto IL_0014;
}
}
{
ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F* L_1 = (ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F*)il2cpp_codegen_object_new(((RuntimeClass*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&ArgumentOutOfRangeException_tEA2822DAF62B10EEED00E0E3A341D4BAF78CF85F_il2cpp_TypeInfo_var)));
ArgumentOutOfRangeException__ctor_mBC1D5DEEA1BA41DE77228CB27D6BAFEB6DCCBF4A(L_1, ((String_t*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&_stringLiteralC4ADC60D7B4D387FB421586A9B670B3D4B8A0775)), NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_1, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&Task_FromCancellation_TisRuntimeObject_m67B91E1DC1B473B7D61E3E95256FD1269E307143_RuntimeMethod_var)));
}
IL_0014:
{
il2cpp_codegen_initobj((&V_0), sizeof(RuntimeObject*));
RuntimeObject* L_2 = V_0;
CancellationToken_t51142D9C6D7C02D314DA34A6A7988C528992FFED L_3 = ___cancellationToken0;
Task_1_t0C4CD3A5BB93A184420D73218644C56C70FDA7E2* L_4 = (Task_1_t0C4CD3A5BB93A184420D73218644C56C70FDA7E2*)il2cpp_codegen_object_new(il2cpp_rgctx_data(method->rgctx_data, 0));
(( void (*) (Task_1_t0C4CD3A5BB93A184420D73218644C56C70FDA7E2*, bool, RuntimeObject*, int32_t, CancellationToken_t51142D9C6D7C02D314DA34A6A7988C528992FFED, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_4, (bool)1, L_2, (int32_t)0, L_3, il2cpp_rgctx_method(method->rgctx_data, 1));
return L_4;
}
}
// System.Threading.Tasks.Task`1<TResult> System.Threading.Tasks.Task::FromResult<System.Int32>(TResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Task_1_t4C228DE57804012969575431CFF12D57C875552D* Task_FromResult_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_m1AB522FB726C8CC51C9F00459B7CE60065461032_gshared (int32_t ___result0, const RuntimeMethod* method)
{
{
int32_t L_0 = ___result0;
Task_1_t4C228DE57804012969575431CFF12D57C875552D* L_1 = (Task_1_t4C228DE57804012969575431CFF12D57C875552D*)il2cpp_codegen_object_new(il2cpp_rgctx_data(method->rgctx_data, 0));
(( void (*) (Task_1_t4C228DE57804012969575431CFF12D57C875552D*, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_1, L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
return L_1;
}
}
// System.Threading.Tasks.Task`1<TResult> System.Threading.Tasks.Task::FromResult<System.Object>(TResult)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Task_1_t0C4CD3A5BB93A184420D73218644C56C70FDA7E2* Task_FromResult_TisRuntimeObject_mCF2DB27B9C76CBB36764EAAC15108BE463AC3A0A_gshared (RuntimeObject* ___result0, const RuntimeMethod* method)
{
{
RuntimeObject* L_0 = ___result0;
Task_1_t0C4CD3A5BB93A184420D73218644C56C70FDA7E2* L_1 = (Task_1_t0C4CD3A5BB93A184420D73218644C56C70FDA7E2*)il2cpp_codegen_object_new(il2cpp_rgctx_data(method->rgctx_data, 0));
(( void (*) (Task_1_t0C4CD3A5BB93A184420D73218644C56C70FDA7E2*, RuntimeObject*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_1, L_0, il2cpp_rgctx_method(method->rgctx_data, 1));
return L_1;
}
}
// System.Void UnityEngine.TextCore.Text.TextGeneratorUtilities::ResizeInternalArray<System.Int32>(T[]&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TextGeneratorUtilities_ResizeInternalArray_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_m3DF1923F71621DA0128E1202583F3B8580E63E32_gshared (Int32U5BU5D_t19C97395396A72ECAF310612F0760F165060314C** ___array0, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
Int32U5BU5D_t19C97395396A72ECAF310612F0760F165060314C** L_0 = ___array0;
Int32U5BU5D_t19C97395396A72ECAF310612F0760F165060314C* L_1 = *((Int32U5BU5D_t19C97395396A72ECAF310612F0760F165060314C**)L_0);
int32_t L_2;
L_2 = Mathf_NextPowerOfTwo_m25B17CBCFB02762842BE3725618DD97C7C4B1014(((int32_t)il2cpp_codegen_add(((int32_t)(((RuntimeArray*)L_1)->max_length)), 1)), NULL);
V_0 = L_2;
Int32U5BU5D_t19C97395396A72ECAF310612F0760F165060314C** L_3 = ___array0;
int32_t L_4 = V_0;
(( void (*) (Int32U5BU5D_t19C97395396A72ECAF310612F0760F165060314C**, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_3, L_4, il2cpp_rgctx_method(method->rgctx_data, 0));
return;
}
}
// System.Void UnityEngine.TextCore.Text.TextGeneratorUtilities::ResizeInternalArray<System.Object>(T[]&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TextGeneratorUtilities_ResizeInternalArray_TisRuntimeObject_m5E32F927ADD520138BDF655B0D5FEBE0471D3846_gshared (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918** ___array0, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918** L_0 = ___array0;
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_1 = *((ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918**)L_0);
int32_t L_2;
L_2 = Mathf_NextPowerOfTwo_m25B17CBCFB02762842BE3725618DD97C7C4B1014(((int32_t)il2cpp_codegen_add(((int32_t)(((RuntimeArray*)L_1)->max_length)), 1)), NULL);
V_0 = L_2;
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918** L_3 = ___array0;
int32_t L_4 = V_0;
(( void (*) (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918**, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_3, L_4, il2cpp_rgctx_method(method->rgctx_data, 0));
return;
}
}
// System.Void UnityEngine.TextCore.Text.TextInfo::Resize<UnityEngine.TextCore.Text.LinkInfo>(T[]&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TextInfo_Resize_TisLinkInfo_tE85DDAFDFBDA635E6405C88EE4FD5941A9243DD8_mCED76C73D7A2398528C92992D323A2DBD1663DDD_gshared (LinkInfoU5BU5D_tB7EB23E47AF29CCBEC884F9D0DB95BC97F62AE51** ___array0, int32_t ___size1, const RuntimeMethod* method)
{
int32_t V_0 = 0;
int32_t G_B3_0 = 0;
{
int32_t L_0 = ___size1;
if ((((int32_t)L_0) > ((int32_t)((int32_t)1024))))
{
goto IL_0011;
}
}
{
int32_t L_1 = ___size1;
int32_t L_2;
L_2 = Mathf_NextPowerOfTwo_m25B17CBCFB02762842BE3725618DD97C7C4B1014(L_1, NULL);
G_B3_0 = L_2;
goto IL_0018;
}
IL_0011:
{
int32_t L_3 = ___size1;
G_B3_0 = ((int32_t)il2cpp_codegen_add(L_3, ((int32_t)256)));
}
IL_0018:
{
V_0 = G_B3_0;
LinkInfoU5BU5D_tB7EB23E47AF29CCBEC884F9D0DB95BC97F62AE51** L_4 = ___array0;
int32_t L_5 = V_0;
(( void (*) (LinkInfoU5BU5D_tB7EB23E47AF29CCBEC884F9D0DB95BC97F62AE51**, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_4, L_5, il2cpp_rgctx_method(method->rgctx_data, 0));
return;
}
}
// System.Void UnityEngine.TextCore.Text.TextInfo::Resize<System.Object>(T[]&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TextInfo_Resize_TisRuntimeObject_mF073B97B013C656B73FEC40ADB21A2518C700951_gshared (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918** ___array0, int32_t ___size1, const RuntimeMethod* method)
{
int32_t V_0 = 0;
int32_t G_B3_0 = 0;
{
int32_t L_0 = ___size1;
if ((((int32_t)L_0) > ((int32_t)((int32_t)1024))))
{
goto IL_0011;
}
}
{
int32_t L_1 = ___size1;
int32_t L_2;
L_2 = Mathf_NextPowerOfTwo_m25B17CBCFB02762842BE3725618DD97C7C4B1014(L_1, NULL);
G_B3_0 = L_2;
goto IL_0018;
}
IL_0011:
{
int32_t L_3 = ___size1;
G_B3_0 = ((int32_t)il2cpp_codegen_add(L_3, ((int32_t)256)));
}
IL_0018:
{
V_0 = G_B3_0;
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918** L_4 = ___array0;
int32_t L_5 = V_0;
(( void (*) (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918**, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_4, L_5, il2cpp_rgctx_method(method->rgctx_data, 0));
return;
}
}
// System.Void UnityEngine.TextCore.Text.TextInfo::Resize<UnityEngine.TextCore.Text.WordInfo>(T[]&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TextInfo_Resize_TisWordInfo_tA466206097891A5A2590896EE164AFC406EB060D_mEB8F1BB793EF724308050D5AF1348A8B94556D45_gshared (WordInfoU5BU5D_tAD74C9720883D7BB229A20FFAE9EFD2CF9963F7B** ___array0, int32_t ___size1, const RuntimeMethod* method)
{
int32_t V_0 = 0;
int32_t G_B3_0 = 0;
{
int32_t L_0 = ___size1;
if ((((int32_t)L_0) > ((int32_t)((int32_t)1024))))
{
goto IL_0011;
}
}
{
int32_t L_1 = ___size1;
int32_t L_2;
L_2 = Mathf_NextPowerOfTwo_m25B17CBCFB02762842BE3725618DD97C7C4B1014(L_1, NULL);
G_B3_0 = L_2;
goto IL_0018;
}
IL_0011:
{
int32_t L_3 = ___size1;
G_B3_0 = ((int32_t)il2cpp_codegen_add(L_3, ((int32_t)256)));
}
IL_0018:
{
V_0 = G_B3_0;
WordInfoU5BU5D_tAD74C9720883D7BB229A20FFAE9EFD2CF9963F7B** L_4 = ___array0;
int32_t L_5 = V_0;
(( void (*) (WordInfoU5BU5D_tAD74C9720883D7BB229A20FFAE9EFD2CF9963F7B**, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_4, L_5, il2cpp_rgctx_method(method->rgctx_data, 0));
return;
}
}
// System.Void UnityEngine.TextCore.Text.TextInfo::Resize<UnityEngine.TextCore.Text.MeshInfo>(T[]&,System.Int32,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TextInfo_Resize_TisMeshInfo_tE55C4A8846CC2C399CCC3FE989476D987B86AB2F_m8DCA99800557BA87ADA9D085ECBE0F002B615BE2_gshared (MeshInfoU5BU5D_t3DF8B75BF4A213334EED197AD25E432212894AC6** ___array0, int32_t ___size1, bool ___isBlockAllocated2, const RuntimeMethod* method)
{
bool V_0 = false;
bool V_1 = false;
int32_t G_B4_0 = 0;
{
bool L_0 = ___isBlockAllocated2;
V_0 = L_0;
bool L_1 = V_0;
if (!L_1)
{
goto IL_001f;
}
}
{
int32_t L_2 = ___size1;
if ((((int32_t)L_2) > ((int32_t)((int32_t)1024))))
{
goto IL_0016;
}
}
{
int32_t L_3 = ___size1;
int32_t L_4;
L_4 = Mathf_NextPowerOfTwo_m25B17CBCFB02762842BE3725618DD97C7C4B1014(L_3, NULL);
G_B4_0 = L_4;
goto IL_001d;
}
IL_0016:
{
int32_t L_5 = ___size1;
G_B4_0 = ((int32_t)il2cpp_codegen_add(L_5, ((int32_t)256)));
}
IL_001d:
{
___size1 = G_B4_0;
}
IL_001f:
{
int32_t L_6 = ___size1;
MeshInfoU5BU5D_t3DF8B75BF4A213334EED197AD25E432212894AC6** L_7 = ___array0;
MeshInfoU5BU5D_t3DF8B75BF4A213334EED197AD25E432212894AC6* L_8 = *((MeshInfoU5BU5D_t3DF8B75BF4A213334EED197AD25E432212894AC6**)L_7);
V_1 = (bool)((((int32_t)L_6) == ((int32_t)((int32_t)(((RuntimeArray*)L_8)->max_length))))? 1 : 0);
bool L_9 = V_1;
if (!L_9)
{
goto IL_002c;
}
}
{
goto IL_0034;
}
IL_002c:
{
MeshInfoU5BU5D_t3DF8B75BF4A213334EED197AD25E432212894AC6** L_10 = ___array0;
int32_t L_11 = ___size1;
(( void (*) (MeshInfoU5BU5D_t3DF8B75BF4A213334EED197AD25E432212894AC6**, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 0));
}
IL_0034:
{
return;
}
}
// System.Void UnityEngine.TextCore.Text.TextInfo::Resize<System.Object>(T[]&,System.Int32,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TextInfo_Resize_TisRuntimeObject_m6F578BFA4D62CF8F439DAE2DD371FC637ADEB676_gshared (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918** ___array0, int32_t ___size1, bool ___isBlockAllocated2, const RuntimeMethod* method)
{
bool V_0 = false;
bool V_1 = false;
int32_t G_B4_0 = 0;
{
bool L_0 = ___isBlockAllocated2;
V_0 = L_0;
bool L_1 = V_0;
if (!L_1)
{
goto IL_001f;
}
}
{
int32_t L_2 = ___size1;
if ((((int32_t)L_2) > ((int32_t)((int32_t)1024))))
{
goto IL_0016;
}
}
{
int32_t L_3 = ___size1;
int32_t L_4;
L_4 = Mathf_NextPowerOfTwo_m25B17CBCFB02762842BE3725618DD97C7C4B1014(L_3, NULL);
G_B4_0 = L_4;
goto IL_001d;
}
IL_0016:
{
int32_t L_5 = ___size1;
G_B4_0 = ((int32_t)il2cpp_codegen_add(L_5, ((int32_t)256)));
}
IL_001d:
{
___size1 = G_B4_0;
}
IL_001f:
{
int32_t L_6 = ___size1;
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918** L_7 = ___array0;
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_8 = *((ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918**)L_7);
V_1 = (bool)((((int32_t)L_6) == ((int32_t)((int32_t)(((RuntimeArray*)L_8)->max_length))))? 1 : 0);
bool L_9 = V_1;
if (!L_9)
{
goto IL_002c;
}
}
{
goto IL_0034;
}
IL_002c:
{
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918** L_10 = ___array0;
int32_t L_11 = ___size1;
(( void (*) (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918**, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 0));
}
IL_0034:
{
return;
}
}
// System.Void UnityEngine.TextCore.Text.TextInfo::Resize<UnityEngine.TextCore.Text.PageInfo>(T[]&,System.Int32,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TextInfo_Resize_TisPageInfo_tFFF6B289E9A37E4D69353B32F941421180DA5909_m0C68AC768E3311C6C7132EC317AF7ABB24A5343B_gshared (PageInfoU5BU5D_tFEA2CF88695491CFC2F2A2EF6BDCC56E52B0A6D4** ___array0, int32_t ___size1, bool ___isBlockAllocated2, const RuntimeMethod* method)
{
bool V_0 = false;
bool V_1 = false;
int32_t G_B4_0 = 0;
{
bool L_0 = ___isBlockAllocated2;
V_0 = L_0;
bool L_1 = V_0;
if (!L_1)
{
goto IL_001f;
}
}
{
int32_t L_2 = ___size1;
if ((((int32_t)L_2) > ((int32_t)((int32_t)1024))))
{
goto IL_0016;
}
}
{
int32_t L_3 = ___size1;
int32_t L_4;
L_4 = Mathf_NextPowerOfTwo_m25B17CBCFB02762842BE3725618DD97C7C4B1014(L_3, NULL);
G_B4_0 = L_4;
goto IL_001d;
}
IL_0016:
{
int32_t L_5 = ___size1;
G_B4_0 = ((int32_t)il2cpp_codegen_add(L_5, ((int32_t)256)));
}
IL_001d:
{
___size1 = G_B4_0;
}
IL_001f:
{
int32_t L_6 = ___size1;
PageInfoU5BU5D_tFEA2CF88695491CFC2F2A2EF6BDCC56E52B0A6D4** L_7 = ___array0;
PageInfoU5BU5D_tFEA2CF88695491CFC2F2A2EF6BDCC56E52B0A6D4* L_8 = *((PageInfoU5BU5D_tFEA2CF88695491CFC2F2A2EF6BDCC56E52B0A6D4**)L_7);
V_1 = (bool)((((int32_t)L_6) == ((int32_t)((int32_t)(((RuntimeArray*)L_8)->max_length))))? 1 : 0);
bool L_9 = V_1;
if (!L_9)
{
goto IL_002c;
}
}
{
goto IL_0034;
}
IL_002c:
{
PageInfoU5BU5D_tFEA2CF88695491CFC2F2A2EF6BDCC56E52B0A6D4** L_10 = ___array0;
int32_t L_11 = ___size1;
(( void (*) (PageInfoU5BU5D_tFEA2CF88695491CFC2F2A2EF6BDCC56E52B0A6D4**, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 0));
}
IL_0034:
{
return;
}
}
// System.Void UnityEngine.TextCore.Text.TextInfo::Resize<UnityEngine.TextCore.Text.TextElementInfo>(T[]&,System.Int32,System.Boolean)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void TextInfo_Resize_TisTextElementInfo_tDD7A12E319505510E0B350E342BD55F32AB5F976_mF1BA7075C51A6706D5946DC1D8B3FBE1B937C92E_gshared (TextElementInfoU5BU5D_tEC28C9B72883EE21AA798913497C69E179A15C4E** ___array0, int32_t ___size1, bool ___isBlockAllocated2, const RuntimeMethod* method)
{
bool V_0 = false;
bool V_1 = false;
int32_t G_B4_0 = 0;
{
bool L_0 = ___isBlockAllocated2;
V_0 = L_0;
bool L_1 = V_0;
if (!L_1)
{
goto IL_001f;
}
}
{
int32_t L_2 = ___size1;
if ((((int32_t)L_2) > ((int32_t)((int32_t)1024))))
{
goto IL_0016;
}
}
{
int32_t L_3 = ___size1;
int32_t L_4;
L_4 = Mathf_NextPowerOfTwo_m25B17CBCFB02762842BE3725618DD97C7C4B1014(L_3, NULL);
G_B4_0 = L_4;
goto IL_001d;
}
IL_0016:
{
int32_t L_5 = ___size1;
G_B4_0 = ((int32_t)il2cpp_codegen_add(L_5, ((int32_t)256)));
}
IL_001d:
{
___size1 = G_B4_0;
}
IL_001f:
{
int32_t L_6 = ___size1;
TextElementInfoU5BU5D_tEC28C9B72883EE21AA798913497C69E179A15C4E** L_7 = ___array0;
TextElementInfoU5BU5D_tEC28C9B72883EE21AA798913497C69E179A15C4E* L_8 = *((TextElementInfoU5BU5D_tEC28C9B72883EE21AA798913497C69E179A15C4E**)L_7);
V_1 = (bool)((((int32_t)L_6) == ((int32_t)((int32_t)(((RuntimeArray*)L_8)->max_length))))? 1 : 0);
bool L_9 = V_1;
if (!L_9)
{
goto IL_002c;
}
}
{
goto IL_0034;
}
IL_002c:
{
TextElementInfoU5BU5D_tEC28C9B72883EE21AA798913497C69E179A15C4E** L_10 = ___array0;
int32_t L_11 = ___size1;
(( void (*) (TextElementInfoU5BU5D_tEC28C9B72883EE21AA798913497C69E179A15C4E**, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_10, L_11, il2cpp_rgctx_method(method->rgctx_data, 0));
}
IL_0034:
{
return;
}
}
// Unity.Collections.NativeArray`1<T> UnityEngine.Texture2D::GetRawTextureData<UnityEngine.Color>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR NativeArray_1_t6AE72D578EEA854475A487A2795F8C90FD258D8D Texture2D_GetRawTextureData_TisColor_tD001788D726C3A7F1379BEED0260B9591F440C1F_m3B133F38C7E43266DCD025BC599C24C187E779B3_gshared (Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
NativeArray_1_t6AE72D578EEA854475A487A2795F8C90FD258D8D V_1;
memset((&V_1), 0, sizeof(V_1));
bool V_2 = false;
NativeArray_1_t6AE72D578EEA854475A487A2795F8C90FD258D8D V_3;
memset((&V_3), 0, sizeof(V_3));
{
bool L_0;
L_0 = VirtualFuncInvoker0< bool >::Invoke(8 /* System.Boolean UnityEngine.Texture::get_isReadable() */, (Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700*)__this);
V_2 = (bool)((((int32_t)L_0) == ((int32_t)0))? 1 : 0);
bool L_1 = V_2;
if (!L_1)
{
goto IL_0016;
}
}
{
UnityException_tA1EC1E95ADE689CF6EB7FAFF77C160AE1F559067* L_2;
L_2 = Texture_CreateNonReadableException_m29786CD930E89C281564A9B341FD4088FBC8C94F((Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700*)__this, (Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700*)__this, NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&Texture2D_GetRawTextureData_TisColor_tD001788D726C3A7F1379BEED0260B9591F440C1F_m3B133F38C7E43266DCD025BC599C24C187E779B3_RuntimeMethod_var)));
}
IL_0016:
{
int32_t L_3;
L_3 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
V_0 = L_3;
intptr_t L_4;
L_4 = Texture2D_GetWritableImageData_m8E26026A332040F8713E5A2A13C5545797159A5E(__this, 0, NULL);
void* L_5;
L_5 = IntPtr_op_Explicit_m693F2F9E685EE117D4AC080342B8959DAF684294(L_4, NULL);
int64_t L_6;
L_6 = Texture2D_GetRawImageDataSize_m690AA2A7E6B0A207BC6DCA00A6313C3407CE3418(__this, NULL);
int32_t L_7 = V_0;
NativeArray_1_t6AE72D578EEA854475A487A2795F8C90FD258D8D L_8;
L_8 = (( NativeArray_1_t6AE72D578EEA854475A487A2795F8C90FD258D8D (*) (void*, int32_t, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_5, ((int32_t)((int64_t)(L_6/((int64_t)L_7)))), (int32_t)1, il2cpp_rgctx_method(method->rgctx_data, 1));
V_1 = L_8;
NativeArray_1_t6AE72D578EEA854475A487A2795F8C90FD258D8D L_9 = V_1;
V_3 = L_9;
goto IL_003d;
}
IL_003d:
{
NativeArray_1_t6AE72D578EEA854475A487A2795F8C90FD258D8D L_10 = V_3;
return L_10;
}
}
// Unity.Collections.NativeArray`1<T> UnityEngine.Texture2D::GetRawTextureData<UnityEngine.Color32>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR NativeArray_1_t0783F5E3C7AF6C600A6A20DA7A32D82CA836528D Texture2D_GetRawTextureData_TisColor32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B_m3F258FE3486B29D798DCFECF41E9845382EF5CC2_gshared (Texture2D_tE6505BC111DD8A424A9DBE8E05D7D09E11FFFCF4* __this, const RuntimeMethod* method)
{
int32_t V_0 = 0;
NativeArray_1_t0783F5E3C7AF6C600A6A20DA7A32D82CA836528D V_1;
memset((&V_1), 0, sizeof(V_1));
bool V_2 = false;
NativeArray_1_t0783F5E3C7AF6C600A6A20DA7A32D82CA836528D V_3;
memset((&V_3), 0, sizeof(V_3));
{
bool L_0;
L_0 = VirtualFuncInvoker0< bool >::Invoke(8 /* System.Boolean UnityEngine.Texture::get_isReadable() */, (Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700*)__this);
V_2 = (bool)((((int32_t)L_0) == ((int32_t)0))? 1 : 0);
bool L_1 = V_2;
if (!L_1)
{
goto IL_0016;
}
}
{
UnityException_tA1EC1E95ADE689CF6EB7FAFF77C160AE1F559067* L_2;
L_2 = Texture_CreateNonReadableException_m29786CD930E89C281564A9B341FD4088FBC8C94F((Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700*)__this, (Texture_t791CBB51219779964E0E8A2ED7C1AA5F92A4A700*)__this, NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&Texture2D_GetRawTextureData_TisColor32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B_m3F258FE3486B29D798DCFECF41E9845382EF5CC2_RuntimeMethod_var)));
}
IL_0016:
{
int32_t L_3;
L_3 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
V_0 = L_3;
intptr_t L_4;
L_4 = Texture2D_GetWritableImageData_m8E26026A332040F8713E5A2A13C5545797159A5E(__this, 0, NULL);
void* L_5;
L_5 = IntPtr_op_Explicit_m693F2F9E685EE117D4AC080342B8959DAF684294(L_4, NULL);
int64_t L_6;
L_6 = Texture2D_GetRawImageDataSize_m690AA2A7E6B0A207BC6DCA00A6313C3407CE3418(__this, NULL);
int32_t L_7 = V_0;
NativeArray_1_t0783F5E3C7AF6C600A6A20DA7A32D82CA836528D L_8;
L_8 = (( NativeArray_1_t0783F5E3C7AF6C600A6A20DA7A32D82CA836528D (*) (void*, int32_t, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_5, ((int32_t)((int64_t)(L_6/((int64_t)L_7)))), (int32_t)1, il2cpp_rgctx_method(method->rgctx_data, 1));
V_1 = L_8;
NativeArray_1_t0783F5E3C7AF6C600A6A20DA7A32D82CA836528D L_9 = V_1;
V_3 = L_9;
goto IL_003d;
}
IL_003d:
{
NativeArray_1_t0783F5E3C7AF6C600A6A20DA7A32D82CA836528D L_10 = V_3;
return L_10;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.Timeline.IntervalTree`1/Entry<System.Object>>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisEntry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E_mC4AAB1D727919DD18C806BE1EA963020B607BC81_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
Entry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(Entry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<System.Collections.Generic.KeyValuePair`2<UnityEngine.PropertyName,System.Object>>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisKeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13_m02629F79FB1EE9EA6B981CD3E85FAB2F2A8AFB11_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
KeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(KeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<Unity.Collections.NativeArray`1<System.UInt16>>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisNativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934_mFD4CDF87BAD7696ECB7A54041C3C2DB9B6FC613A_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
NativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(NativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<Unity.Collections.NativeArray`1<UnityEngine.UIElements.Vertex>>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisNativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81_m15DFCBCE5832AFA230BB9FBE99366657093B5FE0_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
NativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(NativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.AnimatorClipInfo>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisAnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03_m481D4822078AEC70F364ED2B04D64E0EDAC3B1A6_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
AnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(AnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<System.Char>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_m22D73CBA078956BBAE7C23EDA8F418CA18DA9EF1_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
Il2CppChar V_0 = 0x0;
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(Il2CppChar));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.Color32>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisColor32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B_m444A9045B8F3B8AC1E014F6BF99BD244267F0B15_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.ComputedStyle>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisComputedStyle_t8B08CCCEE20525528B3FFDAC6D3F58F101AAF54C_mED5942D6ED4E40E8860104A47D966C0223217ABD_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
ComputedStyle_t8B08CCCEE20525528B3FFDAC6D3F58F101AAF54C V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(ComputedStyle_t8B08CCCEE20525528B3FFDAC6D3F58F101AAF54C));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.ComputedTransitionProperty>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1_mA4A74648222998A514E9F8102C372BF083CCD488_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<ClipperLib.DoublePoint>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisDoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001_mE13A54BB04E891EF04822007DD03318E44D22679_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
DoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(DoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.EasingFunction>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisEasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4_m6A4E17575CE1493BB004A5764BF58059E672609C_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
EasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(EasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.EnumData>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisEnumData_tB9520C9179D9D6C57B2BF70E76FE4EB4DC94A6F8_mCFA782E96B003C83C7B1924298261BAE6C3D1E0A_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
EnumData_tB9520C9179D9D6C57B2BF70E76FE4EB4DC94A6F8 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(EnumData_tB9520C9179D9D6C57B2BF70E76FE4EB4DC94A6F8));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.TextCore.LowLevel.GlyphPairAdjustmentRecord>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisGlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E_m585E61557D10B57A7FC5782D48D81F179B552C0B_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
GlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(GlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.TextCore.GlyphRect>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisGlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D_m0453FA5BDEB45EED94997DB16BC576D8A414178C_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<System.Int32>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_mE98222C6EBF5626830BEEEEADC1B8F7CBC5ACE20_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(int32_t));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<System.Int32Enum>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisInt32Enum_tCBAC8BA2BFF3A845FA599F303093BBBA374B6F0C_mF860BA0663006B795B37E69398FC488083D5AC07_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(int32_t));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<ClipperLib.IntPoint>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisIntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B_mB11C748019FAA62F2E692839A2B83444D49D15E2_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
IntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(IntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.Timeline.IntervalTreeNode>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisIntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC_m475F9B06F96B8911A73A5660E822A22B0D2CCCF1_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
IntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(IntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.TextCore.Text.LigatureSubstitutionRecord>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisLigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27_m05DEB15836CBC921ED59F21E54537A5EC73224F2_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.ManipulatorActivationFilter>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81_mEABA7EBF4EC66F48C905CFC81F9326D249ED6DB7_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
ManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(ManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.TextCore.Text.MarkToBaseAdjustmentRecord>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisMarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437_m99F597E2BD10942B28EBEF876D8CFB362BFBCFE0_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
MarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(MarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.TextCore.Text.MarkToMarkAdjustmentRecord>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisMarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6_mF6E721AE8B73425E3A729591B008A6C6BEF7CF38_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
MarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(MarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.TextCore.Text.MultipleSubstitutionRecord>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisMultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC_m787B275E1B8254479CB4FAC3522DC2CC127A5B9A_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<System.Object>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisRuntimeObject_m482679ADE43FA9A8310196AF93E6812DA1BD72FB_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
RuntimeObject* V_0 = NULL;
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(RuntimeObject*));
RuntimeObject* L_1 = V_0;
if (!L_1)
{
goto IL_0019;
}
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.Playables.Playable>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisPlayable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F_mEAEF5DCF784321023AEBDD98BB98ACEF220EE31D_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.Playables.PlayableBinding>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisPlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4_m449A9E9AB271C38EDBAF17339570AE74296637BA_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.RaycastHit2D>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisRaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA_mFF244D112B3403B17769BCF8AC0A7C8B315DB4B3_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
RaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(RaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.EventSystems.RaycastResult>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisRaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023_m14C4A94EF222880125220F0F5BFCC72505C26643_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.UIR.RenderChainTextEntry>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisRenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11_m37A736A0CED5EF77ACF57BE33145585E08038FAA_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<System.Resources.ResourceLocator>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisResourceLocator_t84F68A0DD2AA185761938E49BBE9B2C46A47E122_mD304B883E597A70BA557A2598227335A82986206_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
ResourceLocator_t84F68A0DD2AA185761938E49BBE9B2C46A47E122 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(ResourceLocator_t84F68A0DD2AA185761938E49BBE9B2C46A47E122));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.RuleMatcher>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisRuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E_m22C6C1EA51BEA34494E040BAFDE839E8476F5D7D_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.StyleSheets.SelectorMatchRecord>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisSelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7_m06AFFACA0D39016A2D4544196E76A85DA4DD269E_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<System.Single>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisSingle_t4530F2FF86FCB0DC29F35385CA1BD21BE294761C_m780C79E1F778BC676BC25C219AFA71E2B2BC993B_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
float V_0 = 0.0f;
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(float));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.StylePropertyName>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisStylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF_mE0443D38A7C0BD5F537680A879E073A361110259_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.StyleSheets.StylePropertyValue>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisStylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2_mAF46BB04BD2319A3AE1CFB1596877D39B9C905F4_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.StyleSelectorPart>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisStyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470_mA6BFFF70ED62CBFDCC0D546F54CE962F7E35D486_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.StyleSheets.Syntax.StyleSyntaxToken>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisStyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C_m38884EA853592EEC3FC69FCBF6BE7CE3AA795A81_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.StyleSheets.StyleValue>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisStyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5_mE6CC9096B8F83CAC6B5225CE0BA1C51FB24699AA_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
StyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(StyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.StyleSheets.StyleValueManaged>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisStyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4_mCCB8AEF36FEB183FB5E1C5AA2078E4B6C71BE8AE_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.StyleVariable>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisStyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269_mA4E51B2C0450046F4E3BA864E3EB1FE5ADC992BD_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.TextureId>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisTextureId_tFF4B4AAE53408AB10B0B89CCA5F7B50CF2535E58_m59DF9D3FDB0BFE455277960B4CDC8BEAE4BE9C18_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
TextureId_tFF4B4AAE53408AB10B0B89CCA5F7B50CF2535E58 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(TextureId_tFF4B4AAE53408AB10B0B89CCA5F7B50CF2535E58));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.TimeValue>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisTimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E_m590840B634054DBBB5327A1FA664ADA5D3658641_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
TimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(TimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UICharInfo>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisUICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD_m41D0415CA16B5084EF16D8B50B352876CA85F671_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
UICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(UICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UILineInfo>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisUILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC_mAB3698BB15D5E9BCA8128F00056B5048F14436B1_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
UILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(UILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIVertex>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisUIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207_m277D772B9CAFD31BC7CC932EC9B12A58426930B1_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<System.UInt32>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisUInt32_t1833D51FFA667B18A5AA4B8D34DE284F8495D29B_m80B7C8B9BB3C82B47D3D2DA10A94025FFD6397B8_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
uint32_t V_0 = 0;
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(uint32_t));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.Vector2>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisVector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7_m6D8C8E55297EFD3E8A26854AC123C5964BA767A7_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.Vector3>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisVector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2_m1FB623A447ADBDE0280AA49EA81CF8AB07E36B01_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.Vector4>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisVector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3_m18EF1B97CF01785013297BD7B5EECBEE7C00C93F_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.Timeline.AnimationOutputWeightProcessor/WeightInfo>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisWeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0_m0C269D5D075BBE3204BC3821A388116FF709F0BF_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
WeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(WeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.BeforeRenderHelper/OrderBlock>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisOrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837_m63F326769441143E1597AC7130AB6DC464D61E88_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.UIR.BitmapAllocator32/Page>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisPage_t04FE552A388BF55B12C8868E19589136957E00A5_mC1B9E425F53586163AEE5480379395BC15D0B23A_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
Page_t04FE552A388BF55B12C8868E19589136957E00A5 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(Page_t04FE552A388BF55B12C8868E19589136957E00A5));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.Camera/RenderRequest>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisRenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A_m27E4FDF83FF5340A8DF394BF91FD7704924507B6_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<Cinemachine.CameraState/CustomBlendable>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisCustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB_mC23FE0B911D581781708AB2D328FE3E6613EDCDD_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
CustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(CustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<Cinemachine.CinemachineClearShot/Pair>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisPair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2_m79457CE60F1634082BD8596106D1BA952B8CB4EE_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
Pair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(Pair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<Cinemachine.CinemachineStateDrivenCamera/HashPair>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisHashPair_t176F7624706A73500F3AB84D61111316D45ECCEC_m7D31DF6B02272F4F9975E84881817E7F747D357D_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
HashPair_t176F7624706A73500F3AB84D61111316D45ECCEC V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(HashPair_t176F7624706A73500F3AB84D61111316D45ECCEC));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<Cinemachine.ConfinerOven/PolygonSolution>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisPolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C_mF859B9A8E4C4585F7A5173E17B43C3BCF6470139_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.EventInterestReflectionUtils/DefaultEventInterests>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisDefaultEventInterests_tF62D361FCDFA26C0E0A55ECCD8C20A64B3F2D8F0_m35F0F7C6D9E96DF3ABA120CC993289713EA2F5F7_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
DefaultEventInterests_tF62D361FCDFA26C0E0A55ECCD8C20A64B3F2D8F0 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(DefaultEventInterests_tF62D361FCDFA26C0E0A55ECCD8C20A64B3F2D8F0));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.FocusController/FocusedElement>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisFocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF_m550B7A4E8E06756FFD3C99BF1FF070F49635F6AE_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.InternalTreeView/TreeViewItemWrapper>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisTreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F_mF28C2E5111A4DE9B96D17A5E6979295D38A322B6_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<System.Text.RegularExpressions.RegexCharClass/SingleRange>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisSingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC_mD5435B6DF5F8586D459CFAF4DB05C8EE9E1E026D_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.UIR.RenderChain/RenderNodeData>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisRenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE_m9AE6F2DDA919C1D7CD74253CB65B2D3BC2F5A9A2_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.StyleComplexSelector/PseudoStateData>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisPseudoStateData_tE5B3EBF682E8DE88E9325F44841D5B95FEB6F3A8_m419CD95F9877D21C9A68DD3D6949A128E64C8DE7_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
PseudoStateData_tE5B3EBF682E8DE88E9325F44841D5B95FEB6F3A8 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(PseudoStateData_tE5B3EBF682E8DE88E9325F44841D5B95FEB6F3A8));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.TemplateAsset/AttributeOverride>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisAttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF_mBD87F34657700BCA14CFBF1A311642E07540C3CB_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.TextCore.Text.TextResourceManager/FontAssetRef>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisFontAssetRef_t7B8E634754BC5683F1E6601D7CD0061285A28FF3_m3E3314C31F89BEFF81A853169FA2CFE48FA16F6F_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
FontAssetRef_t7B8E634754BC5683F1E6601D7CD0061285A28FF3 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(FontAssetRef_t7B8E634754BC5683F1E6601D7CD0061285A28FF3));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.TextCore.Text.TextSettings/FontReferenceMap>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisFontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831_m0EE758B08E26D0C0B7194AD7B6AB324B10BFBFF5_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.UIR.TextureBlitter/BlitInfo>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisBlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357_m83D0961221937C36B54E9CC74D892D62D8AF8D53_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.TextureRegistry/TextureInfo>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisTextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B_m4BE06BD140C54E2CF642303F2FA88DED64DD13E4_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.Timeline.TimeNotificationBehaviour/NotificationEntry>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisNotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62_m08D4CE37482C806BD7F4D3882BE81C81B06A3F31_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.TreeView/TreeViewItemWrapper>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisTreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE_mDCEA5CB7EF66B2727DECCD0B0BE5647C48B6168F_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisEntry_tB8765CA56422E2C92887314844384843688DCB9F_m504444B1ED5507D0A77AD2B3FD60D45D11437744_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
Entry_tB8765CA56422E2C92887314844384843688DCB9F V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(Entry_tB8765CA56422E2C92887314844384843688DCB9F));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.UIR.UIRenderDevice/AllocToFree>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisAllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8_m4A5E1A4D7A50954C2F4430647027D1849191DAD9_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisAllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512_mDCCEA24110FB1AB608C092814D0E1E3C17A526AB_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UnitySynchronizationContext/WorkRequest>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisWorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44_mF23DCA8308D365F2FFA74618C16196CE04CD010C_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.VisualTreeAsset/SlotDefinition>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisSlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8_m016A4454B7E65CF9F24FFFFDE57DE6924C24CCF0_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.VisualTreeAsset/SlotUsageEntry>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisSlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76_m0DE2F9716DDB26996A5C79B5DBA1A013C62E0C23_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<UnityEngine.UIElements.VisualTreeAsset/UsingEntry>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisUsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484_mB56DFDADCE67D8DED213CA5D2712603BD2B2E0C8_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484 V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<Cinemachine.TargetPositionCache/CacheCurve/Item>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisItem_t590AA2925A38AA7EA48963775F482E9BA8525B4E_mA684A70CCFDA47DEC53C07DC02DDB53619727D94_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// System.Void System.ThrowHelper::IfNullAndNullsAreIllegalThenThrow<Cinemachine.TargetPositionCache/CacheEntry/RecordingItem>(System.Object,System.ExceptionArgument)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void ThrowHelper_IfNullAndNullsAreIllegalThenThrow_TisRecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E_mE869F0A5922F2EA876719D2F3B0B0EED2616AE0F_gshared (RuntimeObject* ___value0, int32_t ___argName1, const RuntimeMethod* method)
{
RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E V_0;
memset((&V_0), 0, sizeof(V_0));
{
RuntimeObject* L_0 = ___value0;
if (L_0)
{
goto IL_0019;
}
}
{
il2cpp_codegen_initobj((&V_0), sizeof(RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E));
}
{
int32_t L_2 = ___argName1;
ThrowHelper_ThrowArgumentNullException_m37384675C99E588A5288DECAE9BD7AD7849B22FF(L_2, NULL);
}
IL_0019:
{
return;
}
}
// T UnityEngine.Timeline.TimelineAsset::CreateTrack<System.Object>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* TimelineAsset_CreateTrack_TisRuntimeObject_mB347EECFD633054E8F7C842B699D0832AA96B348_gshared (TimelineAsset_tE400C944B07CA9D1349BAD84545E24075ADB3496* __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Type_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
{
// return (T)CreateTrack(typeof(T), null, null);
RuntimeTypeHandle_t332A452B8B6179E4469B69525D0FE82A88030F7B L_0 = { reinterpret_cast<intptr_t> (il2cpp_rgctx_type(method->rgctx_data, 0)) };
il2cpp_codegen_runtime_class_init_inline(Type_t_il2cpp_TypeInfo_var);
Type_t* L_1;
L_1 = Type_GetTypeFromHandle_m2570A2A5B32A5E9D9F0F38B37459DA18736C823E(L_0, NULL);
TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96* L_2;
L_2 = TimelineAsset_CreateTrack_m327D088F33507A544DE566503CDF6593C024C1ED(__this, L_1, (TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96*)NULL, (String_t*)NULL, NULL);
return ((RuntimeObject*)Castclass((RuntimeObject*)L_2, il2cpp_rgctx_data(method->rgctx_data, 1)));
}
}
// T UnityEngine.Timeline.TimelineAsset::CreateTrack<System.Object>(System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* TimelineAsset_CreateTrack_TisRuntimeObject_mFCADA1BCFFA6EAD908386C69E4D0A689CBD5BBFC_gshared (TimelineAsset_tE400C944B07CA9D1349BAD84545E24075ADB3496* __this, String_t* ___trackName0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Type_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
{
// return (T)CreateTrack(typeof(T), null, trackName);
RuntimeTypeHandle_t332A452B8B6179E4469B69525D0FE82A88030F7B L_0 = { reinterpret_cast<intptr_t> (il2cpp_rgctx_type(method->rgctx_data, 0)) };
il2cpp_codegen_runtime_class_init_inline(Type_t_il2cpp_TypeInfo_var);
Type_t* L_1;
L_1 = Type_GetTypeFromHandle_m2570A2A5B32A5E9D9F0F38B37459DA18736C823E(L_0, NULL);
String_t* L_2 = ___trackName0;
TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96* L_3;
L_3 = TimelineAsset_CreateTrack_m327D088F33507A544DE566503CDF6593C024C1ED(__this, L_1, (TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96*)NULL, L_2, NULL);
return ((RuntimeObject*)Castclass((RuntimeObject*)L_3, il2cpp_rgctx_data(method->rgctx_data, 1)));
}
}
// T UnityEngine.Timeline.TimelineAsset::CreateTrack<System.Object>(UnityEngine.Timeline.TrackAsset,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* TimelineAsset_CreateTrack_TisRuntimeObject_m2A98AF2825900F09A33A99F44B8D5CF60635FA46_gshared (TimelineAsset_tE400C944B07CA9D1349BAD84545E24075ADB3496* __this, TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96* ___parent0, String_t* ___trackName1, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Type_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
{
// return (T)CreateTrack(typeof(T), parent, trackName);
RuntimeTypeHandle_t332A452B8B6179E4469B69525D0FE82A88030F7B L_0 = { reinterpret_cast<intptr_t> (il2cpp_rgctx_type(method->rgctx_data, 0)) };
il2cpp_codegen_runtime_class_init_inline(Type_t_il2cpp_TypeInfo_var);
Type_t* L_1;
L_1 = Type_GetTypeFromHandle_m2570A2A5B32A5E9D9F0F38B37459DA18736C823E(L_0, NULL);
TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96* L_2 = ___parent0;
String_t* L_3 = ___trackName1;
TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96* L_4;
L_4 = TimelineAsset_CreateTrack_m327D088F33507A544DE566503CDF6593C024C1ED(__this, L_1, L_2, L_3, NULL);
return ((RuntimeObject*)Castclass((RuntimeObject*)L_4, il2cpp_rgctx_data(method->rgctx_data, 1)));
}
}
// UnityEngine.Timeline.TimelineClip UnityEngine.Timeline.TrackAsset::CreateClip<System.Object>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TimelineClip_t003008F08E56A75F3A47FD9ADE7C066988A3371D* TrackAsset_CreateClip_TisRuntimeObject_m5BAFDDD423EE60F7B5794701712C57F0F12501AD_gshared (TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96* __this, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Type_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
{
// return CreateClip(typeof(T));
RuntimeTypeHandle_t332A452B8B6179E4469B69525D0FE82A88030F7B L_0 = { reinterpret_cast<intptr_t> (il2cpp_rgctx_type(method->rgctx_data, 0)) };
il2cpp_codegen_runtime_class_init_inline(Type_t_il2cpp_TypeInfo_var);
Type_t* L_1;
L_1 = Type_GetTypeFromHandle_m2570A2A5B32A5E9D9F0F38B37459DA18736C823E(L_0, NULL);
TimelineClip_t003008F08E56A75F3A47FD9ADE7C066988A3371D* L_2;
L_2 = TrackAsset_CreateClip_mA7D1A7B6ACCF5CCF9FB416E86C483BD2EC31A45F(__this, L_1, NULL);
return L_2;
}
}
// T UnityEngine.Timeline.TrackAsset::CreateMarker<System.Object>(System.Double)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* TrackAsset_CreateMarker_TisRuntimeObject_mF08C52C2F5B2346C4735735AE2C24901C9C0C600_gshared (TrackAsset_t31E19BE900C90F6616C0D337652C8614CD833B96* __this, double ___time0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Type_t_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
{
// return (T)CreateMarker(typeof(T), time);
RuntimeTypeHandle_t332A452B8B6179E4469B69525D0FE82A88030F7B L_0 = { reinterpret_cast<intptr_t> (il2cpp_rgctx_type(method->rgctx_data, 0)) };
il2cpp_codegen_runtime_class_init_inline(Type_t_il2cpp_TypeInfo_var);
Type_t* L_1;
L_1 = Type_GetTypeFromHandle_m2570A2A5B32A5E9D9F0F38B37459DA18736C823E(L_0, NULL);
double L_2 = ___time0;
RuntimeObject* L_3;
L_3 = TrackAsset_CreateMarker_mD4F5715387220B12D0EF244C7C02F83F6040638A(__this, L_1, L_2, NULL);
return ((RuntimeObject*)Castclass((RuntimeObject*)L_3, il2cpp_rgctx_data(method->rgctx_data, 1)));
}
}
// System.Void UnityEngine.UIElements.UIR.UIRenderDevice::DrawRanges<System.UInt16,UnityEngine.UIElements.Vertex>(UnityEngine.UIElements.UIR.Utility/GPUBuffer`1<I>,UnityEngine.UIElements.UIR.Utility/GPUBuffer`1<T>,Unity.Collections.NativeSlice`1<UnityEngine.UIElements.UIR.DrawBufferRange>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UIRenderDevice_DrawRanges_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_TisVertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7_m9B1A0575B3B8487DBF5674BC961D048217F113E2_gshared (UIRenderDevice_t59628CBA89B4617E832C2B270E1C1A3931D01302* __this, GPUBuffer_1_tA865630D1AFA976A50A92C4ACE0243A78520BDC7* ___ib0, GPUBuffer_1_tD1DC0573556845223680E17430EFF317DDA4A5AC* ___vb1, NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974 ___ranges2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&NativeSliceUnsafeUtility_GetUnsafePtr_TisDrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4_m5682E2958E30CCCFB6477FB04847917857BEFAFA_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&NativeSlice_1_get_Length_m2566843C81FEFDDF6407962D4E34F13C3133028D_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&UIRenderDevice_DrawRanges_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_TisVertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7_m9B1A0575B3B8487DBF5674BC961D048217F113E2_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Utility_t8BCC393462C6270211734BE47CF5350F05EC97AD_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
intptr_t* V_0 = NULL;
{
uint32_t L_0 = sizeof(intptr_t);
if ((uintptr_t)((uintptr_t)1) * (uintptr_t)L_0 > (uintptr_t)kIl2CppUIntPtrMax)
IL2CPP_RAISE_MANAGED_EXCEPTION(il2cpp_codegen_get_overflow_exception(), UIRenderDevice_DrawRanges_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_TisVertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7_m9B1A0575B3B8487DBF5674BC961D048217F113E2_RuntimeMethod_var);
int8_t* L_1 = (int8_t*) alloca(((intptr_t)il2cpp_codegen_multiply((intptr_t)((uintptr_t)1), (int32_t)L_0)));
memset(L_1, 0, ((intptr_t)il2cpp_codegen_multiply((intptr_t)((uintptr_t)1), (int32_t)L_0)));
V_0 = (intptr_t*)(L_1);
intptr_t* L_2 = V_0;
GPUBuffer_1_tD1DC0573556845223680E17430EFF317DDA4A5AC* L_3 = ___vb1;
intptr_t L_4;
L_4 = (( intptr_t (*) (GPUBuffer_1_tD1DC0573556845223680E17430EFF317DDA4A5AC*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_3, il2cpp_rgctx_method(method->rgctx_data, 1));
*((intptr_t*)L_2) = (intptr_t)L_4;
GPUBuffer_1_tA865630D1AFA976A50A92C4ACE0243A78520BDC7* L_5 = ___ib0;
intptr_t L_6;
L_6 = (( intptr_t (*) (GPUBuffer_1_tA865630D1AFA976A50A92C4ACE0243A78520BDC7*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 3)))(L_5, il2cpp_rgctx_method(method->rgctx_data, 3));
intptr_t* L_7 = V_0;
NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974 L_8 = ___ranges2;
void* L_9;
L_9 = NativeSliceUnsafeUtility_GetUnsafePtr_TisDrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4_m5682E2958E30CCCFB6477FB04847917857BEFAFA(L_8, NativeSliceUnsafeUtility_GetUnsafePtr_TisDrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4_m5682E2958E30CCCFB6477FB04847917857BEFAFA_RuntimeMethod_var);
intptr_t L_10;
memset((&L_10), 0, sizeof(L_10));
IntPtr__ctor_m4F9A9B80F01996B610D5AE4797F20B98ECD0A3D9_inline((&L_10), L_9, /*hidden argument*/NULL);
int32_t L_11;
L_11 = NativeSlice_1_get_Length_m2566843C81FEFDDF6407962D4E34F13C3133028D_inline((&___ranges2), NativeSlice_1_get_Length_m2566843C81FEFDDF6407962D4E34F13C3133028D_RuntimeMethod_var);
intptr_t L_12 = (intptr_t)__this->___m_VertexDecl_2;
il2cpp_codegen_runtime_class_init_inline(Utility_t8BCC393462C6270211734BE47CF5350F05EC97AD_il2cpp_TypeInfo_var);
Utility_DrawRanges_m5C054AC5885504B35399A861D70E9492DBC957A6(L_6, L_7, 1, L_10, L_11, L_12, NULL);
return;
}
}
// Unity.Collections.NativeSlice`1<T> UnityEngine.UIElements.UIR.UIRenderDevice::PtrToSlice<UnityEngine.UIElements.UIR.DrawBufferRange>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974 UIRenderDevice_PtrToSlice_TisDrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4_mE7D46356D1563075AD19258C2044465237519400_gshared (void* ___p0, int32_t ___count1, const RuntimeMethod* method)
{
NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974 V_0;
memset((&V_0), 0, sizeof(V_0));
NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974 V_1;
memset((&V_1), 0, sizeof(V_1));
{
void* L_0 = ___p0;
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_2 = ___count1;
NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974 L_3;
L_3 = (( NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974 (*) (void*, int32_t, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, L_1, L_2, il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = L_3;
NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974 L_4 = V_0;
V_1 = L_4;
goto IL_0012;
}
IL_0012:
{
NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974 L_5 = V_1;
return L_5;
}
}
// T UnityEngine.UIElements.UQueryExtensions::Q<System.Object>(UnityEngine.UIElements.VisualElement,System.String,System.String)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* UQueryExtensions_Q_TisRuntimeObject_m89141E23D03237B5D03A2B126F6726F52A6AC35C_gshared (VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* ___e0, String_t* ___name1, String_t* ___className2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Type_t_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&UQueryState_1_First_m0E66C612BCBDFFA32D636D936B37CF56C0C2BA94_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&UQueryState_1_RebuildOn_m6A44E1618AB0FD0EDCBEEF093B74FDEA03723004_RuntimeMethod_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115_0_0_0_var);
s_Il2CppMethodInitialized = true;
}
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA V_0;
memset((&V_0), 0, sizeof(V_0));
bool V_1 = false;
RuntimeObject* V_2 = NULL;
bool V_3 = false;
bool V_4 = false;
bool V_5 = false;
{
RuntimeTypeHandle_t332A452B8B6179E4469B69525D0FE82A88030F7B L_0 = { reinterpret_cast<intptr_t> (il2cpp_rgctx_type(method->rgctx_data, 0)) };
il2cpp_codegen_runtime_class_init_inline(Type_t_il2cpp_TypeInfo_var);
Type_t* L_1;
L_1 = Type_GetTypeFromHandle_m2570A2A5B32A5E9D9F0F38B37459DA18736C823E(L_0, NULL);
RuntimeTypeHandle_t332A452B8B6179E4469B69525D0FE82A88030F7B L_2 = { reinterpret_cast<intptr_t> (VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115_0_0_0_var) };
Type_t* L_3;
L_3 = Type_GetTypeFromHandle_m2570A2A5B32A5E9D9F0F38B37459DA18736C823E(L_2, NULL);
V_1 = (bool)((((RuntimeObject*)(Type_t*)L_1) == ((RuntimeObject*)(Type_t*)L_3))? 1 : 0);
bool L_4 = V_1;
if (!L_4)
{
goto IL_0034;
}
}
{
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_5 = ___e0;
String_t* L_6 = ___name1;
String_t* L_7 = ___className2;
il2cpp_codegen_runtime_class_init_inline(UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_il2cpp_TypeInfo_var);
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_8;
L_8 = UQueryExtensions_Q_m625363964EA8275D50A9767F1E3468901C1B0BEC(L_5, L_6, L_7, NULL);
V_2 = ((RuntimeObject*)Castclass((RuntimeObject*)((RuntimeObject*)IsInst((RuntimeObject*)L_8, il2cpp_rgctx_data(method->rgctx_data, 1))), il2cpp_rgctx_data(method->rgctx_data, 1)));
goto IL_0237;
}
IL_0034:
{
String_t* L_9 = ___name1;
V_3 = (bool)((((RuntimeObject*)(String_t*)L_9) == ((RuntimeObject*)(RuntimeObject*)NULL))? 1 : 0);
bool L_10 = V_3;
if (!L_10)
{
goto IL_0114;
}
}
{
String_t* L_11 = ___className2;
V_4 = (bool)((((RuntimeObject*)(String_t*)L_11) == ((RuntimeObject*)(RuntimeObject*)NULL))? 1 : 0);
bool L_12 = V_4;
if (!L_12)
{
goto IL_009b;
}
}
{
il2cpp_codegen_runtime_class_init_inline(UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_il2cpp_TypeInfo_var);
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_13 = ___e0;
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA L_14;
L_14 = UQueryState_1_RebuildOn_m6A44E1618AB0FD0EDCBEEF093B74FDEA03723004((&((UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_StaticFields*)il2cpp_codegen_static_fields_for(UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_il2cpp_TypeInfo_var))->___SingleElementTypeQuery_4), L_13, UQueryState_1_RebuildOn_m6A44E1618AB0FD0EDCBEEF093B74FDEA03723004_RuntimeMethod_var);
V_0 = L_14;
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA L_15 = V_0;
List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC* L_16 = (List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC*)L_15.___m_Matchers_2;
RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E L_17;
L_17 = List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68(L_16, 0, List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68_RuntimeMethod_var);
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* L_18 = (StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD*)L_17.___complexSelector_1;
StyleSelectorU5BU5D_t11A633455FC601606B3DF3CEDDDAB1625B54708D* L_19;
L_19 = StyleComplexSelector_get_selectors_m54911D4E758E1A19A16E948D6D10BEB5795ADC02(L_18, NULL);
int32_t L_20 = 0;
StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362* L_21 = (L_19)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_20));
StyleSelectorPartU5BU5D_tBA574FB3E75E94E52874FDB7B05B9048E8A5421B* L_22;
L_22 = StyleSelector_get_parts_mE6EEAE6825862DDA89947B892B661A865D463CEF(L_21, NULL);
il2cpp_codegen_runtime_class_init_inline(il2cpp_rgctx_data(method->rgctx_data, 2));
IsOfType_1_tAD57152B527BA8DDBDA8E8C388140620049ADBE4* L_23 = ((IsOfType_1_tAD57152B527BA8DDBDA8E8C388140620049ADBE4_StaticFields*)il2cpp_codegen_static_fields_for(il2cpp_rgctx_data(method->rgctx_data, 2)))->___s_Instance_0;
StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 L_24;
L_24 = StyleSelectorPart_CreatePredicate_mB47D568BDD71A75929CCF6BD1981FE0565687EDD((RuntimeObject*)L_23, NULL);
(L_22)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470)L_24);
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_25;
L_25 = UQueryState_1_First_m0E66C612BCBDFFA32D636D936B37CF56C0C2BA94((&V_0), UQueryState_1_First_m0E66C612BCBDFFA32D636D936B37CF56C0C2BA94_RuntimeMethod_var);
V_2 = ((RuntimeObject*)Castclass((RuntimeObject*)((RuntimeObject*)IsInst((RuntimeObject*)L_25, il2cpp_rgctx_data(method->rgctx_data, 1))), il2cpp_rgctx_data(method->rgctx_data, 1)));
goto IL_0237;
}
IL_009b:
{
il2cpp_codegen_runtime_class_init_inline(UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_il2cpp_TypeInfo_var);
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_26 = ___e0;
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA L_27;
L_27 = UQueryState_1_RebuildOn_m6A44E1618AB0FD0EDCBEEF093B74FDEA03723004((&((UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_StaticFields*)il2cpp_codegen_static_fields_for(UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_il2cpp_TypeInfo_var))->___SingleElementTypeAndClassQuery_6), L_26, UQueryState_1_RebuildOn_m6A44E1618AB0FD0EDCBEEF093B74FDEA03723004_RuntimeMethod_var);
V_0 = L_27;
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA L_28 = V_0;
List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC* L_29 = (List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC*)L_28.___m_Matchers_2;
RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E L_30;
L_30 = List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68(L_29, 0, List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68_RuntimeMethod_var);
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* L_31 = (StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD*)L_30.___complexSelector_1;
StyleSelectorU5BU5D_t11A633455FC601606B3DF3CEDDDAB1625B54708D* L_32;
L_32 = StyleComplexSelector_get_selectors_m54911D4E758E1A19A16E948D6D10BEB5795ADC02(L_31, NULL);
int32_t L_33 = 0;
StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362* L_34 = (L_32)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_33));
StyleSelectorPartU5BU5D_tBA574FB3E75E94E52874FDB7B05B9048E8A5421B* L_35;
L_35 = StyleSelector_get_parts_mE6EEAE6825862DDA89947B892B661A865D463CEF(L_34, NULL);
il2cpp_codegen_runtime_class_init_inline(il2cpp_rgctx_data(method->rgctx_data, 2));
IsOfType_1_tAD57152B527BA8DDBDA8E8C388140620049ADBE4* L_36 = ((IsOfType_1_tAD57152B527BA8DDBDA8E8C388140620049ADBE4_StaticFields*)il2cpp_codegen_static_fields_for(il2cpp_rgctx_data(method->rgctx_data, 2)))->___s_Instance_0;
StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 L_37;
L_37 = StyleSelectorPart_CreatePredicate_mB47D568BDD71A75929CCF6BD1981FE0565687EDD((RuntimeObject*)L_36, NULL);
(L_35)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470)L_37);
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA L_38 = V_0;
List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC* L_39 = (List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC*)L_38.___m_Matchers_2;
RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E L_40;
L_40 = List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68(L_39, 0, List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68_RuntimeMethod_var);
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* L_41 = (StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD*)L_40.___complexSelector_1;
StyleSelectorU5BU5D_t11A633455FC601606B3DF3CEDDDAB1625B54708D* L_42;
L_42 = StyleComplexSelector_get_selectors_m54911D4E758E1A19A16E948D6D10BEB5795ADC02(L_41, NULL);
int32_t L_43 = 0;
StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362* L_44 = (L_42)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_43));
StyleSelectorPartU5BU5D_tBA574FB3E75E94E52874FDB7B05B9048E8A5421B* L_45;
L_45 = StyleSelector_get_parts_mE6EEAE6825862DDA89947B892B661A865D463CEF(L_44, NULL);
String_t* L_46 = ___className2;
StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 L_47;
L_47 = StyleSelectorPart_CreateClass_m35749E6336C3E92EADB130D6BF196FD7AAB9F066(L_46, NULL);
(L_45)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470)L_47);
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_48;
L_48 = UQueryState_1_First_m0E66C612BCBDFFA32D636D936B37CF56C0C2BA94((&V_0), UQueryState_1_First_m0E66C612BCBDFFA32D636D936B37CF56C0C2BA94_RuntimeMethod_var);
V_2 = ((RuntimeObject*)Castclass((RuntimeObject*)((RuntimeObject*)IsInst((RuntimeObject*)L_48, il2cpp_rgctx_data(method->rgctx_data, 1))), il2cpp_rgctx_data(method->rgctx_data, 1)));
goto IL_0237;
}
IL_0114:
{
String_t* L_49 = ___className2;
V_5 = (bool)((((RuntimeObject*)(String_t*)L_49) == ((RuntimeObject*)(RuntimeObject*)NULL))? 1 : 0);
bool L_50 = V_5;
if (!L_50)
{
goto IL_0198;
}
}
{
il2cpp_codegen_runtime_class_init_inline(UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_il2cpp_TypeInfo_var);
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_51 = ___e0;
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA L_52;
L_52 = UQueryState_1_RebuildOn_m6A44E1618AB0FD0EDCBEEF093B74FDEA03723004((&((UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_StaticFields*)il2cpp_codegen_static_fields_for(UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_il2cpp_TypeInfo_var))->___SingleElementTypeAndNameQuery_5), L_51, UQueryState_1_RebuildOn_m6A44E1618AB0FD0EDCBEEF093B74FDEA03723004_RuntimeMethod_var);
V_0 = L_52;
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA L_53 = V_0;
List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC* L_54 = (List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC*)L_53.___m_Matchers_2;
RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E L_55;
L_55 = List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68(L_54, 0, List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68_RuntimeMethod_var);
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* L_56 = (StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD*)L_55.___complexSelector_1;
StyleSelectorU5BU5D_t11A633455FC601606B3DF3CEDDDAB1625B54708D* L_57;
L_57 = StyleComplexSelector_get_selectors_m54911D4E758E1A19A16E948D6D10BEB5795ADC02(L_56, NULL);
int32_t L_58 = 0;
StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362* L_59 = (L_57)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_58));
StyleSelectorPartU5BU5D_tBA574FB3E75E94E52874FDB7B05B9048E8A5421B* L_60;
L_60 = StyleSelector_get_parts_mE6EEAE6825862DDA89947B892B661A865D463CEF(L_59, NULL);
il2cpp_codegen_runtime_class_init_inline(il2cpp_rgctx_data(method->rgctx_data, 2));
IsOfType_1_tAD57152B527BA8DDBDA8E8C388140620049ADBE4* L_61 = ((IsOfType_1_tAD57152B527BA8DDBDA8E8C388140620049ADBE4_StaticFields*)il2cpp_codegen_static_fields_for(il2cpp_rgctx_data(method->rgctx_data, 2)))->___s_Instance_0;
StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 L_62;
L_62 = StyleSelectorPart_CreatePredicate_mB47D568BDD71A75929CCF6BD1981FE0565687EDD((RuntimeObject*)L_61, NULL);
(L_60)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470)L_62);
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA L_63 = V_0;
List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC* L_64 = (List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC*)L_63.___m_Matchers_2;
RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E L_65;
L_65 = List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68(L_64, 0, List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68_RuntimeMethod_var);
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* L_66 = (StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD*)L_65.___complexSelector_1;
StyleSelectorU5BU5D_t11A633455FC601606B3DF3CEDDDAB1625B54708D* L_67;
L_67 = StyleComplexSelector_get_selectors_m54911D4E758E1A19A16E948D6D10BEB5795ADC02(L_66, NULL);
int32_t L_68 = 0;
StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362* L_69 = (L_67)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_68));
StyleSelectorPartU5BU5D_tBA574FB3E75E94E52874FDB7B05B9048E8A5421B* L_70;
L_70 = StyleSelector_get_parts_mE6EEAE6825862DDA89947B892B661A865D463CEF(L_69, NULL);
String_t* L_71 = ___name1;
StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 L_72;
L_72 = StyleSelectorPart_CreateId_m0D9ACD2EEC4D2CA1081B8158ED53F268840568E4(L_71, NULL);
(L_70)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470)L_72);
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_73;
L_73 = UQueryState_1_First_m0E66C612BCBDFFA32D636D936B37CF56C0C2BA94((&V_0), UQueryState_1_First_m0E66C612BCBDFFA32D636D936B37CF56C0C2BA94_RuntimeMethod_var);
V_2 = ((RuntimeObject*)Castclass((RuntimeObject*)((RuntimeObject*)IsInst((RuntimeObject*)L_73, il2cpp_rgctx_data(method->rgctx_data, 1))), il2cpp_rgctx_data(method->rgctx_data, 1)));
goto IL_0237;
}
IL_0198:
{
il2cpp_codegen_runtime_class_init_inline(UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_il2cpp_TypeInfo_var);
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_74 = ___e0;
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA L_75;
L_75 = UQueryState_1_RebuildOn_m6A44E1618AB0FD0EDCBEEF093B74FDEA03723004((&((UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_StaticFields*)il2cpp_codegen_static_fields_for(UQueryExtensions_t1271382882DF1B8FEEDE5EFA510405ABA7BD3426_il2cpp_TypeInfo_var))->___SingleElementTypeAndNameAndClassQuery_7), L_74, UQueryState_1_RebuildOn_m6A44E1618AB0FD0EDCBEEF093B74FDEA03723004_RuntimeMethod_var);
V_0 = L_75;
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA L_76 = V_0;
List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC* L_77 = (List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC*)L_76.___m_Matchers_2;
RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E L_78;
L_78 = List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68(L_77, 0, List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68_RuntimeMethod_var);
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* L_79 = (StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD*)L_78.___complexSelector_1;
StyleSelectorU5BU5D_t11A633455FC601606B3DF3CEDDDAB1625B54708D* L_80;
L_80 = StyleComplexSelector_get_selectors_m54911D4E758E1A19A16E948D6D10BEB5795ADC02(L_79, NULL);
int32_t L_81 = 0;
StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362* L_82 = (L_80)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_81));
StyleSelectorPartU5BU5D_tBA574FB3E75E94E52874FDB7B05B9048E8A5421B* L_83;
L_83 = StyleSelector_get_parts_mE6EEAE6825862DDA89947B892B661A865D463CEF(L_82, NULL);
il2cpp_codegen_runtime_class_init_inline(il2cpp_rgctx_data(method->rgctx_data, 2));
IsOfType_1_tAD57152B527BA8DDBDA8E8C388140620049ADBE4* L_84 = ((IsOfType_1_tAD57152B527BA8DDBDA8E8C388140620049ADBE4_StaticFields*)il2cpp_codegen_static_fields_for(il2cpp_rgctx_data(method->rgctx_data, 2)))->___s_Instance_0;
StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 L_85;
L_85 = StyleSelectorPart_CreatePredicate_mB47D568BDD71A75929CCF6BD1981FE0565687EDD((RuntimeObject*)L_84, NULL);
(L_83)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(0), (StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470)L_85);
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA L_86 = V_0;
List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC* L_87 = (List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC*)L_86.___m_Matchers_2;
RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E L_88;
L_88 = List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68(L_87, 0, List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68_RuntimeMethod_var);
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* L_89 = (StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD*)L_88.___complexSelector_1;
StyleSelectorU5BU5D_t11A633455FC601606B3DF3CEDDDAB1625B54708D* L_90;
L_90 = StyleComplexSelector_get_selectors_m54911D4E758E1A19A16E948D6D10BEB5795ADC02(L_89, NULL);
int32_t L_91 = 0;
StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362* L_92 = (L_90)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_91));
StyleSelectorPartU5BU5D_tBA574FB3E75E94E52874FDB7B05B9048E8A5421B* L_93;
L_93 = StyleSelector_get_parts_mE6EEAE6825862DDA89947B892B661A865D463CEF(L_92, NULL);
String_t* L_94 = ___name1;
StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 L_95;
L_95 = StyleSelectorPart_CreateId_m0D9ACD2EEC4D2CA1081B8158ED53F268840568E4(L_94, NULL);
(L_93)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(1), (StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470)L_95);
UQueryState_1_t9A60C9E48C10156AE4F8BF8D5C4657061CEF02BA L_96 = V_0;
List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC* L_97 = (List_1_t7C8CC805CEADA09DFAC2AC1A5D731D5EE956F6DC*)L_96.___m_Matchers_2;
RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E L_98;
L_98 = List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68(L_97, 0, List_1_get_Item_mB33745D62B8763A3CCF432DC7DE3151625657F68_RuntimeMethod_var);
StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD* L_99 = (StyleComplexSelector_tE46C29F65FDBA48D3152781187401C8B55B7D8AD*)L_98.___complexSelector_1;
StyleSelectorU5BU5D_t11A633455FC601606B3DF3CEDDDAB1625B54708D* L_100;
L_100 = StyleComplexSelector_get_selectors_m54911D4E758E1A19A16E948D6D10BEB5795ADC02(L_99, NULL);
int32_t L_101 = 0;
StyleSelector_t9B00AE16312CA9F598A45B52F74BC14899CA7362* L_102 = (L_100)->GetAtUnchecked(static_cast<il2cpp_array_size_t>(L_101));
StyleSelectorPartU5BU5D_tBA574FB3E75E94E52874FDB7B05B9048E8A5421B* L_103;
L_103 = StyleSelector_get_parts_mE6EEAE6825862DDA89947B892B661A865D463CEF(L_102, NULL);
String_t* L_104 = ___className2;
StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470 L_105;
L_105 = StyleSelectorPart_CreateClass_m35749E6336C3E92EADB130D6BF196FD7AAB9F066(L_104, NULL);
(L_103)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(2), (StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470)L_105);
VisualElement_t2667F9D19E62C7A315927506C06F223AB9234115* L_106;
L_106 = UQueryState_1_First_m0E66C612BCBDFFA32D636D936B37CF56C0C2BA94((&V_0), UQueryState_1_First_m0E66C612BCBDFFA32D636D936B37CF56C0C2BA94_RuntimeMethod_var);
V_2 = ((RuntimeObject*)Castclass((RuntimeObject*)((RuntimeObject*)IsInst((RuntimeObject*)L_106, il2cpp_rgctx_data(method->rgctx_data, 1))), il2cpp_rgctx_data(method->rgctx_data, 1)));
goto IL_0237;
}
IL_0237:
{
RuntimeObject* L_107 = V_2;
return L_107;
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.Timeline.IntervalTree`1/Entry<System.Object>>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E* Unsafe_Add_TisEntry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E_m6E6A84DD9F1F538D8FBF5D86A6E539CCABEE6CFA_gshared (Entry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
Entry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(Entry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E);
return ((Entry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<System.Collections.Generic.KeyValuePair`2<UnityEngine.PropertyName,System.Object>>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13* Unsafe_Add_TisKeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13_m432213A53DA9CC4D0E30643D73EE0ED6D6BD0163_gshared (KeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
KeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(KeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13);
return ((KeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<Unity.Collections.NativeArray`1<System.UInt16>>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR NativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934* Unsafe_Add_TisNativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934_mC5D04E202A0C7AD19D03050D25A3D733D7471B9E_gshared (NativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
NativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(NativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934);
return ((NativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<Unity.Collections.NativeArray`1<UnityEngine.UIElements.Vertex>>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR NativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81* Unsafe_Add_TisNativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81_m348A0E46C2C7627BE4297CC6C453469EB5E760EC_gshared (NativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
NativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(NativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81);
return ((NativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.AnimatorClipInfo>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR AnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03* Unsafe_Add_TisAnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03_mB89EA93E34D5221851F0B07CA397F9B82D5DDCF8_gshared (AnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
AnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(AnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03);
return ((AnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<System.Byte>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t* Unsafe_Add_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_m4A68552F1DC743EBD60C3302C813A77917407F2A_gshared (uint8_t* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(uint8_t);
return ((uint8_t*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<System.Byte>(T&,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t* Unsafe_Add_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_mD3FD9885D7DCF64B3CD5BB156810537CA9F32FDA_gshared (uint8_t* ___source0, intptr_t ___elementOffset1, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
intptr_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(uint8_t);
return ((uint8_t*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, (int32_t)L_2))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<System.Char>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar* Unsafe_Add_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_mE81319461240AE0B662268C5CD28B5C3E2777BA5_gshared (Il2CppChar* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
Il2CppChar* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(Il2CppChar);
return ((Il2CppChar*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<System.Char>(T&,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar* Unsafe_Add_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_mA540E5C7B875BF9FBBA82DA277B186D1D66730CB_gshared (Il2CppChar* ___source0, intptr_t ___elementOffset1, const RuntimeMethod* method)
{
{
Il2CppChar* L_0 = ___source0;
intptr_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(Il2CppChar);
return ((Il2CppChar*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, (int32_t)L_2))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.Color32>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B* Unsafe_Add_TisColor32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B_mBF627D9065E8346867FBB8099E574E5B605A4A97_gshared (Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B);
return ((Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.ComputedTransitionProperty>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1* Unsafe_Add_TisComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1_m6ABF73158EDCB6833564F6C19C4F968AF6D9CD4E_gshared (ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1);
return ((ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<ClipperLib.DoublePoint>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001* Unsafe_Add_TisDoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001_m09EE5F55ACEB2D4685DDEA123839455B82B9A8F1_gshared (DoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
DoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(DoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001);
return ((DoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.EasingFunction>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR EasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4* Unsafe_Add_TisEasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4_m63A59421E4811302C339FD1EAF07231CFA60526C_gshared (EasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
EasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(EasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4);
return ((EasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.TextCore.LowLevel.GlyphPairAdjustmentRecord>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR GlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E* Unsafe_Add_TisGlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E_m128394D6FADF15D658158650396140BCA1C6ECA5_gshared (GlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
GlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(GlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E);
return ((GlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.TextCore.GlyphRect>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D* Unsafe_Add_TisGlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D_m212C8F4551CA4E63646139446F55E7B8FB726CF2_gshared (GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D);
return ((GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<System.Int32>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t* Unsafe_Add_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_m453886B415E4998526A1E69DE2EB5572AF0B760F_gshared (int32_t* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
int32_t* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(int32_t);
return ((int32_t*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<System.Int32Enum>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t* Unsafe_Add_TisInt32Enum_tCBAC8BA2BFF3A845FA599F303093BBBA374B6F0C_mC2A6C87F918FCCB76E060B08348C02D07A5F8229_gshared (int32_t* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
int32_t* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(int32_t);
return ((int32_t*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<ClipperLib.IntPoint>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR IntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B* Unsafe_Add_TisIntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B_m14F6F9C97E8593B40DD893E1C8218794C22734E8_gshared (IntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
IntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(IntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B);
return ((IntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.Timeline.IntervalTreeNode>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR IntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC* Unsafe_Add_TisIntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC_m236CC9B87E93B3B4A66667518608844E83CF20A3_gshared (IntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
IntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(IntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC);
return ((IntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.TextCore.Text.LigatureSubstitutionRecord>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27* Unsafe_Add_TisLigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27_mDB69C0D675F47497565DEA249DA4ACBE6616D1CF_gshared (LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27);
return ((LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.ManipulatorActivationFilter>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81* Unsafe_Add_TisManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81_m33BA31D8A80233513DA1DC02A9F1C9F86825D8FA_gshared (ManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
ManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(ManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81);
return ((ManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.TextCore.Text.MarkToBaseAdjustmentRecord>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR MarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437* Unsafe_Add_TisMarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437_m1A7B3D39E755836D0D37C30380CB210FBECAC3C2_gshared (MarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
MarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(MarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437);
return ((MarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.TextCore.Text.MarkToMarkAdjustmentRecord>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR MarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6* Unsafe_Add_TisMarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6_m8B4A16F647D9192F0A814061C427848DE5412298_gshared (MarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
MarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(MarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6);
return ((MarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.TextCore.Text.MultipleSubstitutionRecord>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC* Unsafe_Add_TisMultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC_m23BEBA1DB7E5CE703B81A74F45CFD3CA3D98F526_gshared (MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC);
return ((MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<System.Object>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject** Unsafe_Add_TisRuntimeObject_m65310B4345815F3D22896E6D6543FF1EA6DED5C1_gshared (RuntimeObject** ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
RuntimeObject** L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(RuntimeObject*);
return ((RuntimeObject**)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<System.Object>(T&,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject** Unsafe_Add_TisRuntimeObject_m5E189591B2B2CDA6BAB96A9C7D33790F69793583_gshared (RuntimeObject** ___source0, intptr_t ___elementOffset1, const RuntimeMethod* method)
{
{
RuntimeObject** L_0 = ___source0;
intptr_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(RuntimeObject*);
return ((RuntimeObject**)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, (int32_t)L_2))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.Playables.Playable>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F* Unsafe_Add_TisPlayable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F_mEF64F1FF9860841DBA175A47A93D46386F7CC390_gshared (Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F);
return ((Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.Playables.PlayableBinding>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4* Unsafe_Add_TisPlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4_mD3F63B3AD423D4507AC343A0D57A738909237504_gshared (PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4);
return ((PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.RaycastHit2D>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA* Unsafe_Add_TisRaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA_m84F97CC915128FB21190821CBAFD6080167BD763_gshared (RaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
RaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(RaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA);
return ((RaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.EventSystems.RaycastResult>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023* Unsafe_Add_TisRaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023_mF3A79FD07B2230F167BE94C1BE35ABACBE423B41_gshared (RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023);
return ((RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.UIR.RenderChainTextEntry>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11* Unsafe_Add_TisRenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11_m02EB9CF11BD63EF5D72D46CD252836B214CE79E9_gshared (RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11);
return ((RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.RuleMatcher>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E* Unsafe_Add_TisRuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E_m378C8B39FFE24F05081FFCB3B5E08A6BA93D3710_gshared (RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E);
return ((RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<System.SByte>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int8_t* Unsafe_Add_TisSByte_tFEFFEF5D2FEBF5207950AE6FAC150FC53B668DB5_mDF514FBA7C4E9F4E8A84822A556BAB1556166F0D_gshared (int8_t* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
int8_t* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(int8_t);
return ((int8_t*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.StyleSheets.SelectorMatchRecord>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7* Unsafe_Add_TisSelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7_mF45A4B5E105EEB1A98ACD8E273C8C7B217D7567B_gshared (SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7);
return ((SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.StylePropertyName>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF* Unsafe_Add_TisStylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF_mDC2D3F6D4DF0C3599412C671BAFBEC08DA9E19B7_gshared (StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF);
return ((StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.StyleSheets.StylePropertyValue>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2* Unsafe_Add_TisStylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2_m87EA1D5AB34F5F0522ADE518D82DC433ED16F74E_gshared (StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2);
return ((StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.StyleSelectorPart>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470* Unsafe_Add_TisStyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470_m3944B6A45184D78CCA551D12DD8C3A899F5E2CDB_gshared (StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470);
return ((StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.StyleSheets.Syntax.StyleSyntaxToken>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C* Unsafe_Add_TisStyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C_m5D8C0A9B5D5D10A6E01DCE9D3BDBD5B3CEC7A6B3_gshared (StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C);
return ((StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.StyleSheets.StyleValue>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5* Unsafe_Add_TisStyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5_m728D0AE9B3BCA8EEDD3FAC90E7ADD3E7F70D16FC_gshared (StyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
StyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(StyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5);
return ((StyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.StyleSheets.StyleValueManaged>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4* Unsafe_Add_TisStyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4_mE9F74795671DD3A22CD773FBB04CC69BD81172DD_gshared (StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4);
return ((StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.StyleVariable>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269* Unsafe_Add_TisStyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269_mC838E1EFAC8820C7DD2C59B032BA0BF6EACA95C2_gshared (StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269);
return ((StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.TimeValue>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E* Unsafe_Add_TisTimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E_m32F70400B0183F854D64934AB936B42BCC2B5E63_gshared (TimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
TimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(TimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E);
return ((TimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UICharInfo>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD* Unsafe_Add_TisUICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD_m2CEEAF3F4221614F77F2C38146C8F77B950DB9F5_gshared (UICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
UICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(UICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD);
return ((UICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UILineInfo>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC* Unsafe_Add_TisUILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC_mB5A201EC28FB2CDA5BC76F28E8FF603276F84147_gshared (UILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
UILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(UILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC);
return ((UILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIVertex>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207* Unsafe_Add_TisUIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207_mEA5DFB4CEA6277A7E7A09EE282ACADF9743D91A2_gshared (UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207);
return ((UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<System.UInt16>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t* Unsafe_Add_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_m00CE1BE86A53F50F349EB84A50606B3BB34E313C_gshared (uint16_t* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
uint16_t* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(uint16_t);
return ((uint16_t*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<System.UInt32>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t* Unsafe_Add_TisUInt32_t1833D51FFA667B18A5AA4B8D34DE284F8495D29B_mB2AD0A571FB86215CAE7851C4FAC86D655C88711_gshared (uint32_t* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
uint32_t* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(uint32_t);
return ((uint32_t*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.Vector2>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7* Unsafe_Add_TisVector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7_m863F00050BD75E0E1AF1AD5DCA12A5302F95C03E_gshared (Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7);
return ((Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.Vector3>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2* Unsafe_Add_TisVector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2_mFBAB3261AB580BDD55AEC7FFCB40D2ACE51B282E_gshared (Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2);
return ((Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.Vector4>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3* Unsafe_Add_TisVector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3_m2100ABDE323FBB57B7DE849153C8D615A6802E7A_gshared (Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3);
return ((Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.Timeline.AnimationOutputWeightProcessor/WeightInfo>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR WeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0* Unsafe_Add_TisWeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0_mA268A78C99D0174BD856F5E81DBB2E8E59B4EB34_gshared (WeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
WeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(WeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0);
return ((WeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.BeforeRenderHelper/OrderBlock>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837* Unsafe_Add_TisOrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837_m5B67A7E1C9DA30062E32EF18B00466C1620858F8_gshared (OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837);
return ((OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.UIR.BitmapAllocator32/Page>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Page_t04FE552A388BF55B12C8868E19589136957E00A5* Unsafe_Add_TisPage_t04FE552A388BF55B12C8868E19589136957E00A5_mE581A2BB9BCB0C990A8BFB2631B6C94DF47067CE_gshared (Page_t04FE552A388BF55B12C8868E19589136957E00A5* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
Page_t04FE552A388BF55B12C8868E19589136957E00A5* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(Page_t04FE552A388BF55B12C8868E19589136957E00A5);
return ((Page_t04FE552A388BF55B12C8868E19589136957E00A5*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.Camera/RenderRequest>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A* Unsafe_Add_TisRenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A_m401FDFCC7B23F25E875AEB3C62865350BE8395F0_gshared (RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A);
return ((RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<Cinemachine.CameraState/CustomBlendable>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB* Unsafe_Add_TisCustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB_mE381DD09E3361B802D1C323410EE74AD2CC811A2_gshared (CustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
CustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(CustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB);
return ((CustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<Cinemachine.CinemachineClearShot/Pair>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Pair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2* Unsafe_Add_TisPair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2_m69D9330139C87CBB0043B61EFF7BF3204EE85A8A_gshared (Pair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
Pair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(Pair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2);
return ((Pair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<Cinemachine.CinemachineStateDrivenCamera/HashPair>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR HashPair_t176F7624706A73500F3AB84D61111316D45ECCEC* Unsafe_Add_TisHashPair_t176F7624706A73500F3AB84D61111316D45ECCEC_m26F9245E13E1D16EACB99BF45D9C2C18A97D4E0B_gshared (HashPair_t176F7624706A73500F3AB84D61111316D45ECCEC* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
HashPair_t176F7624706A73500F3AB84D61111316D45ECCEC* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(HashPair_t176F7624706A73500F3AB84D61111316D45ECCEC);
return ((HashPair_t176F7624706A73500F3AB84D61111316D45ECCEC*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<Cinemachine.ConfinerOven/PolygonSolution>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C* Unsafe_Add_TisPolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C_m131AB4FE64182E916F3C6404D0E71D957485860B_gshared (PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C);
return ((PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.FocusController/FocusedElement>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF* Unsafe_Add_TisFocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF_mEA7EC1B836ADE2B947494288C2B2A1CCADDD0B98_gshared (FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF);
return ((FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.InternalTreeView/TreeViewItemWrapper>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F* Unsafe_Add_TisTreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F_mA6C8A7FB7F48BC5189366E6C86D6F216BF31F00B_gshared (TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F);
return ((TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<System.Text.RegularExpressions.RegexCharClass/SingleRange>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC* Unsafe_Add_TisSingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC_m4CA11B5641223BC37DC22640D242264DF4E10559_gshared (SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC);
return ((SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.UIR.RenderChain/RenderNodeData>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE* Unsafe_Add_TisRenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE_m4DEEA436986DDBCD24702EEEE76167E4AB706353_gshared (RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE);
return ((RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.TemplateAsset/AttributeOverride>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF* Unsafe_Add_TisAttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF_m3D083BA4C663FE6BB38EE7C034835CDA727218B1_gshared (AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF);
return ((AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.TextCore.Text.TextSettings/FontReferenceMap>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831* Unsafe_Add_TisFontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831_m99FA3C63E1558D3E60FEBEB63235E526C4677785_gshared (FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831);
return ((FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.UIR.TextureBlitter/BlitInfo>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357* Unsafe_Add_TisBlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357_mCF3B8511510B6D55B122BDFE018ED3ECDD686FA1_gshared (BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357);
return ((BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.TextureRegistry/TextureInfo>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B* Unsafe_Add_TisTextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B_m66D0958D7AA3BB3C91F934AA57F9122D29AF409A_gshared (TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B);
return ((TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.Timeline.TimeNotificationBehaviour/NotificationEntry>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62* Unsafe_Add_TisNotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62_mF7B7D9D6FD7E71790A42F72F2BD7394EFAA9B7EB_gshared (NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62);
return ((NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.TreeView/TreeViewItemWrapper>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE* Unsafe_Add_TisTreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE_m6BFBFB17A934633EC4568F0DC7A1E4E8763845CE_gshared (TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE);
return ((TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_tB8765CA56422E2C92887314844384843688DCB9F* Unsafe_Add_TisEntry_tB8765CA56422E2C92887314844384843688DCB9F_m64D8A0741D975ECB2101AFA3E28722B2F8BAE0D0_gshared (Entry_tB8765CA56422E2C92887314844384843688DCB9F* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
Entry_tB8765CA56422E2C92887314844384843688DCB9F* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(Entry_tB8765CA56422E2C92887314844384843688DCB9F);
return ((Entry_tB8765CA56422E2C92887314844384843688DCB9F*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.UIR.UIRenderDevice/AllocToFree>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8* Unsafe_Add_TisAllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8_mE581737F2B824AD7C3AFBA43BB8459CD7851B86E_gshared (AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8);
return ((AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512* Unsafe_Add_TisAllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512_mC6E9471E160A9538A66F0D290F789B64A2D75E1D_gshared (AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512);
return ((AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UnitySynchronizationContext/WorkRequest>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44* Unsafe_Add_TisWorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44_mA2E1BDBB285D35D70A55B578441DC5E9A2F341BF_gshared (WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44);
return ((WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.VisualTreeAsset/SlotDefinition>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8* Unsafe_Add_TisSlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8_mACD85EF72AF76DCEE2BC8F00C60D1B7D1AE72E79_gshared (SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8);
return ((SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.VisualTreeAsset/SlotUsageEntry>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76* Unsafe_Add_TisSlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76_mCF5C33AC197E65EB228090C21693F897664972DF_gshared (SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76);
return ((SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<UnityEngine.UIElements.VisualTreeAsset/UsingEntry>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484* Unsafe_Add_TisUsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484_m9422DBB8EA67AAE62DF4457DA314A2538E8C45FD_gshared (UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484);
return ((UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<Cinemachine.TargetPositionCache/CacheCurve/Item>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E* Unsafe_Add_TisItem_t590AA2925A38AA7EA48963775F482E9BA8525B4E_m9784CADD33618C1A318C7BE137805BCE6091638E_gshared (Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E);
return ((Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::Add<Cinemachine.TargetPositionCache/CacheEntry/RecordingItem>(T&,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E* Unsafe_Add_TisRecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E_m6FEED2B756222373552382C3BC5F19F62E384EF5_gshared (RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E* ___source0, int32_t ___elementOffset1, const RuntimeMethod* method)
{
{
RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E* L_0 = ___source0;
int32_t L_1 = ___elementOffset1;
uint32_t L_2 = sizeof(RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E);
return ((RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)il2cpp_codegen_multiply(L_1, ((intptr_t)L_2)))));
}
}
// T& System.Runtime.CompilerServices.Unsafe::AddByteOffset<System.Byte>(T&,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t* Unsafe_AddByteOffset_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_mA41D4DA1B6351213CB981A99F9505A45CF32389F_gshared (uint8_t* ___source0, intptr_t ___byteOffset1, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
intptr_t L_1 = ___byteOffset1;
return ((uint8_t*)il2cpp_codegen_add((intptr_t)L_0, L_1));
}
}
// T& System.Runtime.CompilerServices.Unsafe::AddByteOffset<System.Byte>(T&,System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t* Unsafe_AddByteOffset_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_m977F986E96198374865467E0C8BCA8C996DC6709_gshared (uint8_t* ___source0, uint64_t ___byteOffset1, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
uint64_t L_1 = ___byteOffset1;
intptr_t L_2;
L_2 = IntPtr_op_Explicit_m04BEF6277775C13DD8A986812AAA3FCEC32DCCBE((void*)((uintptr_t)L_1), NULL);
uint8_t* L_3;
L_3 = (( uint8_t* (*) (uint8_t*, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_0, L_2, il2cpp_rgctx_method(method->rgctx_data, 0));
return L_3;
}
}
// T& System.Runtime.CompilerServices.Unsafe::AddByteOffset<System.Object>(T&,System.IntPtr)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject** Unsafe_AddByteOffset_TisRuntimeObject_mE80524BC43C88F7426858D0F2D76EA278347344C_gshared (RuntimeObject** ___source0, intptr_t ___byteOffset1, const RuntimeMethod* method)
{
{
RuntimeObject** L_0 = ___source0;
intptr_t L_1 = ___byteOffset1;
return ((RuntimeObject**)il2cpp_codegen_add((intptr_t)L_0, L_1));
}
}
// T& System.Runtime.CompilerServices.Unsafe::AddByteOffset<System.Object>(T&,System.UInt64)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject** Unsafe_AddByteOffset_TisRuntimeObject_m865838483903046806DAADBFFC930C2F6ACA83C3_gshared (RuntimeObject** ___source0, uint64_t ___byteOffset1, const RuntimeMethod* method)
{
{
RuntimeObject** L_0 = ___source0;
uint64_t L_1 = ___byteOffset1;
intptr_t L_2;
L_2 = IntPtr_op_Explicit_m04BEF6277775C13DD8A986812AAA3FCEC32DCCBE((void*)((uintptr_t)L_1), NULL);
RuntimeObject** L_3;
L_3 = (( RuntimeObject** (*) (RuntimeObject**, intptr_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_0, L_2, il2cpp_rgctx_method(method->rgctx_data, 0));
return L_3;
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::AreSame<System.Byte>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_AreSame_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_m5D8903DC056729188D576E7F6D297CC65D43BB83_gshared (uint8_t* ___left0, uint8_t* ___right1, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___left0;
uint8_t* L_1 = ___right1;
return (bool)((((RuntimeObject*)(intptr_t)L_0) == ((RuntimeObject*)(intptr_t)L_1))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::AreSame<System.Char>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_AreSame_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_mB3F359D1CA4DAB5E960916F940617B5555E293BA_gshared (Il2CppChar* ___left0, Il2CppChar* ___right1, const RuntimeMethod* method)
{
{
Il2CppChar* L_0 = ___left0;
Il2CppChar* L_1 = ___right1;
return (bool)((((RuntimeObject*)(intptr_t)L_0) == ((RuntimeObject*)(intptr_t)L_1))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::AreSame<System.Object>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_AreSame_TisRuntimeObject_mB9C0F2D2E871C420C229B3EB06DE154607B02268_gshared (RuntimeObject** ___left0, RuntimeObject** ___right1, const RuntimeMethod* method)
{
{
RuntimeObject** L_0 = ___left0;
RuntimeObject** L_1 = ___right1;
return (bool)((((RuntimeObject*)(intptr_t)L_0) == ((RuntimeObject*)(intptr_t)L_1))? 1 : 0);
}
}
// T System.Runtime.CompilerServices.Unsafe::As<System.Object>(System.Object)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Unsafe_As_TisRuntimeObject_m4BCC0ED093BFD47D807324EA964B9020D6203B95_gshared (RuntimeObject* ___o0, const RuntimeMethod* method)
{
{
RuntimeObject* L_0 = ___o0;
return L_0;
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.Timeline.IntervalTree`1/Entry<System.Object>>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisEntry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E_m9D0A05F3A81C43F8F6A73B2B98726493D4C26042_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (Entry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,System.Collections.Generic.KeyValuePair`2<UnityEngine.PropertyName,System.Object>>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR KeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisKeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13_m0869B5383C77BD28985DE3A5A5EEFEC4D33CB5FF_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (KeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,Unity.Collections.NativeArray`1<System.UInt16>>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR NativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisNativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934_m2D596EF9512A1C69462F301AFEC5ABADFB5A18C3_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (NativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,Unity.Collections.NativeArray`1<UnityEngine.UIElements.Vertex>>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR NativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisNativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81_mCD406E5FFAF164AE4888EE2AA14A5BA957A9E4BF_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (NativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.AnimatorClipInfo>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR AnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisAnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03_mCEAD2AED827221E212BC4F9A5BBA5D263A9CB93B_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (AnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,System.Byte>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_mBBBF94FAEFE6ACF9937A9D5CB0AD67CFDBBC5FFE_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (uint8_t*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,System.Char>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_m675417BFAB48B7F7055A5D921C105C175ACCDF2E_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (Il2CppChar*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.Color32>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisColor32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B_mB6E1D2495BD9521359190756D0F7E93E0CEC3BA1_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.ComputedTransitionProperty>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1_m2DA6041FA81C99F8A8596274BF59C261BDCE85C7_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,ClipperLib.DoublePoint>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisDoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001_m2746A550D5B42142E07E985BEF562837FCD10B20_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (DoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.EasingFunction>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR EasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisEasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4_m91E9F05E444EE96A19BD82547C2A513E5D6DA509_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (EasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.TextCore.LowLevel.GlyphPairAdjustmentRecord>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR GlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisGlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E_m75B9D84D28B8B4F567381557F5D6BAC6C5C97B20_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (GlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.TextCore.GlyphRect>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisGlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D_m01AC5D18D5330B3EBE2E396F98ED9E4822D0908B_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,System.Int32>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_m81F9F17E7C2AAE3840B2CCBF247A17F898184B1B_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (int32_t*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,System.Int32Enum>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisInt32Enum_tCBAC8BA2BFF3A845FA599F303093BBBA374B6F0C_mD4883EE1EE8A818F3BDB87AA0E8129351234C029_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (int32_t*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,ClipperLib.IntPoint>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR IntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisIntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B_m071145D1ECAF19454CB08CE6AD4DDC5A24226660_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (IntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.Timeline.IntervalTreeNode>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR IntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisIntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC_mCCA254032878093EC42B6E9377747E2BF3B4E0B1_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (IntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.TextCore.Text.LigatureSubstitutionRecord>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisLigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27_m40279F0EA870C67B065C4414512A33EBD731F390_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.ManipulatorActivationFilter>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81_mE20696047A5434C9287ADB6466647742BE9832D8_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (ManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.TextCore.Text.MarkToBaseAdjustmentRecord>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR MarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisMarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437_mBAA8CBD3ACFABB7F5E03BA387D84C5D5AECEA32C_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (MarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.TextCore.Text.MarkToMarkAdjustmentRecord>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR MarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisMarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6_m1DF65325CF76B4FE430029C093436A59A72C2A9F_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (MarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.TextCore.Text.MultipleSubstitutionRecord>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisMultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC_m3FE27C95FFA65D8CB6D281CB0578C885356AA1F1_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,System.Object>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject** Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisRuntimeObject_m062C2E1C18C2BEFAB12E9ABFEF799CB33804BE4F_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (RuntimeObject**)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.Playables.Playable>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisPlayable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F_mC6A06BEBDBC46814940360BB2ECC61D614AB1894_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.Playables.PlayableBinding>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisPlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4_m8C93DA9B755A01C5FC6DA65510CBBD2CAE3A8EBB_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.RaycastHit2D>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisRaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA_m8D99050CA586B8666316498E12A25FE9C0709166_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (RaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.EventSystems.RaycastResult>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisRaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023_mACE7BA9CDED442766C8D197BCC61802503A46438_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.UIR.RenderChainTextEntry>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisRenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11_m853478F8540CA859DEDDA17B993D2FCA01321DE9_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.RuleMatcher>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisRuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E_mF6797AE06F2393F57DECD631C7F5AC4EA4AE97BE_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.StyleSheets.SelectorMatchRecord>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisSelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7_m05FBAB0560DB903FAC00F99681A03EFBBFC4BC86_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.StylePropertyName>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisStylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF_m2180A4295EEFD3D041BF2CF76D47B4B006CA6D5E_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.StyleSheets.StylePropertyValue>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisStylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2_m543A0356788BF0785544E0B66DBE5657A14BA3FA_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.StyleSelectorPart>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisStyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470_m5576C7EEC59B2CEA6F2D9086F26804C8944F2F1D_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.StyleSheets.Syntax.StyleSyntaxToken>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisStyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C_mE65B2C076B239D906FA58D603B2A276248EEABCD_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.StyleSheets.StyleValue>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisStyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5_mB24B2ED0B38B23DC1F9003CC9ED8611E1AD38AF3_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (StyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.StyleSheets.StyleValueManaged>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisStyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4_mAFA7BE26035BA3E4858E3EA2ECB745C253C5D4A1_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.StyleVariable>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisStyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269_mD5D85969486FE66A7086BC45A362DB5EB6464A1D_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.TimeValue>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisTimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E_mFC30ED2E38918AFA5F7BD1AC89CA2786BA2FDD63_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (TimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UICharInfo>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisUICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD_mC2C67D4881DD70E231FD361981FA2AC4C062885C_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (UICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UILineInfo>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisUILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC_mFE80BC26790A9A78D6D6EE9105FA6A2F84E8318C_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (UILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIVertex>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisUIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207_m83641DEF048851969B41965A94A25D846941D684_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,System.UInt16>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_m8289AC99DB8CCCE8C1D12C3592109A087F75FF31_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (uint16_t*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,System.UInt32>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisUInt32_t1833D51FFA667B18A5AA4B8D34DE284F8495D29B_mCE01536D41313BB14C2373248FD472794C97DB40_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (uint32_t*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.Vector2>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisVector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7_m57F2D58A594E5E8832F8601F726DC2F1E08A99B1_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.Vector3>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisVector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2_mC2086349ECB9CA3D0295A7D7F8011839C5E4EB6A_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.Vector4>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisVector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3_m84794FBB2F8E3AFFA4785C01DA879C62FB7D9932_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.Timeline.AnimationOutputWeightProcessor/WeightInfo>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR WeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisWeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0_m3C33AA3D950ABED293B4FE07226E778B0552579F_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (WeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.BeforeRenderHelper/OrderBlock>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisOrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837_mEB78B631669E0065089B3AFFC3C56FAF5C9AE762_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.UIR.BitmapAllocator32/Page>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Page_t04FE552A388BF55B12C8868E19589136957E00A5* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisPage_t04FE552A388BF55B12C8868E19589136957E00A5_m00BA967D1B1300D0C45903D2DDC5C8F4EA077D43_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (Page_t04FE552A388BF55B12C8868E19589136957E00A5*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.Camera/RenderRequest>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisRenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A_m24B9358C202F0C2A5E1B782AB1B90F0402E7BB5A_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,Cinemachine.CameraState/CustomBlendable>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR CustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisCustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB_m01A34ADE527E97B754F67B6E3F8C3762A90797C5_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (CustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,Cinemachine.CinemachineClearShot/Pair>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Pair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisPair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2_m9424430578D73DF82F3E4338F963526F247BBFD0_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (Pair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,Cinemachine.CinemachineStateDrivenCamera/HashPair>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR HashPair_t176F7624706A73500F3AB84D61111316D45ECCEC* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisHashPair_t176F7624706A73500F3AB84D61111316D45ECCEC_m0750DA5748E90E6998FABFC3EE9F792D1B7CC024_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (HashPair_t176F7624706A73500F3AB84D61111316D45ECCEC*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,Cinemachine.ConfinerOven/PolygonSolution>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisPolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C_mC2A154AD149CD442AA95F246FB4815CC7A906D04_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.FocusController/FocusedElement>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisFocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF_m5A147BFC4BE96572FD1F6651857A819C9EC62DD1_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.InternalTreeView/TreeViewItemWrapper>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisTreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F_mC93BE0F01640CE2C9605E44F0C492EC7475A40C2_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,System.Text.RegularExpressions.RegexCharClass/SingleRange>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisSingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC_m6ECB26CC6F64598A1A015884BE97B23F9A3FEE10_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.UIR.RenderChain/RenderNodeData>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisRenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE_m81AE203CADFD226356CDCF9DA09EA7152EC7B700_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.TemplateAsset/AttributeOverride>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisAttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF_mC229C3AA2927C3B4FB43901A8C8D78405F9AA9A6_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.TextCore.Text.TextSettings/FontReferenceMap>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisFontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831_m4CB89B6B3831BD8ED35F336399C214A9C4C75339_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.UIR.TextureBlitter/BlitInfo>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisBlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357_m7A4637AF6C371E9430B3DEAE0B7D9BC5E9AA7506_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.TextureRegistry/TextureInfo>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisTextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B_m5AA3F5E2FEDFB7110E930AED2D06F37CD5C72664_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.Timeline.TimeNotificationBehaviour/NotificationEntry>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisNotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62_m1E36AC595282F5FABED2EA83D8FBE6F328F8A923_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.TreeView/TreeViewItemWrapper>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisTreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE_m3F1C1A26CD502538037DEF227CD0D6ADF73C25C7_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Entry_tB8765CA56422E2C92887314844384843688DCB9F* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisEntry_tB8765CA56422E2C92887314844384843688DCB9F_m98E9E112D5B2B18D93BEDBFBADCF476F51E61162_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (Entry_tB8765CA56422E2C92887314844384843688DCB9F*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.UIR.UIRenderDevice/AllocToFree>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisAllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8_m2112CF58024905311FFF66635C1F56249CB949DD_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisAllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512_mD98E658E8BBF68CA0EFB6451E77B739579C5DEF1_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UnitySynchronizationContext/WorkRequest>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisWorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44_mD37A62DD0E9EBABD36703268B4DF2DE7AD3FF2B1_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.VisualTreeAsset/SlotDefinition>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisSlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8_m53E7026A89294A874B1E625347DB492FF5A5A7DE_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.VisualTreeAsset/SlotUsageEntry>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisSlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76_mBD23D3572159F9CA46578C85E0698C3D09AF984A_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,UnityEngine.UIElements.VisualTreeAsset/UsingEntry>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisUsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484_m359A86EA7381993B782F0F14F184698956413A40_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,Cinemachine.TargetPositionCache/CacheCurve/Item>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisItem_t590AA2925A38AA7EA48963775F482E9BA8525B4E_m89FA05CA601C2188DAE7BC33B0E07F00320E6C55_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Byte,Cinemachine.TargetPositionCache/CacheEntry/RecordingItem>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E* Unsafe_As_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_TisRecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E_mC54A3FDE7D6DAB13CE526D1B76894C3F5F870BCB_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return (RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Char,System.Byte>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t* Unsafe_As_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_m5CDBD1972E096D4D176783BA7D2F55EC593659B4_gshared (Il2CppChar* ___source0, const RuntimeMethod* method)
{
{
Il2CppChar* L_0 = ___source0;
return (uint8_t*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Char,System.Char>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar* Unsafe_As_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_mA862CB8DDBD498DBF1D9BFDB6CA1164FB1ABEC77_gshared (Il2CppChar* ___source0, const RuntimeMethod* method)
{
{
Il2CppChar* L_0 = ___source0;
return (Il2CppChar*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Decimal,System.Decimal/DecCalc>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DecCalc_t0E9BD1BAF25BAD15940FF4BAB400D012A8DEBCA9* Unsafe_As_TisDecimal_tDA6C877282B2D789CF97C0949661CC11D643969F_TisDecCalc_t0E9BD1BAF25BAD15940FF4BAB400D012A8DEBCA9_m655BE5526023C16AC00CD6B803DE2B0DFD794324_gshared (Decimal_tDA6C877282B2D789CF97C0949661CC11D643969F* ___source0, const RuntimeMethod* method)
{
{
Decimal_tDA6C877282B2D789CF97C0949661CC11D643969F* L_0 = ___source0;
return (DecCalc_t0E9BD1BAF25BAD15940FF4BAB400D012A8DEBCA9*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Int32,System.Byte>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t* Unsafe_As_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_mD4805CE1591A68B97CB60221B779D7F28DD6E75F_gshared (int32_t* ___source0, const RuntimeMethod* method)
{
{
int32_t* L_0 = ___source0;
return (uint8_t*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Int32,System.Char>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar* Unsafe_As_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_m3802F4924AEA902550EDEA7FDF3A6DBD83FDB4C6_gshared (int32_t* ___source0, const RuntimeMethod* method)
{
{
int32_t* L_0 = ___source0;
return (Il2CppChar*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Int32,System.UInt32>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t* Unsafe_As_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_TisUInt32_t1833D51FFA667B18A5AA4B8D34DE284F8495D29B_mD3C14204343AF6B57CA5A16AE342902E55A1960F_gshared (int32_t* ___source0, const RuntimeMethod* method)
{
{
int32_t* L_0 = ___source0;
return (uint32_t*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Int64,System.UInt64>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint64_t* Unsafe_As_TisInt64_t092CFB123BE63C28ACDAF65C68F21A526050DBA3_TisUInt64_t8F12534CC8FC4B5860F2A2CD1EE79D322E7A41AF_m088D7E6857BD4BBF5448E54572955E67820D3DD0_gshared (int64_t* ___source0, const RuntimeMethod* method)
{
{
int64_t* L_0 = ___source0;
return (uint64_t*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Object,System.Byte>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t* Unsafe_As_TisRuntimeObject_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_m01FE0BE10311CE6384A6264314453C262AFE3376_gshared (RuntimeObject** ___source0, const RuntimeMethod* method)
{
{
RuntimeObject** L_0 = ___source0;
return (uint8_t*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Object,System.Char>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar* Unsafe_As_TisRuntimeObject_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_m6F78DF114C69E12A3BD99748B63A4190CBE1844A_gshared (RuntimeObject** ___source0, const RuntimeMethod* method)
{
{
RuntimeObject** L_0 = ___source0;
return (Il2CppChar*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Object,System.Object>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject** Unsafe_As_TisRuntimeObject_TisRuntimeObject_m3E159F5FC9570A15B7E1F3FC0B60F2355DDB359A_gshared (RuntimeObject** ___source0, const RuntimeMethod* method)
{
{
RuntimeObject** L_0 = ___source0;
return (RuntimeObject**)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.Object,System.Threading.Volatile/VolatileObject>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR VolatileObject_tEA3ACFAAFB9D2EFA5162F693BAAB342EA7737B99* Unsafe_As_TisRuntimeObject_TisVolatileObject_tEA3ACFAAFB9D2EFA5162F693BAAB342EA7737B99_m3CF3EC45B1C0C599DAC55CC82268B1667987F41A_gshared (RuntimeObject** ___source0, const RuntimeMethod* method)
{
{
RuntimeObject** L_0 = ___source0;
return (VolatileObject_tEA3ACFAAFB9D2EFA5162F693BAAB342EA7737B99*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.UInt16,System.Byte>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t* Unsafe_As_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_m57A5214D254F55E06E1FA7982C48809FC38E3FD4_gshared (uint16_t* ___source0, const RuntimeMethod* method)
{
{
uint16_t* L_0 = ___source0;
return (uint8_t*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.UInt16,System.Char>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar* Unsafe_As_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_mA4854CB1F87781C7D1E8EAD9B5C11AE9103046D7_gshared (uint16_t* ___source0, const RuntimeMethod* method)
{
{
uint16_t* L_0 = ___source0;
return (Il2CppChar*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.UInt32,System.Byte>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t* Unsafe_As_TisUInt32_t1833D51FFA667B18A5AA4B8D34DE284F8495D29B_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_m4D4DA3640694446A5C811B6406B9D9DA4399A9BB_gshared (uint32_t* ___source0, const RuntimeMethod* method)
{
{
uint32_t* L_0 = ___source0;
return (uint8_t*)(L_0);
}
}
// TTo& System.Runtime.CompilerServices.Unsafe::As<System.UInt32,System.Char>(TFrom&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar* Unsafe_As_TisUInt32_t1833D51FFA667B18A5AA4B8D34DE284F8495D29B_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_mA3C1546104AEEB68DC37C9DE2E7CDCD6A5857DB0_gshared (uint32_t* ___source0, const RuntimeMethod* method)
{
{
uint32_t* L_0 = ___source0;
return (Il2CppChar*)(L_0);
}
}
// System.Void* System.Runtime.CompilerServices.Unsafe::AsPointer<System.Object>(T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void* Unsafe_AsPointer_TisRuntimeObject_mAB8648A0D038AA0BC8E9791B0F07B7417214FD17_gshared (RuntimeObject** ___value0, const RuntimeMethod* method)
{
{
RuntimeObject** L_0 = ___value0;
return (void*)(((uintptr_t)L_0));
}
}
// System.Void* System.Runtime.CompilerServices.Unsafe::AsPointer<System.Number/NumberBuffer/DigitsAndNullTerminator>(T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void* Unsafe_AsPointer_TisDigitsAndNullTerminator_tEF216B2D9886B3B6EBDBBA0E540214C013C02ECA_m50C725B5F441884D5668CB229CAB83C2D1EA2F5C_gshared (DigitsAndNullTerminator_tEF216B2D9886B3B6EBDBBA0E540214C013C02ECA* ___value0, const RuntimeMethod* method)
{
{
DigitsAndNullTerminator_tEF216B2D9886B3B6EBDBBA0E540214C013C02ECA* L_0 = ___value0;
return (void*)(((uintptr_t)L_0));
}
}
// T& System.Runtime.CompilerServices.Unsafe::AsRef<System.Byte>(T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t* Unsafe_AsRef_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_mDFABC34A7725F1807FFAF508A3F39C2ED7B7E30D_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
return L_0;
}
}
// T& System.Runtime.CompilerServices.Unsafe::AsRef<System.Byte>(System.Void*)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t* Unsafe_AsRef_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_mB69F8A5C8AC34D28CE255D958651E7308790D7E4_gshared (void* ___source0, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
return (uint8_t*)(L_0);
}
}
// T& System.Runtime.CompilerServices.Unsafe::AsRef<System.Char>(System.Void*)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Il2CppChar* Unsafe_AsRef_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_mEA9985C837E6BACDBA2D64A4425439584AA7ED57_gshared (void* ___source0, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
return (Il2CppChar*)(L_0);
}
}
// T& System.Runtime.CompilerServices.Unsafe::AsRef<System.Object>(T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject** Unsafe_AsRef_TisRuntimeObject_mEA31169F4A69CE64F46DB0525B359FB372B13784_gshared (RuntimeObject** ___source0, const RuntimeMethod* method)
{
{
RuntimeObject** L_0 = ___source0;
return L_0;
}
}
// T& System.Runtime.CompilerServices.Unsafe::AsRef<System.Object>(System.Void*)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject** Unsafe_AsRef_TisRuntimeObject_m816F6707FFA35CD3D93392AE9E18DC1F25170D04_gshared (void* ___source0, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
return (RuntimeObject**)(L_0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.Timeline.IntervalTree`1/Entry<System.Object>>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisEntry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E_m454EECA976AD44251CCBA62F5F0DF1C0087D487A_gshared (Entry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E* ___left0, Entry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E* ___right1, const RuntimeMethod* method)
{
{
Entry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E* L_0 = ___left0;
Entry_t2EBE8F0B2EC8789846CCD693457A5504B953A43E* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<System.Collections.Generic.KeyValuePair`2<UnityEngine.PropertyName,System.Object>>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisKeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13_m170D1440BCE98862343C9F5B559EA6F894DA5F9A_gshared (KeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13* ___left0, KeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13* ___right1, const RuntimeMethod* method)
{
{
KeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13* L_0 = ___left0;
KeyValuePair_2_t7D311E49C5BFA7AD0E1B6BDE838D7428E2CEDA13* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<Unity.Collections.NativeArray`1<System.UInt16>>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisNativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934_m31F98D8FF93369A593BA82FF237AE4216C4F6D20_gshared (NativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934* ___left0, NativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934* ___right1, const RuntimeMethod* method)
{
{
NativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934* L_0 = ___left0;
NativeArray_1_t275C00CC374DEA66C69B3BB3992116F315A8E934* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<Unity.Collections.NativeArray`1<UnityEngine.UIElements.Vertex>>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisNativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81_m996655CB0EFC531DE2A2DF2C3A702631088C7E27_gshared (NativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81* ___left0, NativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81* ___right1, const RuntimeMethod* method)
{
{
NativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81* L_0 = ___left0;
NativeArray_1_tB60512C6E4578B7CC8EB79321680E495E69ABF81* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.AnimatorClipInfo>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisAnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03_m2338AED738645EF60D1FF295009392F8677D49C5_gshared (AnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03* ___left0, AnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03* ___right1, const RuntimeMethod* method)
{
{
AnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03* L_0 = ___left0;
AnimatorClipInfo_t0C913173594C893E36282602F54ABD06AC1CFA03* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<System.Byte>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_m4E02D641D0F8180CCBBD2B7EF9E8DB4E6767B387_gshared (uint8_t* ___left0, uint8_t* ___right1, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___left0;
uint8_t* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<System.Char>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_m502F9AAFDDFD6C605D8287FA4A064C31EA7C313B_gshared (Il2CppChar* ___left0, Il2CppChar* ___right1, const RuntimeMethod* method)
{
{
Il2CppChar* L_0 = ___left0;
Il2CppChar* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.Color32>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisColor32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B_mFC087A02F3B1C65343DE4D84E8D9E8BEE1576C07_gshared (Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B* ___left0, Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B* ___right1, const RuntimeMethod* method)
{
{
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B* L_0 = ___left0;
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.ComputedTransitionProperty>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1_m343A7014A732FE1C1D7B23E7BD0FD0BC98107EC2_gshared (ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1* ___left0, ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1* ___right1, const RuntimeMethod* method)
{
{
ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1* L_0 = ___left0;
ComputedTransitionProperty_tD8E4D8EB5DD69E063944F27A48D9263F4F1354E1* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<ClipperLib.DoublePoint>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisDoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001_mF1F0E224366B15EF8552EB0BCC76567E23C359FF_gshared (DoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001* ___left0, DoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001* ___right1, const RuntimeMethod* method)
{
{
DoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001* L_0 = ___left0;
DoublePoint_t33850ADD186B1BE5B4A30E3B3CF8FFDFBA47A001* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.EasingFunction>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisEasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4_m12DC025A6061CE20BF224B6A849FB0CBCDD0AA32_gshared (EasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4* ___left0, EasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4* ___right1, const RuntimeMethod* method)
{
{
EasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4* L_0 = ___left0;
EasingFunction_t5197D3B06056326A8B5C96032CDEBD5D3BDCA7A4* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.TextCore.LowLevel.GlyphPairAdjustmentRecord>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisGlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E_m6D23FED8E45C2EFC489FF53567AFB9565FCBD8EB_gshared (GlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E* ___left0, GlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E* ___right1, const RuntimeMethod* method)
{
{
GlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E* L_0 = ___left0;
GlyphPairAdjustmentRecord_t6E4295094D349DBF22BC59116FBC8F22EA55420E* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.TextCore.GlyphRect>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisGlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D_m3B1620F7228EA5913CB9E70958A30B5F9A020482_gshared (GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D* ___left0, GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D* ___right1, const RuntimeMethod* method)
{
{
GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D* L_0 = ___left0;
GlyphRect_tB6D225B9318A527A1CBC1B4078EB923398EB808D* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<System.Int32>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_m8D6733A9842E92B88E3DABC7E7AEF45A56330821_gshared (int32_t* ___left0, int32_t* ___right1, const RuntimeMethod* method)
{
{
int32_t* L_0 = ___left0;
int32_t* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<System.Int32Enum>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisInt32Enum_tCBAC8BA2BFF3A845FA599F303093BBBA374B6F0C_m66968048706BDC5B8CC07A5AA1C6970835373A09_gshared (int32_t* ___left0, int32_t* ___right1, const RuntimeMethod* method)
{
{
int32_t* L_0 = ___left0;
int32_t* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<ClipperLib.IntPoint>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisIntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B_mE07C77F524ED5E861E368B35E1D4432CC2B6CBB6_gshared (IntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B* ___left0, IntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B* ___right1, const RuntimeMethod* method)
{
{
IntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B* L_0 = ___left0;
IntPoint_tD0B7229CD86B44CB04D8FFED76C37A0A3C820F2B* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.Timeline.IntervalTreeNode>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisIntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC_m5511D4AFB814A20095DE4733619D9DB193B7FBCE_gshared (IntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC* ___left0, IntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC* ___right1, const RuntimeMethod* method)
{
{
IntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC* L_0 = ___left0;
IntervalTreeNode_tDAA7D63276D62CD178C91CC7DF932C97896332EC* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.TextCore.Text.LigatureSubstitutionRecord>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisLigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27_mF6A79D7098DCD1BD21BD629F7F6ECA6B353DD2A7_gshared (LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27* ___left0, LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27* ___right1, const RuntimeMethod* method)
{
{
LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27* L_0 = ___left0;
LigatureSubstitutionRecord_t844AF79A2241444ACECD38AA0B3FE16877EE5E27* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.ManipulatorActivationFilter>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81_mE863CAABC63F145750E0E2094C4DB4DC4BEC17C7_gshared (ManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81* ___left0, ManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81* ___right1, const RuntimeMethod* method)
{
{
ManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81* L_0 = ___left0;
ManipulatorActivationFilter_t866A0295DA75EA271B30BDC1F9EEA2C4FDEB1A81* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.TextCore.Text.MarkToBaseAdjustmentRecord>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisMarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437_mADE27BE24355844DA3953E5D06E91FEF1776F024_gshared (MarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437* ___left0, MarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437* ___right1, const RuntimeMethod* method)
{
{
MarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437* L_0 = ___left0;
MarkToBaseAdjustmentRecord_t149C456964004CCC59B1CDA7C4BE23C3E143D437* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.TextCore.Text.MarkToMarkAdjustmentRecord>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisMarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6_mD5A5E7070CFF0D8EB1E6A17B16AC1A889E30D559_gshared (MarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6* ___left0, MarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6* ___right1, const RuntimeMethod* method)
{
{
MarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6* L_0 = ___left0;
MarkToMarkAdjustmentRecord_t370034FCBFB0A949D7057628D44942A7814ACCF6* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.TextCore.Text.MultipleSubstitutionRecord>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisMultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC_mB0C950FC307A01B742FD599C4D0858E246B943E9_gshared (MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC* ___left0, MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC* ___right1, const RuntimeMethod* method)
{
{
MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC* L_0 = ___left0;
MultipleSubstitutionRecord_tFE6A79431BC2A417E6789AE2AFDD0B0040E1A8AC* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<System.Object>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisRuntimeObject_m7F604C05F9E8FDA6F973BD7640B3CFB63B89EBC1_gshared (RuntimeObject** ___left0, RuntimeObject** ___right1, const RuntimeMethod* method)
{
{
RuntimeObject** L_0 = ___left0;
RuntimeObject** L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.Playables.Playable>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisPlayable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F_mD2373435F827EEEEB5C684948ADFBFEA8E261EBA_gshared (Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F* ___left0, Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F* ___right1, const RuntimeMethod* method)
{
{
Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F* L_0 = ___left0;
Playable_t95C6B795846BA0C7D96E4DA14897CCCF2554334F* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.Playables.PlayableBinding>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisPlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4_m929D13B272D37E03E24543AB9662C98FB51295E8_gshared (PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4* ___left0, PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4* ___right1, const RuntimeMethod* method)
{
{
PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4* L_0 = ___left0;
PlayableBinding_tB68B3BAC47F4F4C559640472174D5BEF93CB6AB4* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.RaycastHit2D>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisRaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA_mF14F30103D7E74ABAF540BAAF81AC91E894D8939_gshared (RaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA* ___left0, RaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA* ___right1, const RuntimeMethod* method)
{
{
RaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA* L_0 = ___left0;
RaycastHit2D_t3EAAA06E6603C6BC61AC1291DD881C5C1E23BDFA* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.EventSystems.RaycastResult>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisRaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023_m6475BEED23B701AE5B485386CF39ED0CCD44EB69_gshared (RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023* ___left0, RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023* ___right1, const RuntimeMethod* method)
{
{
RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023* L_0 = ___left0;
RaycastResult_tEC6A7B7CABA99C386F054F01E498AEC426CF8023* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.UIR.RenderChainTextEntry>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisRenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11_m0A32ACA34842C0A4F8E88A926FDCEF7732A922E8_gshared (RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11* ___left0, RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11* ___right1, const RuntimeMethod* method)
{
{
RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11* L_0 = ___left0;
RenderChainTextEntry_t3B07A86ED897E1859552D13B1CF046F585CF9D11* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.RuleMatcher>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisRuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E_m949C32E6F3F9C4D75325E3F670AB40052CC48755_gshared (RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E* ___left0, RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E* ___right1, const RuntimeMethod* method)
{
{
RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E* L_0 = ___left0;
RuleMatcher_t327CFEB02C81AA20E639DE949DCBBAB5E92FF28E* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.StyleSheets.SelectorMatchRecord>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisSelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7_m3D61EC01BC4C38D8A125D0D373C55A5D6A90AD66_gshared (SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7* ___left0, SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7* ___right1, const RuntimeMethod* method)
{
{
SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7* L_0 = ___left0;
SelectorMatchRecord_t1E93CDB54312CFB4A67768BB25ABB9AFB31BC5D7* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.StylePropertyName>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisStylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF_mAC6A652984E22A639B6CBBE47895DE85D486C383_gshared (StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF* ___left0, StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF* ___right1, const RuntimeMethod* method)
{
{
StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF* L_0 = ___left0;
StylePropertyName_tCBE2B561C690538C8514BF56426AC486DC35B6FF* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.StyleSheets.StylePropertyValue>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisStylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2_m435A8A27ABB2230FC80765D1895B2A83DD7F4DEF_gshared (StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2* ___left0, StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2* ___right1, const RuntimeMethod* method)
{
{
StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2* L_0 = ___left0;
StylePropertyValue_tED32F617FABE99611B213BFCF9D1D909E7F141C2* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.StyleSelectorPart>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisStyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470_mCF3EFB661BC3D619C113832F1F0F1D2636F8B628_gshared (StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470* ___left0, StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470* ___right1, const RuntimeMethod* method)
{
{
StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470* L_0 = ___left0;
StyleSelectorPart_tEE5B8ADC7D114C7486CC8301FF96C114FF3C9470* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.StyleSheets.Syntax.StyleSyntaxToken>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisStyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C_m3F45BD980810B5A333893DC54C0E7655642CEE72_gshared (StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C* ___left0, StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C* ___right1, const RuntimeMethod* method)
{
{
StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C* L_0 = ___left0;
StyleSyntaxToken_tE4474F86F800F298F966FFDE947528453E769E0C* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.StyleSheets.StyleValue>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisStyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5_m36BF461911D04778975C0AC25D9E7A0D4934E1A0_gshared (StyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5* ___left0, StyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5* ___right1, const RuntimeMethod* method)
{
{
StyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5* L_0 = ___left0;
StyleValue_t56307594EC04E04EFBCC3220595B4AAD66FF93C5* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.StyleSheets.StyleValueManaged>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisStyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4_m7BCF69CCA5F97327C7DC2428DAEA9A31F025C06A_gshared (StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4* ___left0, StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4* ___right1, const RuntimeMethod* method)
{
{
StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4* L_0 = ___left0;
StyleValueManaged_t68DFBEC1594279E4DC56634FD5092318D1E9A5F4* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.StyleVariable>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisStyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269_m2B3B27FF2EE786FB8E3A1108EBDA8A45380EF4D3_gshared (StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269* ___left0, StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269* ___right1, const RuntimeMethod* method)
{
{
StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269* L_0 = ___left0;
StyleVariable_t5D4DEC936102A13961F4F2C6214B83D6CDC56269* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.TimeValue>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisTimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E_mD3AE5611CA1D62F6AF43F1FD344EE4282F0B01DC_gshared (TimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E* ___left0, TimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E* ___right1, const RuntimeMethod* method)
{
{
TimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E* L_0 = ___left0;
TimeValue_t45AE43B219493F9459363F32C79E8986B5F82E0E* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UICharInfo>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisUICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD_m89FE910113E3D1BFD969C38C6C93A2A3A868BFE1_gshared (UICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD* ___left0, UICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD* ___right1, const RuntimeMethod* method)
{
{
UICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD* L_0 = ___left0;
UICharInfo_t24C2EA0F2F3A938100C271891D9DEB015ABA5FBD* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UILineInfo>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisUILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC_m600D46F0834BF9D37BA75222E9C8D99C870B8EB8_gshared (UILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC* ___left0, UILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC* ___right1, const RuntimeMethod* method)
{
{
UILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC* L_0 = ___left0;
UILineInfo_tC6FF4F85BD2316FADA2148A1789B3FF0B05A6CAC* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIVertex>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisUIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207_mF6BEAE3A599E972181E03D5FFC3AD9CBCC33A158_gshared (UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207* ___left0, UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207* ___right1, const RuntimeMethod* method)
{
{
UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207* L_0 = ___left0;
UIVertex_tF5C663F4BBC786C9D56C28016FF66E6C6BF85207* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<System.UInt32>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisUInt32_t1833D51FFA667B18A5AA4B8D34DE284F8495D29B_mABC4005334CB97DC64C7890A0F3385F00CCE86D1_gshared (uint32_t* ___left0, uint32_t* ___right1, const RuntimeMethod* method)
{
{
uint32_t* L_0 = ___left0;
uint32_t* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.Vector2>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisVector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7_m2A9D9BD4F12FCB8930151B6F27318F3B2E3F9094_gshared (Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7* ___left0, Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7* ___right1, const RuntimeMethod* method)
{
{
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7* L_0 = ___left0;
Vector2_t1FD6F485C871E832B347AB2DC8CBA08B739D8DF7* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.Vector3>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisVector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2_m37DAB5D2C0D08923E413CE0D8599DAA4BB2DD54C_gshared (Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2* ___left0, Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2* ___right1, const RuntimeMethod* method)
{
{
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2* L_0 = ___left0;
Vector3_t24C512C7B96BBABAD472002D0BA2BDA40A5A80B2* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.Vector4>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisVector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3_m0EBF4F8C97EAA03D7601F9D7FE9B2CD63F006986_gshared (Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3* ___left0, Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3* ___right1, const RuntimeMethod* method)
{
{
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3* L_0 = ___left0;
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.Timeline.AnimationOutputWeightProcessor/WeightInfo>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisWeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0_m49B538468A5B8C1878165F13C115680F9C07C4BB_gshared (WeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0* ___left0, WeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0* ___right1, const RuntimeMethod* method)
{
{
WeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0* L_0 = ___left0;
WeightInfo_t9942B0D2C77A00A5C9824732AEAA0AB0A55620B0* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.BeforeRenderHelper/OrderBlock>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisOrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837_m85010A41B4DE43F32D5B5090F42B1A68BA587B36_gshared (OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837* ___left0, OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837* ___right1, const RuntimeMethod* method)
{
{
OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837* L_0 = ___left0;
OrderBlock_t62FD6F6544F34B5298DEF2F77AAE446F269B7837* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.UIR.BitmapAllocator32/Page>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisPage_t04FE552A388BF55B12C8868E19589136957E00A5_mED4C934658E599649C532BE6E3E8C1D668667D98_gshared (Page_t04FE552A388BF55B12C8868E19589136957E00A5* ___left0, Page_t04FE552A388BF55B12C8868E19589136957E00A5* ___right1, const RuntimeMethod* method)
{
{
Page_t04FE552A388BF55B12C8868E19589136957E00A5* L_0 = ___left0;
Page_t04FE552A388BF55B12C8868E19589136957E00A5* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.Camera/RenderRequest>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisRenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A_m72169E1441E871B449CDC3578593F4F5C9A3DFB0_gshared (RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A* ___left0, RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A* ___right1, const RuntimeMethod* method)
{
{
RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A* L_0 = ___left0;
RenderRequest_t432931B06439AC4704282E924DE8A9A474DB6B9A* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<Cinemachine.CameraState/CustomBlendable>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisCustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB_mDE7390C3EAE42EB65D624E6E1DA8A8BC2982187D_gshared (CustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB* ___left0, CustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB* ___right1, const RuntimeMethod* method)
{
{
CustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB* L_0 = ___left0;
CustomBlendable_t99FF1C1C42F08A7265E2842451D5CB2F4BFF16CB* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<Cinemachine.CinemachineClearShot/Pair>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisPair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2_m919B3C36B84CE1AB056DFAE2C31C7DAB8A7F5591_gshared (Pair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2* ___left0, Pair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2* ___right1, const RuntimeMethod* method)
{
{
Pair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2* L_0 = ___left0;
Pair_t395B1EC1E7854C08811AF7E0584C4BA7AE3C6AF2* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<Cinemachine.CinemachineStateDrivenCamera/HashPair>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisHashPair_t176F7624706A73500F3AB84D61111316D45ECCEC_m095128901B1DB972C26FB7C216C1EC124F7EDD31_gshared (HashPair_t176F7624706A73500F3AB84D61111316D45ECCEC* ___left0, HashPair_t176F7624706A73500F3AB84D61111316D45ECCEC* ___right1, const RuntimeMethod* method)
{
{
HashPair_t176F7624706A73500F3AB84D61111316D45ECCEC* L_0 = ___left0;
HashPair_t176F7624706A73500F3AB84D61111316D45ECCEC* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<Cinemachine.ConfinerOven/PolygonSolution>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisPolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C_m32B380CAD63003453D6EEFA76F2D859DE107069A_gshared (PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C* ___left0, PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C* ___right1, const RuntimeMethod* method)
{
{
PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C* L_0 = ___left0;
PolygonSolution_tAF24FAC932885B257486B439AACD765C7D49CB4C* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.FocusController/FocusedElement>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisFocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF_m1B60202721184F322A71948959696C4CBCE2DAE5_gshared (FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF* ___left0, FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF* ___right1, const RuntimeMethod* method)
{
{
FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF* L_0 = ___left0;
FocusedElement_t1EE083A1C5276213C533A38C6B5DC02E9DE5CBEF* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.InternalTreeView/TreeViewItemWrapper>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisTreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F_mB6FE5BA6BEF2FC657B14F6153B086B312103BEC6_gshared (TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F* ___left0, TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F* ___right1, const RuntimeMethod* method)
{
{
TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F* L_0 = ___left0;
TreeViewItemWrapper_tFA593EC4B06E0C963C0EAA9C18DDC99EEDC05D1F* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<System.Text.RegularExpressions.RegexCharClass/SingleRange>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisSingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC_mA49800B47A0E4E88CD5339DA32235F0C002428B0_gshared (SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC* ___left0, SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC* ___right1, const RuntimeMethod* method)
{
{
SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC* L_0 = ___left0;
SingleRange_tB50C1C2B62BDC445BDBA41FD3CDC77A45A211BBC* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.UIR.RenderChain/RenderNodeData>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisRenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE_mAC3A5EE61665F3DFDE8B6BE0AAF10C423706F211_gshared (RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE* ___left0, RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE* ___right1, const RuntimeMethod* method)
{
{
RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE* L_0 = ___left0;
RenderNodeData_t7527D1643CC280CE2B2E40AB9F5154615B7A99AE* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.TemplateAsset/AttributeOverride>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisAttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF_m8B77CD210CBA70BC8A5A44F2A2CFAD97D2710D28_gshared (AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF* ___left0, AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF* ___right1, const RuntimeMethod* method)
{
{
AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF* L_0 = ___left0;
AttributeOverride_t58F1DF22E69714D48ECBEEAD266D443A858BADEF* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.TextCore.Text.TextSettings/FontReferenceMap>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisFontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831_m79C471E31C8144B52A0E5CF9D18DCE8D4CACD2DD_gshared (FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831* ___left0, FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831* ___right1, const RuntimeMethod* method)
{
{
FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831* L_0 = ___left0;
FontReferenceMap_t1C0CECF3F0F650BE4A881A50A25EFB26965E7831* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.UIR.TextureBlitter/BlitInfo>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisBlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357_mB0C629E8EDE547FA5155E7FBF58B2A572294D482_gshared (BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357* ___left0, BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357* ___right1, const RuntimeMethod* method)
{
{
BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357* L_0 = ___left0;
BlitInfo_t6D4C0580BBEF65F5EAD39FB6DBC85F360CF6A357* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.TextureRegistry/TextureInfo>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisTextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B_m1DEC3D29B9FF60965B96400D2ACD1E0430DA76CE_gshared (TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B* ___left0, TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B* ___right1, const RuntimeMethod* method)
{
{
TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B* L_0 = ___left0;
TextureInfo_t581C305A0444F786E0E7405054714685BE3A5A5B* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.Timeline.TimeNotificationBehaviour/NotificationEntry>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisNotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62_m39B9871C23CD63A3E6BB3BD27CD944A3FB4EB865_gshared (NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62* ___left0, NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62* ___right1, const RuntimeMethod* method)
{
{
NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62* L_0 = ___left0;
NotificationEntry_tBBA39A8ACD63E90360DB0FFC4835E8702DFC2E62* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.TreeView/TreeViewItemWrapper>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisTreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE_mCD9845FB0F62DCEE236E7B7A4BC7E14BD8CDAAA7_gshared (TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE* ___left0, TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE* ___right1, const RuntimeMethod* method)
{
{
TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE* L_0 = ___left0;
TreeViewItemWrapper_t8130863A8182C5BF6925A88AF5E77192A4D519CE* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.UIR.Implementation.UIRStylePainter/Entry>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisEntry_tB8765CA56422E2C92887314844384843688DCB9F_m9070207A00425FCDA5075D59D183C3EC97A31901_gshared (Entry_tB8765CA56422E2C92887314844384843688DCB9F* ___left0, Entry_tB8765CA56422E2C92887314844384843688DCB9F* ___right1, const RuntimeMethod* method)
{
{
Entry_tB8765CA56422E2C92887314844384843688DCB9F* L_0 = ___left0;
Entry_tB8765CA56422E2C92887314844384843688DCB9F* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.UIR.UIRenderDevice/AllocToFree>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisAllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8_m53C552D4E0A0281C962BC96228ACB64D135CD886_gshared (AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8* ___left0, AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8* ___right1, const RuntimeMethod* method)
{
{
AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8* L_0 = ___left0;
AllocToFree_tC46982856CB8220A92BB724F5FB75CCCD09C67D8* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.UIR.UIRenderDevice/AllocToUpdate>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisAllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512_m16576A623B017469576470A46F121DD87D9F24F8_gshared (AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512* ___left0, AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512* ___right1, const RuntimeMethod* method)
{
{
AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512* L_0 = ___left0;
AllocToUpdate_tD0221D0ABC5378DDE5AAB1DAA219C337E562B512* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UnitySynchronizationContext/WorkRequest>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisWorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44_mEC6CE53A8B998893796D4A6AD37469074A262D4A_gshared (WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44* ___left0, WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44* ___right1, const RuntimeMethod* method)
{
{
WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44* L_0 = ___left0;
WorkRequest_t8AF542F2E248D9234341817CDB5F76C27D348B44* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.VisualTreeAsset/SlotDefinition>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisSlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8_m2640CB73C2CC9CACDAAD43C55B56BEFB8A3055AD_gshared (SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8* ___left0, SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8* ___right1, const RuntimeMethod* method)
{
{
SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8* L_0 = ___left0;
SlotDefinition_t2E39E965BBE5A336DD1B93A115DD01044D1A66F8* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.VisualTreeAsset/SlotUsageEntry>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisSlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76_mA0AB76BE22DE14406619577351B06194C9AD4B1A_gshared (SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76* ___left0, SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76* ___right1, const RuntimeMethod* method)
{
{
SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76* L_0 = ___left0;
SlotUsageEntry_t73A628038C799E4FD44436E093EC19D2B9EA1B76* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<UnityEngine.UIElements.VisualTreeAsset/UsingEntry>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisUsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484_m5BD5158A468E5904BCCA825E26FAC6B04E7A88DB_gshared (UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484* ___left0, UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484* ___right1, const RuntimeMethod* method)
{
{
UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484* L_0 = ___left0;
UsingEntry_t0454AD34026FDFD1733CE07BD4AE807B0FBCE484* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<Cinemachine.TargetPositionCache/CacheCurve/Item>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisItem_t590AA2925A38AA7EA48963775F482E9BA8525B4E_m5AFA7A08F6F4129C7EBD47A46139B2F33545ECF8_gshared (Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E* ___left0, Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E* ___right1, const RuntimeMethod* method)
{
{
Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E* L_0 = ___left0;
Item_t590AA2925A38AA7EA48963775F482E9BA8525B4E* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// System.Boolean System.Runtime.CompilerServices.Unsafe::IsAddressLessThan<Cinemachine.TargetPositionCache/CacheEntry/RecordingItem>(T&,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool Unsafe_IsAddressLessThan_TisRecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E_m13F403036EE29EB933FFAF2FE362D9479B63407E_gshared (RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E* ___left0, RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E* ___right1, const RuntimeMethod* method)
{
{
RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E* L_0 = ___left0;
RecordingItem_t5CE44E9AB838D651799847F74609435470D50A1E* L_1 = ___right1;
return (bool)((!(((RuntimeObject*)(uintptr_t)L_0) >= ((RuntimeObject*)(uintptr_t)L_1)))? 1 : 0);
}
}
// T System.Runtime.CompilerServices.Unsafe::Read<System.Numerics.Vector`1<System.UInt16>>(System.Void*)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 Unsafe_Read_TisVector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489_mE7FD30B8ED7259EC7CF1DD9978909EA43BFA52E9_gshared (void* ___source0, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 L_1 = (*(Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489*)L_0);
return L_1;
}
}
// T System.Runtime.CompilerServices.Unsafe::Read<System.Object>(System.Void*)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Unsafe_Read_TisRuntimeObject_mE4C9D6B542D202B075488A0B484D583E63B175EF_gshared (void* ___source0, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
RuntimeObject* L_1 = (*(RuntimeObject**)L_0);
return L_1;
}
}
// T System.Runtime.CompilerServices.Unsafe::ReadUnaligned<System.Numerics.Vector`1<System.UInt16>>(System.Byte&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 Unsafe_ReadUnaligned_TisVector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489_m19B8BC6045269AC7201FDEEE8BBBC7E0B8EBEA72_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 L_1 = (*(Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489*)L_0);
return L_1;
}
}
// T System.Runtime.CompilerServices.Unsafe::ReadUnaligned<System.Int32>(System.Byte&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Unsafe_ReadUnaligned_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_m385DFBBD0FD3CF8B72069D142B8AAA375DB6FC54_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
int32_t L_1 = (*(int32_t*)L_0);
return L_1;
}
}
// T System.Runtime.CompilerServices.Unsafe::ReadUnaligned<System.Object>(System.Byte&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Unsafe_ReadUnaligned_TisRuntimeObject_mCA74A4B8D120C37E493CBECDC3CD7310B0403435_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
RuntimeObject* L_1 = (*(RuntimeObject**)L_0);
return L_1;
}
}
// T System.Runtime.CompilerServices.Unsafe::ReadUnaligned<System.UInt16>(System.Byte&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t Unsafe_ReadUnaligned_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_mE444B74BEB5C615DAB1AEFB35D4159A4A7B5723C_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
uint16_t L_1 = (*(uint16_t*)L_0);
return L_1;
}
}
// T System.Runtime.CompilerServices.Unsafe::ReadUnaligned<System.UInt32>(System.Byte&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint32_t Unsafe_ReadUnaligned_TisUInt32_t1833D51FFA667B18A5AA4B8D34DE284F8495D29B_m525EE4C96BF37CA9D8ADDC9969A115C4ED48F009_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
uint32_t L_1 = (*(uint32_t*)L_0);
return L_1;
}
}
// T System.Runtime.CompilerServices.Unsafe::ReadUnaligned<System.UIntPtr>(System.Byte&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uintptr_t Unsafe_ReadUnaligned_TisUIntPtr_t_m954A0043ABD89608CAD7C7CEF794530C1952981B_gshared (uint8_t* ___source0, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___source0;
uintptr_t L_1 = (*(uintptr_t*)L_0);
return L_1;
}
}
// System.Int32 System.Runtime.CompilerServices.Unsafe::SizeOf<System.Numerics.Vector`1<System.UInt16>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Unsafe_SizeOf_TisVector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489_mF7F8CE507D0D65CE769DD205191AC25A8057EAAC_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489);
return (int32_t)L_0;
}
}
// System.Int32 System.Runtime.CompilerServices.Unsafe::SizeOf<System.Byte>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Unsafe_SizeOf_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_mEAF4DFAD570F6A0F25E17C34E9AAA9131B96AC9C_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(uint8_t);
return (int32_t)L_0;
}
}
// System.Int32 System.Runtime.CompilerServices.Unsafe::SizeOf<System.Char>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Unsafe_SizeOf_TisChar_t521A6F19B456D956AF452D926C32709DC03D6B17_m234AEF941FF3D72B5570DBE807B3AFEB3343906A_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(Il2CppChar);
return (int32_t)L_0;
}
}
// System.Int32 System.Runtime.CompilerServices.Unsafe::SizeOf<System.Int32>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Unsafe_SizeOf_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_m29CFE4DF51CADD200D23D7093D4C4AE7BE8747BD_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(int32_t);
return (int32_t)L_0;
}
}
// System.Int32 System.Runtime.CompilerServices.Unsafe::SizeOf<System.Object>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Unsafe_SizeOf_TisRuntimeObject_mA22951023930DCF5FB04D26D4F61AFC71F5C364E_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(RuntimeObject*);
return (int32_t)L_0;
}
}
// System.Int32 System.Runtime.CompilerServices.Unsafe::SizeOf<System.UInt16>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Unsafe_SizeOf_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_m33F5A3F372CCE962897122AC2428EF23303140A7_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(uint16_t);
return (int32_t)L_0;
}
}
// System.Int32 System.Runtime.CompilerServices.Unsafe::SizeOf<System.UInt32>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t Unsafe_SizeOf_TisUInt32_t1833D51FFA667B18A5AA4B8D34DE284F8495D29B_m0E93389411F91A993ED18D746F4FD1AE8FF2780B_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(uint32_t);
return (int32_t)L_0;
}
}
// System.Void System.Runtime.CompilerServices.Unsafe::WriteUnaligned<System.Object>(System.Byte&,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Unsafe_WriteUnaligned_TisRuntimeObject_mEDA97602DC0EB8DC2665E08DAF87B32B5DC37396_gshared (uint8_t* ___destination0, RuntimeObject* ___value1, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___destination0;
RuntimeObject* L_1 = ___value1;
*(RuntimeObject**)L_0 = L_1;
Il2CppCodeGenWriteBarrier((void**)(RuntimeObject**)L_0, (void*)L_1);
return;
}
}
// System.Void System.Runtime.CompilerServices.Unsafe::WriteUnaligned<System.UInt32>(System.Byte&,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Unsafe_WriteUnaligned_TisUInt32_t1833D51FFA667B18A5AA4B8D34DE284F8495D29B_m7B733AB630A479ABA40D0073873EE68B3E6496EB_gshared (uint8_t* ___destination0, uint32_t ___value1, const RuntimeMethod* method)
{
{
uint8_t* L_0 = ___destination0;
uint32_t L_1 = ___value1;
*(uint32_t*)L_0 = L_1;
return;
}
}
// System.Void* Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AddressOf<UnityEngine.UIElements.UIR.OpacityIdAccelerator/OpacityIdUpdateJob>(T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void* UnsafeUtility_AddressOf_TisOpacityIdUpdateJob_t44287EF1EDECBC73C16DD75791575F362A19A110_mD8CE4B072E656B1BFB011C70A75AE39A2BEDE135_gshared (OpacityIdUpdateJob_t44287EF1EDECBC73C16DD75791575F362A19A110* ___output0, const RuntimeMethod* method)
{
{
OpacityIdUpdateJob_t44287EF1EDECBC73C16DD75791575F362A19A110* L_0 = ___output0;
return (void*)(L_0);
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<UnityEngine.Rendering.BatchVisibility>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisBatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA_m07CC5D724FB51097BD1C26AF28FC5168FE713CFC_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<System.Byte>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_mF03E614161BF995D77845FFA04D22A72E8732A89_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<UnityEngine.Color>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisColor_tD001788D726C3A7F1379BEED0260B9591F440C1F_m5867683CC34E6B1B99FAC622E00D4130EB17684E_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<UnityEngine.Color32>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisColor32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B_m8B17D8D6F4DC1BAFEE28AD46E84F0AC6FB668030_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<UnityEngine.UIElements.UIR.DrawBufferRange>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisDrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4_m215AAE884BAC74B43A7E5D079D210CA1CCB61623_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<UnityEngine.UIElements.UIR.GfxUpdateBufferRange>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisGfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97_m025F45CD26DD2B180F68B916D4D50BE3CE92A6AC_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<System.Int32>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_mAC90D2724553DBDDB2A54AEC2892E8FC47A67031_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<Unity.Jobs.JobHandle>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisJobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08_m4FB093B267B2DAC8FCBBF5D4B91B3CB79C52F83A_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<UnityEngine.Experimental.GlobalIllumination.LightDataGI>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisLightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21_mDD9F31966971943321FED873DFE368772832FDBC_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<UnityEngine.ModifiableContactPair>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960_m6F9345EB658596C7C348B419F5D1AA275AD7D727_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<UnityEngine.Plane>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisPlane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C_mAE1CDD7C47AFF17EE65CE931B12ABAAC7EB95B7B_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<UnityEngine.UIElements.TextVertex>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisTextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3_m1168AF81092523FB280C60369857EF523ED98AF1_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<UnityEngine.UIElements.UIR.Transform3x4>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisTransform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F_m830A211579408D52BA331D3E35DA889363CB313F_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<System.UInt16>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_mC29212C619B3A7E60488E17A827AD1C101B75822_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<UnityEngine.Vector4>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisVector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3_m19DAF130AA28E3DDE2FCBB507846EB9718383329_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::AlignOf<UnityEngine.UIElements.Vertex>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_AlignOf_TisVertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7_mE6A898CD608ED8377F478E96B64D7E4C5ABF15D1_gshared (const RuntimeMethod* method)
{
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = (( int32_t (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)il2cpp_codegen_subtract(L_0, L_1));
goto IL_000f;
}
IL_000f:
{
int32_t L_2 = V_0;
return L_2;
}
}
// System.Boolean Unity.Collections.LowLevel.Unsafe.UnsafeUtility::EnumEquals<System.Int32Enum>(T,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UnsafeUtility_EnumEquals_TisInt32Enum_tCBAC8BA2BFF3A845FA599F303093BBBA374B6F0C_m47586ED10DC892FAAC599C0DC5A3E8CF3EBCA31A_gshared (int32_t ___lhs0, int32_t ___rhs1, const RuntimeMethod* method)
{
{
int32_t L_0 = ___lhs0;
int32_t L_1 = ___rhs1;
return (bool)((((int64_t)((int64_t)L_0)) == ((int64_t)((int64_t)L_1)))? 1 : 0);
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::EnumToInt<System.Int32Enum>(T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_EnumToInt_TisInt32Enum_tCBAC8BA2BFF3A845FA599F303093BBBA374B6F0C_m7FC8FD5E40D6A1FAA8F6E3BBD8237C3D8877A6E6_gshared (int32_t ___enumValue0, const RuntimeMethod* method)
{
int32_t V_0 = 0;
int32_t V_1 = 0;
{
V_0 = 0;
(( void (*) (int32_t*, int32_t*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))((&___enumValue0), (&V_0), il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_0 = V_0;
V_1 = L_0;
goto IL_0011;
}
IL_0011:
{
int32_t L_1 = V_1;
return L_1;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::InternalEnumToInt<System.Int32Enum>(T&,System.Int32&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_InternalEnumToInt_TisInt32Enum_tCBAC8BA2BFF3A845FA599F303093BBBA374B6F0C_m221CD8D61148E4A9CE89F54D9C15538EAAC0073A_gshared (int32_t* ___enumValue0, int32_t* ___intValue1, const RuntimeMethod* method)
{
{
int32_t* L_0 = ___intValue1;
int32_t* L_1 = ___enumValue0;
int32_t L_2 = *((int32_t*)L_1);
*((int32_t*)L_0) = (int32_t)L_2;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::InternalEnumToInt<System.Object>(T&,System.Int32&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_InternalEnumToInt_TisRuntimeObject_mEF15526464EE65366356E21094F2C1EDB07C68F9_gshared (RuntimeObject** ___enumValue0, int32_t* ___intValue1, const RuntimeMethod* method)
{
{
int32_t* L_0 = ___intValue1;
RuntimeObject** L_1 = ___enumValue0;
int32_t L_2 = *((int32_t*)L_1);
*((int32_t*)L_0) = (int32_t)L_2;
return;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<UnityEngine.Rendering.BatchVisibility>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR BatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA UnsafeUtility_ReadArrayElement_TisBatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA_mD1B12BC135C7549B65C863F3F39D1A3A050E236E_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(BatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA);
BatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA L_3 = (*(BatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<System.Byte>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint8_t UnsafeUtility_ReadArrayElement_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_m62EF4DB483402313C34FBC027E1B1C6244BCB099_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(uint8_t);
uint8_t L_3 = (*(uint8_t*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<UnityEngine.Color>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Color_tD001788D726C3A7F1379BEED0260B9591F440C1F UnsafeUtility_ReadArrayElement_TisColor_tD001788D726C3A7F1379BEED0260B9591F440C1F_mDC26C51F9AC768B4131DB6E17E6F8B1BB35DA2A3_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(Color_tD001788D726C3A7F1379BEED0260B9591F440C1F);
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F L_3 = (*(Color_tD001788D726C3A7F1379BEED0260B9591F440C1F*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<UnityEngine.Color32>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B UnsafeUtility_ReadArrayElement_TisColor32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B_mDF7C1B760DD64FE2816BC34336FEFFB95348A063_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B);
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B L_3 = (*(Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<UnityEngine.UIElements.UIR.DrawBufferRange>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4 UnsafeUtility_ReadArrayElement_TisDrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4_mDB924F358D7DB3EF03D603E110F56A04C7224445_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4);
DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4 L_3 = (*(DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<UnityEngine.UIElements.UIR.GfxUpdateBufferRange>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97 UnsafeUtility_ReadArrayElement_TisGfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97_m267840F6133028A01BCBFB1F6C54F7411C1A5901_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97);
GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97 L_3 = (*(GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<System.Int32>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_ReadArrayElement_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_mDC519E0F8059BBB99CB137FDA901BC6C0761A40A_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(int32_t);
int32_t L_3 = (*(int32_t*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<Unity.Jobs.JobHandle>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08 UnsafeUtility_ReadArrayElement_TisJobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08_m174C9E551299EB97010F7F1D5B3FCD3F2B07C59C_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08);
JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08 L_3 = (*(JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<UnityEngine.Experimental.GlobalIllumination.LightDataGI>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR LightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21 UnsafeUtility_ReadArrayElement_TisLightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21_mA3A295126D79E3C78AE62430341208E962A9FD17_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(LightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21);
LightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21 L_3 = (*(LightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<UnityEngine.ModifiableContactPair>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960 UnsafeUtility_ReadArrayElement_TisModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960_mB7D854609AF2F2527E776AA2A68959A06F818ED9_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(ModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960);
ModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960 L_3 = (*(ModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<System.Object>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* UnsafeUtility_ReadArrayElement_TisRuntimeObject_m3934FD1CF24F2FA559FF1E1B68977A7BDE16ADF8_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(RuntimeObject*);
RuntimeObject* L_3 = (*(RuntimeObject**)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<UnityEngine.Plane>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Plane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C UnsafeUtility_ReadArrayElement_TisPlane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C_mC24229ADE94CB475E66818897BF1FD1618C547CA_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(Plane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C);
Plane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C L_3 = (*(Plane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<UnityEngine.UIElements.TextVertex>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR TextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3 UnsafeUtility_ReadArrayElement_TisTextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3_mF4AEFBD4A2D37C7AEE65B42C4BA1664FE143A7A6_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(TextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3);
TextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3 L_3 = (*(TextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<UnityEngine.UIElements.UIR.Transform3x4>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F UnsafeUtility_ReadArrayElement_TisTransform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F_m13666808DCDAF77AF9A6049D56559DB3299E1467_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F);
Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F L_3 = (*(Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<System.UInt16>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t UnsafeUtility_ReadArrayElement_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_mECAA1FA8E0ADE1FAC171FED4C0C34F602D490FAF_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(uint16_t);
uint16_t L_3 = (*(uint16_t*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<UnityEngine.Vector4>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 UnsafeUtility_ReadArrayElement_TisVector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3_m6B78BA932DFCFC6F730CDD84DCBD8C431C0235D9_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3);
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 L_3 = (*(Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElement<UnityEngine.UIElements.Vertex>(System.Void*,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7 UnsafeUtility_ReadArrayElement_TisVertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7_m797B4A73798C16D0ADC717E02D81677936A9729F_gshared (void* ___source0, int32_t ___index1, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7);
Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7 L_3 = (*(Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElementWithStride<UnityEngine.UIElements.UIR.DrawBufferRange>(System.Void*,System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4 UnsafeUtility_ReadArrayElementWithStride_TisDrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4_mD37227A0516A42D0C3216EEE777222CA612D474F_gshared (void* ___source0, int32_t ___index1, int32_t ___stride2, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4 L_3 = (*(DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElementWithStride<UnityEngine.UIElements.UIR.GfxUpdateBufferRange>(System.Void*,System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97 UnsafeUtility_ReadArrayElementWithStride_TisGfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97_mF9EF728A14AA91707191753D405A2AE17094355D_gshared (void* ___source0, int32_t ___index1, int32_t ___stride2, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97 L_3 = (*(GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElementWithStride<Unity.Jobs.JobHandle>(System.Void*,System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08 UnsafeUtility_ReadArrayElementWithStride_TisJobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08_m0D0EB04B9B7564FFA53E72020FF2A42E0EF2BD2F_gshared (void* ___source0, int32_t ___index1, int32_t ___stride2, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08 L_3 = (*(JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElementWithStride<System.Object>(System.Void*,System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* UnsafeUtility_ReadArrayElementWithStride_TisRuntimeObject_mD8B01EC113910AB764688B9F81AD0C898A2C8908_gshared (void* ___source0, int32_t ___index1, int32_t ___stride2, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
RuntimeObject* L_3 = (*(RuntimeObject**)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElementWithStride<UnityEngine.UIElements.UIR.Transform3x4>(System.Void*,System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F UnsafeUtility_ReadArrayElementWithStride_TisTransform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F_m725198ADB8F0E6D32FA2F372EEE39BCE319CAD43_gshared (void* ___source0, int32_t ___index1, int32_t ___stride2, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F L_3 = (*(Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElementWithStride<System.UInt16>(System.Void*,System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR uint16_t UnsafeUtility_ReadArrayElementWithStride_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_m5C0F4DF1ECF6ADCFCFCFF935728CE8E088360DF3_gshared (void* ___source0, int32_t ___index1, int32_t ___stride2, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
uint16_t L_3 = (*(uint16_t*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElementWithStride<UnityEngine.Vector4>(System.Void*,System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 UnsafeUtility_ReadArrayElementWithStride_TisVector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3_mF7F2E0658EEDE1281394A07408CFF382F751D696_gshared (void* ___source0, int32_t ___index1, int32_t ___stride2, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 L_3 = (*(Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))));
return L_3;
}
}
// T Unity.Collections.LowLevel.Unsafe.UnsafeUtility::ReadArrayElementWithStride<UnityEngine.UIElements.Vertex>(System.Void*,System.Int32,System.Int32)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7 UnsafeUtility_ReadArrayElementWithStride_TisVertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7_m68DCD72EC1A2AEDB60DE163A20FCA764F95CCBCB_gshared (void* ___source0, int32_t ___index1, int32_t ___stride2, const RuntimeMethod* method)
{
{
void* L_0 = ___source0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7 L_3 = (*(Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))));
return L_3;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.Rendering.BatchVisibility>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_t06B2AF48C49769AAD65F5E3F53EA9C54BFB10F00_m798060D503E2DC4F2622E157417CCD5D6D68AB63_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_t06B2AF48C49769AAD65F5E3F53EA9C54BFB10F00);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<System.Byte>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_t31AECFF735259A0FDFB7AA894944339927FD14A2_m1BB2068B4AF7E9272F5D17E175EC6F20E851CDB9_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_t31AECFF735259A0FDFB7AA894944339927FD14A2);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.Color>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_tDD05A3FC824A309846DFDD7539C19F11BB681485_m47999D9797BEC5CD8420C0BC7167D76676DDA1D5_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_tDD05A3FC824A309846DFDD7539C19F11BB681485);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.Color32>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_t26A3226821AB86486949E2EEA83A5BE120465E3D_m071C0EF72DD39E1C0D60D778848F2E5ADDDB1299_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_t26A3226821AB86486949E2EEA83A5BE120465E3D);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.UIElements.UIR.DrawBufferRange>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_t3F15C977CB75F6273144B3EB4A070152979E3542_m4820FBE202DF36BA42E2902D4050190D2E27EBAF_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_t3F15C977CB75F6273144B3EB4A070152979E3542);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.UIElements.UIR.GfxUpdateBufferRange>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_tD52B3A8A6905ECEC0B9C3B4D1828784E75D7FE88_mD04B0E3220BDBA74C420BE71390F092CB260C735_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_tD52B3A8A6905ECEC0B9C3B4D1828784E75D7FE88);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<System.Int32>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_tDEDE36731BCA4BBF0A258F5E9A0155E556B11BB3_m0CECBD6EB03094967518FB804572141A860AB730_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_tDEDE36731BCA4BBF0A258F5E9A0155E556B11BB3);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<Unity.Jobs.JobHandle>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_t34F1F7B1C240980BD9A2FE1C6A698A61423A9012_m21E380BD0A066F709491E0FFAE28FDC70C4BD28F_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_t34F1F7B1C240980BD9A2FE1C6A698A61423A9012);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.Experimental.GlobalIllumination.LightDataGI>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_tC14085A002766BE215E2A570FCDA1F263125AA18_m192EEC588293DB3AA11A93E7B0179B5BEEE64139_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_tC14085A002766BE215E2A570FCDA1F263125AA18);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.ModifiableContactPair>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_tD67A48EC63F59A3B0822645B10F6057BB0B1A6FB_m3A1405E2A4345B3451B054746F52852B3E2B1138_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_tD67A48EC63F59A3B0822645B10F6057BB0B1A6FB);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.Plane>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_t0A0F0444D297D1B268776F65B34B921CC7440328_mF937C2C12D474F7AE7CFB6AC652CC690A28DFDC0_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_t0A0F0444D297D1B268776F65B34B921CC7440328);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.UIElements.TextVertex>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_tD213CBFA28C6ED84BFB52825C5EDC3D52ADE5B18_m9692592649D61902F7F810F63B58F11E3D5BA4F7_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_tD213CBFA28C6ED84BFB52825C5EDC3D52ADE5B18);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.UIElements.UIR.Transform3x4>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_t6867F50FD3853DD4CA4DD96AD88FE1A614E678D2_mAFAED8BA8276D52FAA0A257E0307C10AB3B94252_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_t6867F50FD3853DD4CA4DD96AD88FE1A614E678D2);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<System.UInt16>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_t82117C0F9F1FB124A9CEB4215A5BB62387D6E5D2_m41E8DDFDA28E48F303CF30D12AA5EFBD966CEB3F_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_t82117C0F9F1FB124A9CEB4215A5BB62387D6E5D2);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.Vector4>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_t715DBF373F018E47F9BAD31EF00130648BA568B2_m400B5017B785526C64A53B92FD747CF00911D846_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_t715DBF373F018E47F9BAD31EF00130648BA568B2);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Collections.LowLevel.Unsafe.UnsafeUtility/AlignOfHelper`1<UnityEngine.UIElements.Vertex>>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisAlignOfHelper_1_t7A2C4AA30B2C9EC8415A83A5A9B280DBF11AB9AF_mE3249013083EE8416FBE752CBA6392BAAB76B0F1_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(AlignOfHelper_1_t7A2C4AA30B2C9EC8415A83A5A9B280DBF11AB9AF);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<UnityEngine.Rendering.BatchVisibility>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisBatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA_m0C2D5AEA2098B5AA4CD35E98F4534C6CAFB7FAF4_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(BatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<System.Byte>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_m5439440481B764D17A028D20239A1223C256B2EC_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(uint8_t);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<UnityEngine.Color>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisColor_tD001788D726C3A7F1379BEED0260B9591F440C1F_m368B07FF7DA8576002862EC3A4BE7FDCCA5B660A_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(Color_tD001788D726C3A7F1379BEED0260B9591F440C1F);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<UnityEngine.Color32>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisColor32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B_m5281DD33141D340D84276B8F49EBD43E6D656E47_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<UnityEngine.UIElements.UIR.DrawBufferRange>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisDrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4_m823422A9041E022CC73656F03B20C464D8664663_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<UnityEngine.UIElements.UIR.GfxUpdateBufferRange>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisGfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97_mA641A5D74C608735D83A9D39CE103B8D5E76B179_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<System.Int32>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_m5AC9EB77585D6151D2321C1F1671E99E6505C29E_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(int32_t);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<Unity.Jobs.JobHandle>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisJobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08_m5859A51ACC192DF0F860117B3E26D3B9838054E3_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<UnityEngine.Experimental.GlobalIllumination.LightDataGI>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisLightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21_m412B236A366F36076AAA5807D2CCF0966CC2C99A_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(LightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<UnityEngine.ModifiableContactPair>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960_mE1C4ACDD183C7EAE81B93ADD8002852EEEF456E8_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(ModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<UnityEngine.Plane>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisPlane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C_mFC0D85A137C4D75407268FE6D616C339A35CFA26_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(Plane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<UnityEngine.UIElements.TextVertex>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisTextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3_m039A24F9D07F9513076C3F4D0A4F3DB8F14E720F_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(TextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<UnityEngine.UIElements.UIR.Transform3x4>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisTransform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F_mB4B188E6F7178686EDE48F52550903F5C8631602_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<System.UInt16>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_mAF63E97D2056B84CDCB6966AD5A4C67B91117D0A_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(uint16_t);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<UnityEngine.Vector4>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisVector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3_m4FF28C686A0979A117552001662758B3B640956C_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3);
return (int32_t)L_0;
}
}
// System.Int32 Unity.Collections.LowLevel.Unsafe.UnsafeUtility::SizeOf<UnityEngine.UIElements.Vertex>()
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UnsafeUtility_SizeOf_TisVertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7_mB2D55F04C69E061E61E22051029DC802E5B79ADB_gshared (const RuntimeMethod* method)
{
{
uint32_t L_0 = sizeof(Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7);
return (int32_t)L_0;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<UnityEngine.Rendering.BatchVisibility>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisBatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA_m5870A4ABF63FAAF17B94871B8574D5F76FF88653_gshared (void* ___destination0, int32_t ___index1, BatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(BatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA);
BatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA L_3 = ___value2;
*(BatchVisibility_t0AC94FB0AE271C762F911D4602604F4D83837CEA*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<System.Byte>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisByte_t94D9231AC217BE4D2E004C4CD32DF6D099EA41A3_m83A5B89E51882C47758A100BB36F8EDF3CCE5AEC_gshared (void* ___destination0, int32_t ___index1, uint8_t ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(uint8_t);
uint8_t L_3 = ___value2;
*(uint8_t*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<UnityEngine.Color>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisColor_tD001788D726C3A7F1379BEED0260B9591F440C1F_m7AF321BAF3926C49F00C0D9D91B7E8FCA88A5039_gshared (void* ___destination0, int32_t ___index1, Color_tD001788D726C3A7F1379BEED0260B9591F440C1F ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(Color_tD001788D726C3A7F1379BEED0260B9591F440C1F);
Color_tD001788D726C3A7F1379BEED0260B9591F440C1F L_3 = ___value2;
*(Color_tD001788D726C3A7F1379BEED0260B9591F440C1F*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<UnityEngine.Color32>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisColor32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B_m63D3D4D5843EE58FCE9BE95940AF8417E36FD805_gshared (void* ___destination0, int32_t ___index1, Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B);
Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B L_3 = ___value2;
*(Color32_t73C5004937BF5BB8AD55323D51AAA40A898EF48B*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<UnityEngine.UIElements.UIR.DrawBufferRange>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisDrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4_mABEB5621368C9B3825632B329FF886E0E1B67132_gshared (void* ___destination0, int32_t ___index1, DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4 ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4);
DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4 L_3 = ___value2;
*(DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<UnityEngine.UIElements.UIR.GfxUpdateBufferRange>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisGfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97_mF2A6A54C0460B3364A9E78051B09707585233816_gshared (void* ___destination0, int32_t ___index1, GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97 ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97);
GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97 L_3 = ___value2;
*(GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<System.Int32>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_m22615F03667154E3694602654C53574FE60392F0_gshared (void* ___destination0, int32_t ___index1, int32_t ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(int32_t);
int32_t L_3 = ___value2;
*(int32_t*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<Unity.Jobs.JobHandle>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisJobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08_m136E3C11D3BEE9FA18C6084460D072E301015B40_gshared (void* ___destination0, int32_t ___index1, JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08 ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08);
JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08 L_3 = ___value2;
*(JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<UnityEngine.Experimental.GlobalIllumination.LightDataGI>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisLightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21_m7EB32F2E11CA2A9695D57784B491E35AAC1852DC_gshared (void* ___destination0, int32_t ___index1, LightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21 ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(LightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21);
LightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21 L_3 = ___value2;
*(LightDataGI_t47D2197E863C0DDA40C2182FBF0A21367E468E21*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<UnityEngine.ModifiableContactPair>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960_mA5D150AE9D8517CE2B2A1D30AC04791346C80F3E_gshared (void* ___destination0, int32_t ___index1, ModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960 ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(ModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960);
ModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960 L_3 = ___value2;
*(ModifiableContactPair_t8D3CA3E20AF1718A5421A6098D633DDA67399960*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<System.Object>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisRuntimeObject_mA073C31C52093C52E7EB7237E67D392CE60C1F54_gshared (void* ___destination0, int32_t ___index1, RuntimeObject* ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(RuntimeObject*);
RuntimeObject* L_3 = ___value2;
*(RuntimeObject**)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
Il2CppCodeGenWriteBarrier((void**)(RuntimeObject**)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))), (void*)L_3);
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<UnityEngine.Plane>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisPlane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C_m153D282970D4A00F77734E7C974CC052E4BC9889_gshared (void* ___destination0, int32_t ___index1, Plane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(Plane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C);
Plane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C L_3 = ___value2;
*(Plane_tB7D8CC6F7AACF5F3AA483AF005C1102A8577BC0C*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<UnityEngine.UIElements.TextVertex>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisTextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3_mE483B1BA5BFD1927125A6CE739DCC600CA8D20B4_gshared (void* ___destination0, int32_t ___index1, TextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3 ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(TextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3);
TextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3 L_3 = ___value2;
*(TextVertex_tF56662BA585F7DD34D71971F1AA1D2E767946CF3*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<UnityEngine.UIElements.UIR.Transform3x4>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisTransform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F_m004FD5D76BC4612A674AC05AC0E6711FDE9E4A32_gshared (void* ___destination0, int32_t ___index1, Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F);
Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F L_3 = ___value2;
*(Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<System.UInt16>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_m4A749B0D3DF862541754B5A86EF3042CA55ED482_gshared (void* ___destination0, int32_t ___index1, uint16_t ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(uint16_t);
uint16_t L_3 = ___value2;
*(uint16_t*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<UnityEngine.Vector4>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisVector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3_mBB0C6AAC5624AA408D248E660CC73180A37FB7C9_gshared (void* ___destination0, int32_t ___index1, Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3);
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 L_3 = ___value2;
*(Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElement<UnityEngine.UIElements.Vertex>(System.Void*,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElement_TisVertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7_m67DCD86AAA57B9F85E92147A41519345EFF7A9E9_gshared (void* ___destination0, int32_t ___index1, Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7 ___value2, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
uint32_t L_2 = sizeof(Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7);
Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7 L_3 = ___value2;
*(Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)((int32_t)L_2))))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElementWithStride<UnityEngine.UIElements.UIR.DrawBufferRange>(System.Void*,System.Int32,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElementWithStride_TisDrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4_m57A6D4DA9E89F4BE2AE62B20539F5B01E2F192B7_gshared (void* ___destination0, int32_t ___index1, int32_t ___stride2, DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4 ___value3, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4 L_3 = ___value3;
*(DrawBufferRange_t684F255F5C954760B12F6689F84E78811040C7A4*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElementWithStride<UnityEngine.UIElements.UIR.GfxUpdateBufferRange>(System.Void*,System.Int32,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElementWithStride_TisGfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97_m874AAF984C29FAE26D0BC5D1D454B0ED3D1671BE_gshared (void* ___destination0, int32_t ___index1, int32_t ___stride2, GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97 ___value3, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97 L_3 = ___value3;
*(GfxUpdateBufferRange_tC47258BCB472B0727B4FCE21A2A53506644C1A97*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElementWithStride<Unity.Jobs.JobHandle>(System.Void*,System.Int32,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElementWithStride_TisJobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08_m069891E192B8255DA211F1110FE9C8425A8F6E77_gshared (void* ___destination0, int32_t ___index1, int32_t ___stride2, JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08 ___value3, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08 L_3 = ___value3;
*(JobHandle_t5DF5F99902FED3C801A81C05205CEA6CE039EF08*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElementWithStride<System.Object>(System.Void*,System.Int32,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElementWithStride_TisRuntimeObject_m9819A6D6AAB517F827CF85FB4DBA94FD99356E03_gshared (void* ___destination0, int32_t ___index1, int32_t ___stride2, RuntimeObject* ___value3, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
RuntimeObject* L_3 = ___value3;
*(RuntimeObject**)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))) = L_3;
Il2CppCodeGenWriteBarrier((void**)(RuntimeObject**)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))), (void*)L_3);
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElementWithStride<UnityEngine.UIElements.UIR.Transform3x4>(System.Void*,System.Int32,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElementWithStride_TisTransform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F_m939F8C0DDD24A1BF75F3A16D965BF85F8ECD71FB_gshared (void* ___destination0, int32_t ___index1, int32_t ___stride2, Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F ___value3, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F L_3 = ___value3;
*(Transform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElementWithStride<System.UInt16>(System.Void*,System.Int32,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElementWithStride_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_mB2E58173A605B68E5FFE120A53D3D7ADD725EF65_gshared (void* ___destination0, int32_t ___index1, int32_t ___stride2, uint16_t ___value3, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
uint16_t L_3 = ___value3;
*(uint16_t*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElementWithStride<UnityEngine.Vector4>(System.Void*,System.Int32,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElementWithStride_TisVector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3_m8F8173BE4670FCEB2DF75193E14CD02C22537A4D_gshared (void* ___destination0, int32_t ___index1, int32_t ___stride2, Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 ___value3, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3 L_3 = ___value3;
*(Vector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))) = L_3;
return;
}
}
// System.Void Unity.Collections.LowLevel.Unsafe.UnsafeUtility::WriteArrayElementWithStride<UnityEngine.UIElements.Vertex>(System.Void*,System.Int32,System.Int32,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void UnsafeUtility_WriteArrayElementWithStride_TisVertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7_m85504862E9E760C7030D5F880DF7AA5F447DA9A4_gshared (void* ___destination0, int32_t ___index1, int32_t ___stride2, Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7 ___value3, const RuntimeMethod* method)
{
{
void* L_0 = ___destination0;
int32_t L_1 = ___index1;
int32_t L_2 = ___stride2;
Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7 L_3 = ___value3;
*(Vertex_t016AC68A2E6C62576E65412BEC71544AFC01AFC7*)((void*)il2cpp_codegen_add((intptr_t)L_0, ((intptr_t)((int64_t)il2cpp_codegen_multiply(((int64_t)L_1), ((int64_t)L_2)))))) = L_3;
return;
}
}
// System.Void UnityEngine.UIElements.UIR.Utility::SetVectorArray<UnityEngine.UIElements.UIR.Transform3x4>(UnityEngine.MaterialPropertyBlock,System.Int32,Unity.Collections.NativeSlice`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Utility_SetVectorArray_TisTransform3x4_t9F79FC0112A00D3FFD7AFAD2D10AD22DF929052F_m67EE8F8BE9677CD0DE886FCB4EAE7DD82CBFD561_gshared (MaterialPropertyBlock_t2308669579033A857EFE6E4831909F638B27411D* ___props0, int32_t ___name1, NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370 ___vector4s2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Utility_t8BCC393462C6270211734BE47CF5350F05EC97AD_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = NativeSlice_1_get_Length_mC069C9254C3F61C678293E03E3E7C51F245F52E9_inline((&___vector4s2), il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = NativeSlice_1_get_Stride_mE29B800705645CDD49B576BB3B9B328811F27C90_inline((&___vector4s2), il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)(((int32_t)il2cpp_codegen_multiply(L_0, L_1))/((int32_t)16)));
MaterialPropertyBlock_t2308669579033A857EFE6E4831909F638B27411D* L_2 = ___props0;
int32_t L_3 = ___name1;
NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370 L_4 = ___vector4s2;
void* L_5;
L_5 = (( void* (*) (NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(L_4, il2cpp_rgctx_method(method->rgctx_data, 2));
intptr_t L_6;
memset((&L_6), 0, sizeof(L_6));
IntPtr__ctor_m4F9A9B80F01996B610D5AE4797F20B98ECD0A3D9_inline((&L_6), L_5, /*hidden argument*/NULL);
int32_t L_7 = V_0;
il2cpp_codegen_runtime_class_init_inline(Utility_t8BCC393462C6270211734BE47CF5350F05EC97AD_il2cpp_TypeInfo_var);
Utility_SetVectorArray_m6C8F08342C9D3D33A183B29536DA13B07E2763FA(L_2, L_3, L_6, L_7, NULL);
return;
}
}
// System.Void UnityEngine.UIElements.UIR.Utility::SetVectorArray<UnityEngine.Vector4>(UnityEngine.MaterialPropertyBlock,System.Int32,Unity.Collections.NativeSlice`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Utility_SetVectorArray_TisVector4_t58B63D32F48C0DBF50DE2C60794C4676C80EDBE3_m6B7249321B3E0FA74B668FDAB3DCB055ABE7E750_gshared (MaterialPropertyBlock_t2308669579033A857EFE6E4831909F638B27411D* ___props0, int32_t ___name1, NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F ___vector4s2, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&Utility_t8BCC393462C6270211734BE47CF5350F05EC97AD_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
int32_t V_0 = 0;
{
int32_t L_0;
L_0 = NativeSlice_1_get_Length_mED822A5A5476BEBA72E429C395644A7B41F78F50_inline((&___vector4s2), il2cpp_rgctx_method(method->rgctx_data, 0));
int32_t L_1;
L_1 = NativeSlice_1_get_Stride_m2BC6AD2264EE2D02A38D29E30D382DEA9B5A9E29_inline((&___vector4s2), il2cpp_rgctx_method(method->rgctx_data, 1));
V_0 = ((int32_t)(((int32_t)il2cpp_codegen_multiply(L_0, L_1))/((int32_t)16)));
MaterialPropertyBlock_t2308669579033A857EFE6E4831909F638B27411D* L_2 = ___props0;
int32_t L_3 = ___name1;
NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F L_4 = ___vector4s2;
void* L_5;
L_5 = (( void* (*) (NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(L_4, il2cpp_rgctx_method(method->rgctx_data, 2));
intptr_t L_6;
memset((&L_6), 0, sizeof(L_6));
IntPtr__ctor_m4F9A9B80F01996B610D5AE4797F20B98ECD0A3D9_inline((&L_6), L_5, /*hidden argument*/NULL);
int32_t L_7 = V_0;
il2cpp_codegen_runtime_class_init_inline(Utility_t8BCC393462C6270211734BE47CF5350F05EC97AD_il2cpp_TypeInfo_var);
Utility_SetVectorArray_m6C8F08342C9D3D33A183B29536DA13B07E2763FA(L_2, L_3, L_6, L_7, NULL);
return;
}
}
// T UnityEngine.UIElements.UxmlAttributeDescription::GetValueFromBag<System.Boolean>(UnityEngine.UIElements.IUxmlAttributes,UnityEngine.UIElements.CreationContext,System.Func`3<System.String,T,T>,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UxmlAttributeDescription_GetValueFromBag_TisBoolean_t09A6377A54BE2F9E6985A8149F19234FD7DDFE22_m22751CE4DF8B8DDEFEBE8E79FDBB271B3B7AF62D_gshared (UxmlAttributeDescription_t742D021489DB2B564142146CAAAC3F9191825EF2* __this, RuntimeObject* ___bag0, CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 ___cc1, Func_3_t62BC9D925DCAC8F5784BA97C793F4E593496CDA7* ___converterFunc2, bool ___defaultValue3, const RuntimeMethod* method)
{
String_t* V_0 = NULL;
bool V_1 = false;
bool V_2 = false;
bool V_3 = false;
{
Func_3_t62BC9D925DCAC8F5784BA97C793F4E593496CDA7* L_0 = ___converterFunc2;
V_1 = (bool)((((RuntimeObject*)(Func_3_t62BC9D925DCAC8F5784BA97C793F4E593496CDA7*)L_0) == ((RuntimeObject*)(RuntimeObject*)NULL))? 1 : 0);
bool L_1 = V_1;
if (!L_1)
{
goto IL_0015;
}
}
{
ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129* L_2 = (ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129*)il2cpp_codegen_object_new(((RuntimeClass*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129_il2cpp_TypeInfo_var)));
ArgumentNullException__ctor_m444AE141157E333844FC1A9500224C2F9FD24F4B(L_2, ((String_t*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&_stringLiteralBF44A05DB008A507A463F2A13F1907FEB2E4B19F)), NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&UxmlAttributeDescription_GetValueFromBag_TisBoolean_t09A6377A54BE2F9E6985A8149F19234FD7DDFE22_m22751CE4DF8B8DDEFEBE8E79FDBB271B3B7AF62D_RuntimeMethod_var)));
}
IL_0015:
{
RuntimeObject* L_3 = ___bag0;
CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 L_4 = ___cc1;
bool L_5;
L_5 = UxmlAttributeDescription_TryGetValueFromBagAsString_mF08874E8E58AD04C20041C076E2447E9AF57C9ED(__this, L_3, L_4, (&V_0), NULL);
V_2 = L_5;
bool L_6 = V_2;
if (!L_6)
{
goto IL_0030;
}
}
{
Func_3_t62BC9D925DCAC8F5784BA97C793F4E593496CDA7* L_7 = ___converterFunc2;
String_t* L_8 = V_0;
bool L_9 = ___defaultValue3;
bool L_10;
L_10 = (( bool (*) (Func_3_t62BC9D925DCAC8F5784BA97C793F4E593496CDA7*, String_t*, bool, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_7, L_8, L_9, il2cpp_rgctx_method(method->rgctx_data, 1));
V_3 = L_10;
goto IL_0035;
}
IL_0030:
{
bool L_11 = ___defaultValue3;
V_3 = L_11;
goto IL_0035;
}
IL_0035:
{
bool L_12 = V_3;
return L_12;
}
}
// T UnityEngine.UIElements.UxmlAttributeDescription::GetValueFromBag<System.Int32>(UnityEngine.UIElements.IUxmlAttributes,UnityEngine.UIElements.CreationContext,System.Func`3<System.String,T,T>,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UxmlAttributeDescription_GetValueFromBag_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_mE6407D384CA016BA1904AE558D480299827A91F0_gshared (UxmlAttributeDescription_t742D021489DB2B564142146CAAAC3F9191825EF2* __this, RuntimeObject* ___bag0, CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 ___cc1, Func_3_t0620ECF6AB73866242850ABCE518B069D201DA79* ___converterFunc2, int32_t ___defaultValue3, const RuntimeMethod* method)
{
String_t* V_0 = NULL;
bool V_1 = false;
bool V_2 = false;
int32_t V_3 = 0;
{
Func_3_t0620ECF6AB73866242850ABCE518B069D201DA79* L_0 = ___converterFunc2;
V_1 = (bool)((((RuntimeObject*)(Func_3_t0620ECF6AB73866242850ABCE518B069D201DA79*)L_0) == ((RuntimeObject*)(RuntimeObject*)NULL))? 1 : 0);
bool L_1 = V_1;
if (!L_1)
{
goto IL_0015;
}
}
{
ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129* L_2 = (ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129*)il2cpp_codegen_object_new(((RuntimeClass*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129_il2cpp_TypeInfo_var)));
ArgumentNullException__ctor_m444AE141157E333844FC1A9500224C2F9FD24F4B(L_2, ((String_t*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&_stringLiteralBF44A05DB008A507A463F2A13F1907FEB2E4B19F)), NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&UxmlAttributeDescription_GetValueFromBag_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_mE6407D384CA016BA1904AE558D480299827A91F0_RuntimeMethod_var)));
}
IL_0015:
{
RuntimeObject* L_3 = ___bag0;
CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 L_4 = ___cc1;
bool L_5;
L_5 = UxmlAttributeDescription_TryGetValueFromBagAsString_mF08874E8E58AD04C20041C076E2447E9AF57C9ED(__this, L_3, L_4, (&V_0), NULL);
V_2 = L_5;
bool L_6 = V_2;
if (!L_6)
{
goto IL_0030;
}
}
{
Func_3_t0620ECF6AB73866242850ABCE518B069D201DA79* L_7 = ___converterFunc2;
String_t* L_8 = V_0;
int32_t L_9 = ___defaultValue3;
int32_t L_10;
L_10 = (( int32_t (*) (Func_3_t0620ECF6AB73866242850ABCE518B069D201DA79*, String_t*, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_7, L_8, L_9, il2cpp_rgctx_method(method->rgctx_data, 1));
V_3 = L_10;
goto IL_0035;
}
IL_0030:
{
int32_t L_11 = ___defaultValue3;
V_3 = L_11;
goto IL_0035;
}
IL_0035:
{
int32_t L_12 = V_3;
return L_12;
}
}
// T UnityEngine.UIElements.UxmlAttributeDescription::GetValueFromBag<System.Int32Enum>(UnityEngine.UIElements.IUxmlAttributes,UnityEngine.UIElements.CreationContext,System.Func`3<System.String,T,T>,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int32_t UxmlAttributeDescription_GetValueFromBag_TisInt32Enum_tCBAC8BA2BFF3A845FA599F303093BBBA374B6F0C_mB8752E3FCFBE10C58F06DF6F6275C822C4850645_gshared (UxmlAttributeDescription_t742D021489DB2B564142146CAAAC3F9191825EF2* __this, RuntimeObject* ___bag0, CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 ___cc1, Func_3_t538A8E697534A282316BC2DF71DE83E68360C8B9* ___converterFunc2, int32_t ___defaultValue3, const RuntimeMethod* method)
{
String_t* V_0 = NULL;
bool V_1 = false;
bool V_2 = false;
int32_t V_3 = 0;
{
Func_3_t538A8E697534A282316BC2DF71DE83E68360C8B9* L_0 = ___converterFunc2;
V_1 = (bool)((((RuntimeObject*)(Func_3_t538A8E697534A282316BC2DF71DE83E68360C8B9*)L_0) == ((RuntimeObject*)(RuntimeObject*)NULL))? 1 : 0);
bool L_1 = V_1;
if (!L_1)
{
goto IL_0015;
}
}
{
ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129* L_2 = (ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129*)il2cpp_codegen_object_new(((RuntimeClass*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129_il2cpp_TypeInfo_var)));
ArgumentNullException__ctor_m444AE141157E333844FC1A9500224C2F9FD24F4B(L_2, ((String_t*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&_stringLiteralBF44A05DB008A507A463F2A13F1907FEB2E4B19F)), NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&UxmlAttributeDescription_GetValueFromBag_TisInt32Enum_tCBAC8BA2BFF3A845FA599F303093BBBA374B6F0C_mB8752E3FCFBE10C58F06DF6F6275C822C4850645_RuntimeMethod_var)));
}
IL_0015:
{
RuntimeObject* L_3 = ___bag0;
CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 L_4 = ___cc1;
bool L_5;
L_5 = UxmlAttributeDescription_TryGetValueFromBagAsString_mF08874E8E58AD04C20041C076E2447E9AF57C9ED(__this, L_3, L_4, (&V_0), NULL);
V_2 = L_5;
bool L_6 = V_2;
if (!L_6)
{
goto IL_0030;
}
}
{
Func_3_t538A8E697534A282316BC2DF71DE83E68360C8B9* L_7 = ___converterFunc2;
String_t* L_8 = V_0;
int32_t L_9 = ___defaultValue3;
int32_t L_10;
L_10 = (( int32_t (*) (Func_3_t538A8E697534A282316BC2DF71DE83E68360C8B9*, String_t*, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_7, L_8, L_9, il2cpp_rgctx_method(method->rgctx_data, 1));
V_3 = L_10;
goto IL_0035;
}
IL_0030:
{
int32_t L_11 = ___defaultValue3;
V_3 = L_11;
goto IL_0035;
}
IL_0035:
{
int32_t L_12 = V_3;
return L_12;
}
}
// T UnityEngine.UIElements.UxmlAttributeDescription::GetValueFromBag<System.Int64>(UnityEngine.UIElements.IUxmlAttributes,UnityEngine.UIElements.CreationContext,System.Func`3<System.String,T,T>,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR int64_t UxmlAttributeDescription_GetValueFromBag_TisInt64_t092CFB123BE63C28ACDAF65C68F21A526050DBA3_mD5D06E5828505FB5AC84B2EF9D0FDD2494C4ABA4_gshared (UxmlAttributeDescription_t742D021489DB2B564142146CAAAC3F9191825EF2* __this, RuntimeObject* ___bag0, CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 ___cc1, Func_3_tD3C5141B184A528ABF7649D429906DA08C68E4A7* ___converterFunc2, int64_t ___defaultValue3, const RuntimeMethod* method)
{
String_t* V_0 = NULL;
bool V_1 = false;
bool V_2 = false;
int64_t V_3 = 0;
{
Func_3_tD3C5141B184A528ABF7649D429906DA08C68E4A7* L_0 = ___converterFunc2;
V_1 = (bool)((((RuntimeObject*)(Func_3_tD3C5141B184A528ABF7649D429906DA08C68E4A7*)L_0) == ((RuntimeObject*)(RuntimeObject*)NULL))? 1 : 0);
bool L_1 = V_1;
if (!L_1)
{
goto IL_0015;
}
}
{
ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129* L_2 = (ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129*)il2cpp_codegen_object_new(((RuntimeClass*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129_il2cpp_TypeInfo_var)));
ArgumentNullException__ctor_m444AE141157E333844FC1A9500224C2F9FD24F4B(L_2, ((String_t*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&_stringLiteralBF44A05DB008A507A463F2A13F1907FEB2E4B19F)), NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&UxmlAttributeDescription_GetValueFromBag_TisInt64_t092CFB123BE63C28ACDAF65C68F21A526050DBA3_mD5D06E5828505FB5AC84B2EF9D0FDD2494C4ABA4_RuntimeMethod_var)));
}
IL_0015:
{
RuntimeObject* L_3 = ___bag0;
CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 L_4 = ___cc1;
bool L_5;
L_5 = UxmlAttributeDescription_TryGetValueFromBagAsString_mF08874E8E58AD04C20041C076E2447E9AF57C9ED(__this, L_3, L_4, (&V_0), NULL);
V_2 = L_5;
bool L_6 = V_2;
if (!L_6)
{
goto IL_0030;
}
}
{
Func_3_tD3C5141B184A528ABF7649D429906DA08C68E4A7* L_7 = ___converterFunc2;
String_t* L_8 = V_0;
int64_t L_9 = ___defaultValue3;
int64_t L_10;
L_10 = (( int64_t (*) (Func_3_tD3C5141B184A528ABF7649D429906DA08C68E4A7*, String_t*, int64_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_7, L_8, L_9, il2cpp_rgctx_method(method->rgctx_data, 1));
V_3 = L_10;
goto IL_0035;
}
IL_0030:
{
int64_t L_11 = ___defaultValue3;
V_3 = L_11;
goto IL_0035;
}
IL_0035:
{
int64_t L_12 = V_3;
return L_12;
}
}
// T UnityEngine.UIElements.UxmlAttributeDescription::GetValueFromBag<System.Object>(UnityEngine.UIElements.IUxmlAttributes,UnityEngine.UIElements.CreationContext,System.Func`3<System.String,T,T>,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* UxmlAttributeDescription_GetValueFromBag_TisRuntimeObject_m068CFD3292450E7E40FB2498A6ABDD4A0B7F9FDC_gshared (UxmlAttributeDescription_t742D021489DB2B564142146CAAAC3F9191825EF2* __this, RuntimeObject* ___bag0, CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 ___cc1, Func_3_tBFBF2C1D5A7EE5485A61C55BA580F7AF50AABBF0* ___converterFunc2, RuntimeObject* ___defaultValue3, const RuntimeMethod* method)
{
String_t* V_0 = NULL;
bool V_1 = false;
bool V_2 = false;
RuntimeObject* V_3 = NULL;
{
Func_3_tBFBF2C1D5A7EE5485A61C55BA580F7AF50AABBF0* L_0 = ___converterFunc2;
V_1 = (bool)((((RuntimeObject*)(Func_3_tBFBF2C1D5A7EE5485A61C55BA580F7AF50AABBF0*)L_0) == ((RuntimeObject*)(RuntimeObject*)NULL))? 1 : 0);
bool L_1 = V_1;
if (!L_1)
{
goto IL_0015;
}
}
{
ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129* L_2 = (ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129*)il2cpp_codegen_object_new(((RuntimeClass*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129_il2cpp_TypeInfo_var)));
ArgumentNullException__ctor_m444AE141157E333844FC1A9500224C2F9FD24F4B(L_2, ((String_t*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&_stringLiteralBF44A05DB008A507A463F2A13F1907FEB2E4B19F)), NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&UxmlAttributeDescription_GetValueFromBag_TisRuntimeObject_m068CFD3292450E7E40FB2498A6ABDD4A0B7F9FDC_RuntimeMethod_var)));
}
IL_0015:
{
RuntimeObject* L_3 = ___bag0;
CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 L_4 = ___cc1;
bool L_5;
L_5 = UxmlAttributeDescription_TryGetValueFromBagAsString_mF08874E8E58AD04C20041C076E2447E9AF57C9ED(__this, L_3, L_4, (&V_0), NULL);
V_2 = L_5;
bool L_6 = V_2;
if (!L_6)
{
goto IL_0030;
}
}
{
Func_3_tBFBF2C1D5A7EE5485A61C55BA580F7AF50AABBF0* L_7 = ___converterFunc2;
String_t* L_8 = V_0;
RuntimeObject* L_9 = ___defaultValue3;
RuntimeObject* L_10;
L_10 = (( RuntimeObject* (*) (Func_3_tBFBF2C1D5A7EE5485A61C55BA580F7AF50AABBF0*, String_t*, RuntimeObject*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_7, L_8, L_9, il2cpp_rgctx_method(method->rgctx_data, 1));
V_3 = L_10;
goto IL_0035;
}
IL_0030:
{
RuntimeObject* L_11 = ___defaultValue3;
V_3 = L_11;
goto IL_0035;
}
IL_0035:
{
RuntimeObject* L_12 = V_3;
return L_12;
}
}
// T UnityEngine.UIElements.UxmlAttributeDescription::GetValueFromBag<System.Single>(UnityEngine.UIElements.IUxmlAttributes,UnityEngine.UIElements.CreationContext,System.Func`3<System.String,T,T>,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR float UxmlAttributeDescription_GetValueFromBag_TisSingle_t4530F2FF86FCB0DC29F35385CA1BD21BE294761C_m3B483191ED592442A1ACF14EC0700E03ECDB4F8D_gshared (UxmlAttributeDescription_t742D021489DB2B564142146CAAAC3F9191825EF2* __this, RuntimeObject* ___bag0, CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 ___cc1, Func_3_t5328A430FC4208B44C52E4E89DC5F686DE6A6A1B* ___converterFunc2, float ___defaultValue3, const RuntimeMethod* method)
{
String_t* V_0 = NULL;
bool V_1 = false;
bool V_2 = false;
float V_3 = 0.0f;
{
Func_3_t5328A430FC4208B44C52E4E89DC5F686DE6A6A1B* L_0 = ___converterFunc2;
V_1 = (bool)((((RuntimeObject*)(Func_3_t5328A430FC4208B44C52E4E89DC5F686DE6A6A1B*)L_0) == ((RuntimeObject*)(RuntimeObject*)NULL))? 1 : 0);
bool L_1 = V_1;
if (!L_1)
{
goto IL_0015;
}
}
{
ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129* L_2 = (ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129*)il2cpp_codegen_object_new(((RuntimeClass*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&ArgumentNullException_t327031E412FAB2351B0022DD5DAD47E67E597129_il2cpp_TypeInfo_var)));
ArgumentNullException__ctor_m444AE141157E333844FC1A9500224C2F9FD24F4B(L_2, ((String_t*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&_stringLiteralBF44A05DB008A507A463F2A13F1907FEB2E4B19F)), NULL);
IL2CPP_RAISE_MANAGED_EXCEPTION(L_2, ((RuntimeMethod*)il2cpp_codegen_initialize_runtime_metadata_inline((uintptr_t*)&UxmlAttributeDescription_GetValueFromBag_TisSingle_t4530F2FF86FCB0DC29F35385CA1BD21BE294761C_m3B483191ED592442A1ACF14EC0700E03ECDB4F8D_RuntimeMethod_var)));
}
IL_0015:
{
RuntimeObject* L_3 = ___bag0;
CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 L_4 = ___cc1;
bool L_5;
L_5 = UxmlAttributeDescription_TryGetValueFromBagAsString_mF08874E8E58AD04C20041C076E2447E9AF57C9ED(__this, L_3, L_4, (&V_0), NULL);
V_2 = L_5;
bool L_6 = V_2;
if (!L_6)
{
goto IL_0030;
}
}
{
Func_3_t5328A430FC4208B44C52E4E89DC5F686DE6A6A1B* L_7 = ___converterFunc2;
String_t* L_8 = V_0;
float L_9 = ___defaultValue3;
float L_10;
L_10 = (( float (*) (Func_3_t5328A430FC4208B44C52E4E89DC5F686DE6A6A1B*, String_t*, float, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_7, L_8, L_9, il2cpp_rgctx_method(method->rgctx_data, 1));
V_3 = L_10;
goto IL_0035;
}
IL_0030:
{
float L_11 = ___defaultValue3;
V_3 = L_11;
goto IL_0035;
}
IL_0035:
{
float L_12 = V_3;
return L_12;
}
}
// System.Boolean UnityEngine.UIElements.UxmlAttributeDescription::TryGetValueFromBag<System.Boolean>(UnityEngine.UIElements.IUxmlAttributes,UnityEngine.UIElements.CreationContext,System.Func`3<System.String,T,T>,T,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UxmlAttributeDescription_TryGetValueFromBag_TisBoolean_t09A6377A54BE2F9E6985A8149F19234FD7DDFE22_m8D501F46447CC1568AA5403F1AC2691D744A0E17_gshared (UxmlAttributeDescription_t742D021489DB2B564142146CAAAC3F9191825EF2* __this, RuntimeObject* ___bag0, CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 ___cc1, Func_3_t62BC9D925DCAC8F5784BA97C793F4E593496CDA7* ___converterFunc2, bool ___defaultValue3, bool* ___value4, const RuntimeMethod* method)
{
String_t* V_0 = NULL;
bool V_1 = false;
bool V_2 = false;
bool V_3 = false;
{
RuntimeObject* L_0 = ___bag0;
CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 L_1 = ___cc1;
bool L_2;
L_2 = UxmlAttributeDescription_TryGetValueFromBagAsString_mF08874E8E58AD04C20041C076E2447E9AF57C9ED(__this, L_0, L_1, (&V_0), NULL);
V_1 = L_2;
bool L_3 = V_1;
if (!L_3)
{
goto IL_003b;
}
}
{
Func_3_t62BC9D925DCAC8F5784BA97C793F4E593496CDA7* L_4 = ___converterFunc2;
V_2 = (bool)((!(((RuntimeObject*)(Func_3_t62BC9D925DCAC8F5784BA97C793F4E593496CDA7*)L_4) <= ((RuntimeObject*)(RuntimeObject*)NULL)))? 1 : 0);
bool L_5 = V_2;
if (!L_5)
{
goto IL_002c;
}
}
{
bool* L_6 = ___value4;
Func_3_t62BC9D925DCAC8F5784BA97C793F4E593496CDA7* L_7 = ___converterFunc2;
String_t* L_8 = V_0;
bool L_9 = ___defaultValue3;
bool L_10;
L_10 = (( bool (*) (Func_3_t62BC9D925DCAC8F5784BA97C793F4E593496CDA7*, String_t*, bool, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_7, L_8, L_9, il2cpp_rgctx_method(method->rgctx_data, 1));
*(bool*)L_6 = L_10;
goto IL_0037;
}
IL_002c:
{
bool* L_11 = ___value4;
bool L_12 = ___defaultValue3;
*(bool*)L_11 = L_12;
}
IL_0037:
{
V_3 = (bool)1;
goto IL_003f;
}
IL_003b:
{
V_3 = (bool)0;
goto IL_003f;
}
IL_003f:
{
bool L_13 = V_3;
return L_13;
}
}
// System.Boolean UnityEngine.UIElements.UxmlAttributeDescription::TryGetValueFromBag<System.Int32>(UnityEngine.UIElements.IUxmlAttributes,UnityEngine.UIElements.CreationContext,System.Func`3<System.String,T,T>,T,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UxmlAttributeDescription_TryGetValueFromBag_TisInt32_t680FF22E76F6EFAD4375103CBBFFA0421349384C_m2A29552F5ABFE82902CCE5FB193BAF71C65C8AD5_gshared (UxmlAttributeDescription_t742D021489DB2B564142146CAAAC3F9191825EF2* __this, RuntimeObject* ___bag0, CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 ___cc1, Func_3_t0620ECF6AB73866242850ABCE518B069D201DA79* ___converterFunc2, int32_t ___defaultValue3, int32_t* ___value4, const RuntimeMethod* method)
{
String_t* V_0 = NULL;
bool V_1 = false;
bool V_2 = false;
bool V_3 = false;
{
RuntimeObject* L_0 = ___bag0;
CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 L_1 = ___cc1;
bool L_2;
L_2 = UxmlAttributeDescription_TryGetValueFromBagAsString_mF08874E8E58AD04C20041C076E2447E9AF57C9ED(__this, L_0, L_1, (&V_0), NULL);
V_1 = L_2;
bool L_3 = V_1;
if (!L_3)
{
goto IL_003b;
}
}
{
Func_3_t0620ECF6AB73866242850ABCE518B069D201DA79* L_4 = ___converterFunc2;
V_2 = (bool)((!(((RuntimeObject*)(Func_3_t0620ECF6AB73866242850ABCE518B069D201DA79*)L_4) <= ((RuntimeObject*)(RuntimeObject*)NULL)))? 1 : 0);
bool L_5 = V_2;
if (!L_5)
{
goto IL_002c;
}
}
{
int32_t* L_6 = ___value4;
Func_3_t0620ECF6AB73866242850ABCE518B069D201DA79* L_7 = ___converterFunc2;
String_t* L_8 = V_0;
int32_t L_9 = ___defaultValue3;
int32_t L_10;
L_10 = (( int32_t (*) (Func_3_t0620ECF6AB73866242850ABCE518B069D201DA79*, String_t*, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_7, L_8, L_9, il2cpp_rgctx_method(method->rgctx_data, 1));
*(int32_t*)L_6 = L_10;
goto IL_0037;
}
IL_002c:
{
int32_t* L_11 = ___value4;
int32_t L_12 = ___defaultValue3;
*(int32_t*)L_11 = L_12;
}
IL_0037:
{
V_3 = (bool)1;
goto IL_003f;
}
IL_003b:
{
V_3 = (bool)0;
goto IL_003f;
}
IL_003f:
{
bool L_13 = V_3;
return L_13;
}
}
// System.Boolean UnityEngine.UIElements.UxmlAttributeDescription::TryGetValueFromBag<System.Int32Enum>(UnityEngine.UIElements.IUxmlAttributes,UnityEngine.UIElements.CreationContext,System.Func`3<System.String,T,T>,T,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UxmlAttributeDescription_TryGetValueFromBag_TisInt32Enum_tCBAC8BA2BFF3A845FA599F303093BBBA374B6F0C_mBF6B69FD22082486E0E8C3E72FF29FAE946751E8_gshared (UxmlAttributeDescription_t742D021489DB2B564142146CAAAC3F9191825EF2* __this, RuntimeObject* ___bag0, CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 ___cc1, Func_3_t538A8E697534A282316BC2DF71DE83E68360C8B9* ___converterFunc2, int32_t ___defaultValue3, int32_t* ___value4, const RuntimeMethod* method)
{
String_t* V_0 = NULL;
bool V_1 = false;
bool V_2 = false;
bool V_3 = false;
{
RuntimeObject* L_0 = ___bag0;
CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 L_1 = ___cc1;
bool L_2;
L_2 = UxmlAttributeDescription_TryGetValueFromBagAsString_mF08874E8E58AD04C20041C076E2447E9AF57C9ED(__this, L_0, L_1, (&V_0), NULL);
V_1 = L_2;
bool L_3 = V_1;
if (!L_3)
{
goto IL_003b;
}
}
{
Func_3_t538A8E697534A282316BC2DF71DE83E68360C8B9* L_4 = ___converterFunc2;
V_2 = (bool)((!(((RuntimeObject*)(Func_3_t538A8E697534A282316BC2DF71DE83E68360C8B9*)L_4) <= ((RuntimeObject*)(RuntimeObject*)NULL)))? 1 : 0);
bool L_5 = V_2;
if (!L_5)
{
goto IL_002c;
}
}
{
int32_t* L_6 = ___value4;
Func_3_t538A8E697534A282316BC2DF71DE83E68360C8B9* L_7 = ___converterFunc2;
String_t* L_8 = V_0;
int32_t L_9 = ___defaultValue3;
int32_t L_10;
L_10 = (( int32_t (*) (Func_3_t538A8E697534A282316BC2DF71DE83E68360C8B9*, String_t*, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_7, L_8, L_9, il2cpp_rgctx_method(method->rgctx_data, 1));
*(int32_t*)L_6 = L_10;
goto IL_0037;
}
IL_002c:
{
int32_t* L_11 = ___value4;
int32_t L_12 = ___defaultValue3;
*(int32_t*)L_11 = L_12;
}
IL_0037:
{
V_3 = (bool)1;
goto IL_003f;
}
IL_003b:
{
V_3 = (bool)0;
goto IL_003f;
}
IL_003f:
{
bool L_13 = V_3;
return L_13;
}
}
// System.Boolean UnityEngine.UIElements.UxmlAttributeDescription::TryGetValueFromBag<System.Object>(UnityEngine.UIElements.IUxmlAttributes,UnityEngine.UIElements.CreationContext,System.Func`3<System.String,T,T>,T,T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR bool UxmlAttributeDescription_TryGetValueFromBag_TisRuntimeObject_mBD67FCD642F352CE1837AA2BEB414BA72028C743_gshared (UxmlAttributeDescription_t742D021489DB2B564142146CAAAC3F9191825EF2* __this, RuntimeObject* ___bag0, CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 ___cc1, Func_3_tBFBF2C1D5A7EE5485A61C55BA580F7AF50AABBF0* ___converterFunc2, RuntimeObject* ___defaultValue3, RuntimeObject** ___value4, const RuntimeMethod* method)
{
String_t* V_0 = NULL;
bool V_1 = false;
bool V_2 = false;
bool V_3 = false;
{
RuntimeObject* L_0 = ___bag0;
CreationContext_t9C57B5BE551CCE200C0A2C72711BFF9DA298C257 L_1 = ___cc1;
bool L_2;
L_2 = UxmlAttributeDescription_TryGetValueFromBagAsString_mF08874E8E58AD04C20041C076E2447E9AF57C9ED(__this, L_0, L_1, (&V_0), NULL);
V_1 = L_2;
bool L_3 = V_1;
if (!L_3)
{
goto IL_003b;
}
}
{
Func_3_tBFBF2C1D5A7EE5485A61C55BA580F7AF50AABBF0* L_4 = ___converterFunc2;
V_2 = (bool)((!(((RuntimeObject*)(Func_3_tBFBF2C1D5A7EE5485A61C55BA580F7AF50AABBF0*)L_4) <= ((RuntimeObject*)(RuntimeObject*)NULL)))? 1 : 0);
bool L_5 = V_2;
if (!L_5)
{
goto IL_002c;
}
}
{
RuntimeObject** L_6 = ___value4;
Func_3_tBFBF2C1D5A7EE5485A61C55BA580F7AF50AABBF0* L_7 = ___converterFunc2;
String_t* L_8 = V_0;
RuntimeObject* L_9 = ___defaultValue3;
RuntimeObject* L_10;
L_10 = (( RuntimeObject* (*) (Func_3_tBFBF2C1D5A7EE5485A61C55BA580F7AF50AABBF0*, String_t*, RuntimeObject*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_7, L_8, L_9, il2cpp_rgctx_method(method->rgctx_data, 1));
*(RuntimeObject**)L_6 = L_10;
Il2CppCodeGenWriteBarrier((void**)(RuntimeObject**)L_6, (void*)L_10);
goto IL_0037;
}
IL_002c:
{
RuntimeObject** L_11 = ___value4;
RuntimeObject* L_12 = ___defaultValue3;
*(RuntimeObject**)L_11 = L_12;
Il2CppCodeGenWriteBarrier((void**)(RuntimeObject**)L_11, (void*)L_12);
}
IL_0037:
{
V_3 = (bool)1;
goto IL_003f;
}
IL_003b:
{
V_3 = (bool)0;
goto IL_003f;
}
IL_003f:
{
bool L_13 = V_3;
return L_13;
}
}
// System.Numerics.Vector`1<System.UInt64> System.Numerics.Vector::AsVectorUInt64<System.UInt16>(System.Numerics.Vector`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector_1_t566D05A9DE75BCD8F12F1E09AC3F8A4BC01BF92A Vector_AsVectorUInt64_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_mB1290EF33E80A390B04A3A61E2ED8039C7C1D527_gshared (Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 ___value0, const RuntimeMethod* method)
{
{
Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 L_0 = ___value0;
il2cpp_codegen_runtime_class_init_inline(il2cpp_rgctx_data(method->rgctx_data, 1));
Vector_1_t566D05A9DE75BCD8F12F1E09AC3F8A4BC01BF92A L_1;
L_1 = (( Vector_1_t566D05A9DE75BCD8F12F1E09AC3F8A4BC01BF92A (*) (Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 0));
return L_1;
}
}
// System.Numerics.Vector`1<T> System.Numerics.Vector::Equals<System.UInt16>(System.Numerics.Vector`1<T>,System.Numerics.Vector`1<T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 Vector_Equals_TisUInt16_tF4C148C876015C212FD72652D0B6ED8CC247A455_mDF58FEA5BFA35E22ED8C525BA9EE0B508F567406_gshared (Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 ___left0, Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 ___right1, const RuntimeMethod* method)
{
{
Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 L_0 = ___left0;
Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 L_1 = ___right1;
il2cpp_codegen_runtime_class_init_inline(il2cpp_rgctx_data(method->rgctx_data, 1));
Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 L_2;
L_2 = (( Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489 (*) (Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489, Vector_1_tACF5C606E327928B31CCD8E09C9224DCA7065489, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_0, L_1, il2cpp_rgctx_method(method->rgctx_data, 0));
return L_2;
}
}
// UnityEngine.UIElements.Experimental.ValueAnimation`1<T> UnityEngine.UIElements.VisualElement::StartAnimation<System.Object>(UnityEngine.UIElements.Experimental.ValueAnimation`1<T>,System.Func`2<UnityEngine.UIElements.VisualElement,T>,T,System.Int32,System.Action`2<UnityEngine.UIElements.VisualElement,T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B* VisualElement_StartAnimation_TisRuntimeObject_mFBD42C4DE9E16FE6E43F9B7717A2ECC761B98902_gshared (ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B* ___anim0, Func_2_t9AAA83BE20528E7FBB1DCCFF8E9640E7061D5BE3* ___fromValueGetter1, RuntimeObject* ___to2, int32_t ___durationMs3, Action_2_t481D6C6BCDB085CB7BE1AA1DBD81F4DC0C04D1F2* ___onValueChanged4, const RuntimeMethod* method)
{
ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B* V_0 = NULL;
{
ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B* L_0 = ___anim0;
Func_2_t9AAA83BE20528E7FBB1DCCFF8E9640E7061D5BE3* L_1 = ___fromValueGetter1;
(( void (*) (ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B*, Func_2_t9AAA83BE20528E7FBB1DCCFF8E9640E7061D5BE3*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, L_1, il2cpp_rgctx_method(method->rgctx_data, 1));
ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B* L_2 = ___anim0;
RuntimeObject* L_3 = ___to2;
(( void (*) (ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B*, RuntimeObject*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(L_2, L_3, il2cpp_rgctx_method(method->rgctx_data, 2));
ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B* L_4 = ___anim0;
int32_t L_5 = ___durationMs3;
(( void (*) (ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B*, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 3)))(L_4, L_5, il2cpp_rgctx_method(method->rgctx_data, 3));
ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B* L_6 = ___anim0;
Action_2_t481D6C6BCDB085CB7BE1AA1DBD81F4DC0C04D1F2* L_7 = ___onValueChanged4;
(( void (*) (ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B*, Action_2_t481D6C6BCDB085CB7BE1AA1DBD81F4DC0C04D1F2*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 4)))(L_6, L_7, il2cpp_rgctx_method(method->rgctx_data, 4));
ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B* L_8 = ___anim0;
(( void (*) (ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 5)))(L_8, il2cpp_rgctx_method(method->rgctx_data, 5));
ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B* L_9 = ___anim0;
V_0 = L_9;
goto IL_002d;
}
IL_002d:
{
ValueAnimation_1_tF3671ECA2C7631382409A777D0358001E0815F7B* L_10 = V_0;
return L_10;
}
}
// UnityEngine.UIElements.Experimental.ValueAnimation`1<T> UnityEngine.UIElements.VisualElement::StartAnimation<UnityEngine.UIElements.Experimental.StyleValues>(UnityEngine.UIElements.Experimental.ValueAnimation`1<T>,System.Func`2<UnityEngine.UIElements.VisualElement,T>,T,System.Int32,System.Action`2<UnityEngine.UIElements.VisualElement,T>)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC* VisualElement_StartAnimation_TisStyleValues_t4AED947A53B84B62EF2B589A40B74911CA77D11A_mADB9C50790E47B4253CE04BC5B8F7A83CCAF68ED_gshared (ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC* ___anim0, Func_2_t87FB5A45506EB8DF671CF8BEB31A0FD5A00FA227* ___fromValueGetter1, StyleValues_t4AED947A53B84B62EF2B589A40B74911CA77D11A ___to2, int32_t ___durationMs3, Action_2_tCFAD9DC5CF83678682A1102DCD1B12DE9FCA395A* ___onValueChanged4, const RuntimeMethod* method)
{
ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC* V_0 = NULL;
{
ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC* L_0 = ___anim0;
Func_2_t87FB5A45506EB8DF671CF8BEB31A0FD5A00FA227* L_1 = ___fromValueGetter1;
(( void (*) (ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC*, Func_2_t87FB5A45506EB8DF671CF8BEB31A0FD5A00FA227*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_0, L_1, il2cpp_rgctx_method(method->rgctx_data, 1));
ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC* L_2 = ___anim0;
StyleValues_t4AED947A53B84B62EF2B589A40B74911CA77D11A L_3 = ___to2;
(( void (*) (ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC*, StyleValues_t4AED947A53B84B62EF2B589A40B74911CA77D11A, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 2)))(L_2, L_3, il2cpp_rgctx_method(method->rgctx_data, 2));
ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC* L_4 = ___anim0;
int32_t L_5 = ___durationMs3;
(( void (*) (ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC*, int32_t, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 3)))(L_4, L_5, il2cpp_rgctx_method(method->rgctx_data, 3));
ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC* L_6 = ___anim0;
Action_2_tCFAD9DC5CF83678682A1102DCD1B12DE9FCA395A* L_7 = ___onValueChanged4;
(( void (*) (ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC*, Action_2_tCFAD9DC5CF83678682A1102DCD1B12DE9FCA395A*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 4)))(L_6, L_7, il2cpp_rgctx_method(method->rgctx_data, 4));
ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC* L_8 = ___anim0;
(( void (*) (ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 5)))(L_8, il2cpp_rgctx_method(method->rgctx_data, 5));
ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC* L_9 = ___anim0;
V_0 = L_9;
goto IL_002d;
}
IL_002d:
{
ValueAnimation_1_t639ABF37111B0184CCB3DE2F577E466F04B28FAC* L_10 = V_0;
return L_10;
}
}
// System.Void UnityEngine.UIElements.VisualTreeUpdater::SetUpdater<System.Object>(UnityEngine.UIElements.VisualTreeUpdatePhase)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void VisualTreeUpdater_SetUpdater_TisRuntimeObject_m8476DF92DC347257A6AFCA48272BE51985407784_gshared (VisualTreeUpdater_tFDE7D9F9A146A26B2ED69565B7BD142B416AB9C9* __this, int32_t ___phase0, const RuntimeMethod* method)
{
static bool s_Il2CppMethodInitialized;
if (!s_Il2CppMethodInitialized)
{
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&IDisposable_t030E0496B4E0E4E4F086825007979AF51F7248C5_il2cpp_TypeInfo_var);
il2cpp_codegen_initialize_runtime_metadata((uintptr_t*)&IVisualTreeUpdater_t4AF1E0B23A6AEFF024F1AC23815089B2495C7F06_il2cpp_TypeInfo_var);
s_Il2CppMethodInitialized = true;
}
RuntimeObject* V_0 = NULL;
RuntimeObject* V_1 = NULL;
RuntimeObject* G_B2_0 = NULL;
RuntimeObject* G_B1_0 = NULL;
{
UpdaterArray_tF8D43D2A3598E7C17ABB5308E83FDECF1F36A449* L_0 = (UpdaterArray_tF8D43D2A3598E7C17ABB5308E83FDECF1F36A449*)__this->___m_UpdaterArray_1;
int32_t L_1 = ___phase0;
RuntimeObject* L_2;
L_2 = UpdaterArray_get_Item_m6DADA11557BD3FE2E6680F3C1F6F828DB4EE255C(L_0, L_1, NULL);
RuntimeObject* L_3 = L_2;
G_B1_0 = L_3;
if (L_3)
{
G_B2_0 = L_3;
goto IL_0013;
}
}
{
goto IL_0019;
}
IL_0013:
{
InterfaceActionInvoker0::Invoke(0 /* System.Void System.IDisposable::Dispose() */, IDisposable_t030E0496B4E0E4E4F086825007979AF51F7248C5_il2cpp_TypeInfo_var, (RuntimeObject*)G_B2_0);
}
IL_0019:
{
RuntimeObject* L_4;
L_4 = (( RuntimeObject* (*) (const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(il2cpp_rgctx_method(method->rgctx_data, 0));
V_1 = L_4;
BaseVisualElementPanel_tE3811F3D1474B72CB6CD5BCEECFF5B5CBEC1E303* L_5 = (BaseVisualElementPanel_tE3811F3D1474B72CB6CD5BCEECFF5B5CBEC1E303*)__this->___m_Panel_0;
InterfaceActionInvoker1< BaseVisualElementPanel_tE3811F3D1474B72CB6CD5BCEECFF5B5CBEC1E303* >::Invoke(0 /* System.Void UnityEngine.UIElements.IVisualTreeUpdater::set_panel(UnityEngine.UIElements.BaseVisualElementPanel) */, IVisualTreeUpdater_t4AF1E0B23A6AEFF024F1AC23815089B2495C7F06_il2cpp_TypeInfo_var, (RuntimeObject*)(V_1), L_5);
RuntimeObject* L_6 = V_1;
V_0 = L_6;
UpdaterArray_tF8D43D2A3598E7C17ABB5308E83FDECF1F36A449* L_7 = (UpdaterArray_tF8D43D2A3598E7C17ABB5308E83FDECF1F36A449*)__this->___m_UpdaterArray_1;
int32_t L_8 = ___phase0;
RuntimeObject* L_9 = V_0;
UpdaterArray_set_Item_m2961BC09E3C22E6D3887BB8E48A367BAEF847A11(L_7, L_8, (RuntimeObject*)L_9, NULL);
return;
}
}
// T System.Threading.Volatile::Read<System.Object>(T&)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR RuntimeObject* Volatile_Read_TisRuntimeObject_m1BB143C73CA3A7A5B880A663FEE10E149F0F274F_gshared (RuntimeObject** ___location0, const RuntimeMethod* method)
{
{
RuntimeObject** L_0 = ___location0;
VolatileObject_tEA3ACFAAFB9D2EFA5162F693BAAB342EA7737B99* L_1;
L_1 = (( VolatileObject_tEA3ACFAAFB9D2EFA5162F693BAAB342EA7737B99* (*) (RuntimeObject**, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_2 = (RuntimeObject*)L_1->___Value_0;
il2cpp_codegen_memory_barrier();
RuntimeObject* L_3;
L_3 = (( RuntimeObject* (*) (RuntimeObject*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 1)))(L_2, il2cpp_rgctx_method(method->rgctx_data, 1));
return L_3;
}
}
// System.Void System.Threading.Volatile::Write<System.Object>(T&,T)
IL2CPP_EXTERN_C IL2CPP_METHOD_ATTR void Volatile_Write_TisRuntimeObject_mB9B6B04771AC33604CEAD0611ADB13B54869254B_gshared (RuntimeObject** ___location0, RuntimeObject* ___value1, const RuntimeMethod* method)
{
{
RuntimeObject** L_0 = ___location0;
VolatileObject_tEA3ACFAAFB9D2EFA5162F693BAAB342EA7737B99* L_1;
L_1 = (( VolatileObject_tEA3ACFAAFB9D2EFA5162F693BAAB342EA7737B99* (*) (RuntimeObject**, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->rgctx_data, 0)))(L_0, il2cpp_rgctx_method(method->rgctx_data, 0));
RuntimeObject* L_2 = ___value1;
il2cpp_codegen_memory_barrier();
L_1->___Value_0 = L_2;
Il2CppCodeGenWriteBarrier((void**)(&L_1->___Value_0), (void*)L_2);
return;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void IntPtr__ctor_m4F9A9B80F01996B610D5AE4797F20B98ECD0A3D9_inline (intptr_t* __this, void* ___value0, const RuntimeMethod* method)
{
{
void* L_0 = ___value0;
*__this = ((intptr_t)L_0);
return;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void Span_1__ctor_mC9BE2938B716B46BB6B9070B94DBE5CE814BC0E2_gshared_inline (Span_1_tEDDF15FCF9EC6DEBA0F696BAACDDBAB9D92C252D* __this, Il2CppChar* ___ptr0, int32_t ___length1, const RuntimeMethod* method)
{
{
Il2CppChar* L_0 = ___ptr0;
ByReference_1_t7BA5A6CA164F770BC688F21C5978D368716465F5 L_1;
memset((&L_1), 0, sizeof(L_1));
il2cpp_codegen_by_reference_constructor((Il2CppByReference*)(&L_1), L_0);
__this->____pointer_0 = L_1;
int32_t L_2 = ___length1;
__this->____length_1 = L_2;
return;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR void List_1_Add_mEBCF994CC3814631017F46A387B1A192ED6C85C7_gshared_inline (List_1_tA239CB83DE5615F348BB0507E45F490F4F7C9A8D* __this, RuntimeObject* ___item0, const RuntimeMethod* method)
{
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* V_0 = NULL;
int32_t V_1 = 0;
{
int32_t L_0 = (int32_t)__this->____version_3;
__this->____version_3 = ((int32_t)il2cpp_codegen_add(L_0, 1));
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_1 = (ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918*)__this->____items_1;
V_0 = L_1;
int32_t L_2 = (int32_t)__this->____size_2;
V_1 = L_2;
int32_t L_3 = V_1;
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_4 = V_0;
if ((!(((uint32_t)L_3) < ((uint32_t)((int32_t)(((RuntimeArray*)L_4)->max_length))))))
{
goto IL_0034;
}
}
{
int32_t L_5 = V_1;
__this->____size_2 = ((int32_t)il2cpp_codegen_add(L_5, 1));
ObjectU5BU5D_t8061030B0A12A55D5AD8652A20C922FE99450918* L_6 = V_0;
int32_t L_7 = V_1;
RuntimeObject* L_8 = ___item0;
(L_6)->SetAtUnchecked(static_cast<il2cpp_array_size_t>(L_7), (RuntimeObject*)L_8);
return;
}
IL_0034:
{
RuntimeObject* L_9 = ___item0;
(( void (*) (List_1_tA239CB83DE5615F348BB0507E45F490F4F7C9A8D*, RuntimeObject*, const RuntimeMethod*))il2cpp_codegen_get_method_pointer(il2cpp_rgctx_method(method->klass->rgctx_data, 11)))(__this, L_9, il2cpp_rgctx_method(method->klass->rgctx_data, 11));
return;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR int32_t NativeSlice_1_get_Length_m2566843C81FEFDDF6407962D4E34F13C3133028D_gshared_inline (NativeSlice_1_t2E5DBD9A5F77A5044A4160098A0B2A45D3EE8974* __this, const RuntimeMethod* method)
{
{
int32_t L_0 = (int32_t)__this->___m_Length_2;
return L_0;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR int32_t NativeSlice_1_get_Length_mC069C9254C3F61C678293E03E3E7C51F245F52E9_gshared_inline (NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370* __this, const RuntimeMethod* method)
{
{
int32_t L_0 = (int32_t)__this->___m_Length_2;
return L_0;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR int32_t NativeSlice_1_get_Stride_mE29B800705645CDD49B576BB3B9B328811F27C90_gshared_inline (NativeSlice_1_t8229A12E65C90A3900340F6E126089DB5696D370* __this, const RuntimeMethod* method)
{
{
int32_t L_0 = (int32_t)__this->___m_Stride_1;
return L_0;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR int32_t NativeSlice_1_get_Length_mED822A5A5476BEBA72E429C395644A7B41F78F50_gshared_inline (NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F* __this, const RuntimeMethod* method)
{
{
int32_t L_0 = (int32_t)__this->___m_Length_2;
return L_0;
}
}
IL2CPP_MANAGED_FORCE_INLINE IL2CPP_METHOD_ATTR int32_t NativeSlice_1_get_Stride_m2BC6AD2264EE2D02A38D29E30D382DEA9B5A9E29_gshared_inline (NativeSlice_1_tA687F314957178F2A299D03D59B960DDC218680F* __this, const RuntimeMethod* method)
{
{
int32_t L_0 = (int32_t)__this->___m_Stride_1;
return L_0;
}
}
| [
"[email protected]"
] | |
8eb3b82461954699629828a1b556b7127fdc11c7 | b3c47795e8b6d95ae5521dcbbb920ab71851a92f | /hihoCoder/1106.cc | e73c4d8b31503f2ce1aa5ef53619840cda665c4c | [
"LicenseRef-scancode-warranty-disclaimer"
] | no_license | Wizmann/ACM-ICPC | 6afecd0fd09918c53a2a84c4d22c244de0065710 | 7c30454c49485a794dcc4d1c09daf2f755f9ecc1 | refs/heads/master | 2023-07-15T02:46:21.372860 | 2023-07-09T15:30:27 | 2023-07-09T15:30:27 | 3,009,276 | 51 | 23 | null | null | null | null | UTF-8 | C++ | false | false | 846 | cc | #include <cstdio>
#include <cstdlib>
#include <cstring>
#include <iostream>
#include <algorithm>
#include <vector>
using namespace std;
#define print(x) cout << x << endl
#define input(x) cin >> x
typedef long long llint ;
const llint MAXI = 1000000000LL;
vector<llint> vier;
void init() {
llint v = 1;
while (v <= MAXI) {
vier.push_back(v);
v *= 4;
}
}
int main() {
freopen("input.txt", "r", stdin);
init();
int T, a, b;
input(T);
while (T--) {
scanf("%d%d", &a, &b);
a--;
if (b < vier.size()) {
llint v = vier[b];
a %= v;
}
while (a && a % 4 != 1 && a % 4 != 2) {
b--;
a /= 4;
}
if (a == 0) {
b = 0;
}
printf("%d\n", b);
}
return 0;
}
| [
"[email protected]"
] | |
e068d7e17155b820b463ae3e29e0b3f89c6fd8b4 | f7ded95f8aded74a67c3494952e0cffa3b4977e1 | /impl/Terminals.cpp | 05f2d58c9c940e5fb47550c57e371b9b9846a1de | [
"MIT"
] | permissive | ryanmolden/Erlang-Lexer-Parser | 9656c885e5203011d94d781b2a892afdbf6ab98a | 9932fb6da7cdaf4401e1916a493fe30618fb32c0 | refs/heads/master | 2016-09-05T16:02:27.629138 | 2012-01-04T03:06:19 | 2012-01-04T03:06:19 | 2,959,797 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 513 | cpp | #include "StdAfx.h"
#include "Terminals_def.h"
namespace lex = boost::spirit::lex;
typedef lex::lexertl::token<const wchar_t*> TokenType;
typedef ErlangLexer<lex::lexertl::actor_lexer<TokenType>> LexerType;
typedef LexerType::iterator_type LexerIteratorType;
typedef CommentSkipper<LexerIteratorType, typename LexerType::Token> CommentSkipperType;
//Force an instantiation of the ErlangTerminals class so the ctor is generated.
template struct ErlangTerminals<LexerIteratorType, LexerType, CommentSkipperType>; | [
"[email protected]"
] | |
b820a4b9b9b87d40d4e8fcb507e8e07dde0db376 | f7936cf3e2abb8939e9bb1aadb7d88e1eb0f0377 | /삼성 SW 역량 테스트/20055.cpp | 06eca2b540e15e8984411b33a4d19dcbb6d6f15e | [] | no_license | raeyoungii/BOJ | b30f599ddcd663ee765d98f1a3ef23b5976e2ab7 | cb8f6ad8545ea6810dc08e39e2f365ca0e637bd8 | refs/heads/master | 2023-06-14T04:23:32.087035 | 2021-07-02T16:43:06 | 2021-07-02T16:43:06 | 329,713,517 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,364 | cpp | #include <bits/stdc++.h>
using namespace std;
typedef long long ll;
int n, k;
deque<pair<bool, int>> a;
// 벨트가 한 칸 회전한다.
void rotate() {
a[n - 1].first = false;
a.push_front(a.back());
a.pop_back();
}
// 가장 먼저 벨트에 올라간 로봇부터, 벨트가 회전하는 방향으로 한 칸 이동할 수 있다면 이동한다.
// 만약 이동할 수 없다면 가만히 있는다.
void move() {
a[n - 1].first = false;
for (int i = n - 2; i > 0; i--) {
if (a[i].first) {
if (!a[i + 1].first && a[i + 1].second > 0) {
a[i].first = false;
a[i + 1].first = true;
a[i + 1].second--;
}
}
}
}
// 올라가는 위치에 로봇이 없다면 로봇을 하나 올린다.
void put() {
if (a[0].second > 0) {
a[0].first = true;
a[0].second--;
}
}
int main() {
ios::sync_with_stdio(false);
cin.tie(nullptr);
cin >> n >> k;
for (int i = 0; i < 2 * n; i++) {
int t; cin >> t;
a.emplace_back(false, t);
}
int cnt = 0, step = 0;
while (cnt < k) {
step++;
cnt = 0;
rotate();
move();
put();
for (int i = 0; i < 2 * n; i++) {
if (a[i].second == 0) cnt++;
}
}
cout << step << "\n";
return 0;
}
| [
"[email protected]"
] | |
07fe0c2113a161dd3efc51518842b391a16c3f7c | a754da405bc3d2d2d1d8940d7d277c63bf2b7768 | /graphics/overlay.cpp | b68a84830c43b9ca32986de44ed52ff6c30fcc14 | [
"Apache-2.0"
] | permissive | icyleaf/omim | 3a5a4f07890e6ad0155447ed39563a710178ec35 | a1a299eb341603337bf4a22b92518d9575498c97 | refs/heads/master | 2020-12-28T22:53:52.624975 | 2015-10-09T16:30:46 | 2015-10-09T16:30:46 | 43,995,093 | 0 | 0 | Apache-2.0 | 2019-12-12T03:19:59 | 2015-10-10T05:08:38 | C++ | UTF-8 | C++ | false | false | 5,734 | cpp | #include "graphics/overlay.hpp"
#include "graphics/overlay_renderer.hpp"
#include "base/logging.hpp"
#include "base/stl_add.hpp"
#include "std/bind.hpp"
#include "std/vector.hpp"
namespace graphics
{
OverlayStorage::OverlayStorage()
: m_needClip(false)
{
}
OverlayStorage::OverlayStorage(const m2::RectD & clipRect)
: m_clipRect(clipRect)
, m_needClip(true)
{
}
size_t OverlayStorage::GetSize() const
{
return m_elements.size();
}
void OverlayStorage::AddElement(const shared_ptr<OverlayElement> & elem)
{
if (m_needClip == false)
{
m_elements.push_back(elem);
return;
}
OverlayElement::RectsT rects;
elem->GetMiniBoundRects(rects);
for (size_t j = 0; j < rects.size(); ++j)
{
if (m_clipRect.IsIntersect(rects[j]))
{
m_elements.push_back(elem);
break;
}
}
}
bool betterOverlayElement(shared_ptr<OverlayElement> const & l,
shared_ptr<OverlayElement> const & r)
{
// "frozen" object shouldn't be popped out.
if (r->isFrozen())
return false;
// for the composite elements, collected in OverlayRenderer to replace the part elements
return l->priority() > r->priority();
}
m2::RectD const OverlayElementTraits::LimitRect(shared_ptr<OverlayElement> const & elem)
{
return elem->GetBoundRect();
}
size_t Overlay::getElementsCount() const
{
return m_tree.GetSize();
}
void Overlay::lock()
{
m_mutex.Lock();
}
void Overlay::unlock()
{
m_mutex.Unlock();
}
void Overlay::clear()
{
m_tree.Clear();
}
struct DoPreciseSelectByRect
{
m2::AnyRectD m_rect;
list<shared_ptr<OverlayElement> > * m_elements;
DoPreciseSelectByRect(m2::RectD const & rect,
list<shared_ptr<OverlayElement> > * elements)
: m_rect(rect),
m_elements(elements)
{}
void operator()(shared_ptr<OverlayElement> const & e)
{
OverlayElement::RectsT rects;
e->GetMiniBoundRects(rects);
for (size_t i = 0; i < rects.size(); ++i)
{
if (m_rect.IsIntersect(rects[i]))
{
m_elements->push_back(e);
break;
}
}
}
};
class DoPreciseIntersect
{
shared_ptr<OverlayElement> m_oe;
OverlayElement::RectsT m_rects;
bool m_isIntersect;
public:
DoPreciseIntersect(shared_ptr<OverlayElement> const & oe)
: m_oe(oe), m_isIntersect(false)
{
m_oe->GetMiniBoundRects(m_rects);
}
m2::RectD GetSearchRect() const
{
m2::RectD rect;
for (size_t i = 0; i < m_rects.size(); ++i)
rect.Add(m_rects[i].GetGlobalRect());
return rect;
}
void operator()(shared_ptr<OverlayElement> const & e)
{
if (m_isIntersect)
return;
if (m_oe->m_userInfo == e->m_userInfo)
return;
OverlayElement::RectsT rects;
e->GetMiniBoundRects(rects);
for (size_t i = 0; i < m_rects.size(); ++i)
for (size_t j = 0; j < rects.size(); ++j)
{
m_isIntersect = m_rects[i].IsIntersect(rects[j]);
if (m_isIntersect)
return;
}
}
bool IsIntersect() const { return m_isIntersect; }
};
void Overlay::selectOverlayElements(m2::RectD const & rect, list<shared_ptr<OverlayElement> > & res) const
{
DoPreciseSelectByRect fn(rect, &res);
m_tree.ForEachInRect(rect, fn);
}
void Overlay::replaceOverlayElement(shared_ptr<OverlayElement> const & oe)
{
DoPreciseIntersect fn(oe);
m_tree.ForEachInRect(fn.GetSearchRect(), ref(fn));
if (fn.IsIntersect())
m_tree.ReplaceAllInRect(oe, &betterOverlayElement);
else
m_tree.Add(oe);
}
void Overlay::processOverlayElement(shared_ptr<OverlayElement> const & oe, math::Matrix<double, 3, 3> const & m)
{
oe->setTransformation(m);
if (oe->isValid())
processOverlayElement(oe);
}
void Overlay::processOverlayElement(shared_ptr<OverlayElement> const & oe)
{
if (oe->isValid())
replaceOverlayElement(oe);
}
bool greater_priority(shared_ptr<OverlayElement> const & l,
shared_ptr<OverlayElement> const & r)
{
return l->priority() > r->priority();
}
void Overlay::merge(shared_ptr<OverlayStorage> const & layer, math::Matrix<double, 3, 3> const & m)
{
buffer_vector<shared_ptr<OverlayElement>, 256> v;
v.reserve(layer->GetSize());
// 1. collecting all elements from tree
layer->ForEach(MakeBackInsertFunctor(v));
// 2. sorting by priority, so the more important ones comes first
sort(v.begin(), v.end(), &greater_priority);
// 3. merging them into the infoLayer starting from most
// important one to optimize the space usage.
for_each(v.begin(), v.end(), [&] (shared_ptr<OverlayElement> const & p)
{
processOverlayElement(p, m);
});
}
void Overlay::merge(shared_ptr<OverlayStorage> const & infoLayer)
{
buffer_vector<shared_ptr<OverlayElement>, 265> v;
v.reserve(infoLayer->GetSize());
// 1. collecting all elements from tree
infoLayer->ForEach(MakeBackInsertFunctor(v));
// 2. sorting by priority, so the more important ones comes first
sort(v.begin(), v.end(), &greater_priority);
// 3. merging them into the infoLayer starting from most
// important one to optimize the space usage.
for_each(v.begin(), v.end(), [this] (shared_ptr<OverlayElement> const & p)
{
processOverlayElement(p);
});
}
void Overlay::clip(m2::RectI const & r)
{
vector<shared_ptr<OverlayElement> > v;
v.reserve(m_tree.GetSize());
m_tree.ForEach(MakeBackInsertFunctor(v));
m_tree.Clear();
m2::RectD const rd(r);
m2::AnyRectD ard(rd);
for (shared_ptr<OverlayElement> const & e : v)
{
if (!e->isVisible())
continue;
OverlayElement::RectsT rects;
e->GetMiniBoundRects(rects);
for (size_t j = 0; j < rects.size(); ++j)
if (ard.IsIntersect(rects[j]))
{
processOverlayElement(e);
break;
}
}
}
}
| [
"[email protected]"
] | |
64dbf54845a81678fb2bedd8e37916f9dec02ac0 | bf817b914f2c423da15c330b2a60bdf9f32c798a | /9_24_practice/9_24_practice/test.cpp | cb3b7a5da70b621a45191d66be8982c7e89ac686 | [] | no_license | z397318716/C-Plus-Plus | 2d074ea53f7f45534f72b3109c86c0612eb32bfe | 6a7405386e60e1c2668fd8e92d7e4b4ab7903339 | refs/heads/master | 2021-12-10T22:16:34.871394 | 2021-09-27T01:55:23 | 2021-09-27T01:55:23 | 204,134,098 | 0 | 0 | null | null | null | null | GB18030 | C++ | false | false | 2,384 | cpp | //#include <iostream>
//#include <string>
//
//using namespace std;
//
//void access_string()
//{
// string s1("hello");
// const string s2(s1); // 拷贝构造
// for (int i = 0; i < s1.size(); i++)
// {
// cout << s1[i]; // [] 访问
// }
// cout << endl; // 换行
// s1[0] = 'a'; // 将对象s1首元素修改为 'a'
// //s2[0] = 'a'; // 该句错误,const 修饰s2,不可修改
// string::iterator it = s1.begin(); // 初始化迭代器
// for (; it < s1.end(); it++)
// {
// cout << *it; // 此处迭代器可理解为指针,对指针解引用
// }
//}
//void CapacityOperator()
//{
// // string 类支持直接使用 cout cin 操作
// char arr[] = "abcd";
// string s1(arr);
// string s2(s1);
// cout << s1.size() << endl;
// cout << s1.length() << endl;
// cout << s1.capacity() << endl;
// // 此处clear后,只改变了s1的size,并没有改变它的capacity
// s1.clear();
// cout << s1.size() << endl;
// cout << s1.capacity() << endl;
// // 将s1的有效字符长度置为10个,多出位置用 '\0' 填充
// s1.resize(10);
// cout << s1 << endl;
// cout << s1.size() << endl;
// cout << s1.capacity() << endl;
// // 将s2的有效字符长度置为10个,多出位置用字符'c'填充
// s2.resize(10, 'c');
// cout << s2 << endl;
// cout << s2.size() << endl;
// cout << s2.capacity() << endl;
// // 为s2预设20个空间长度
// s2.reserve(20);
// cout << s2.capacity() << endl;
//}
//void ModifyString()
//{
// char arr[] = " 123asd";
// string s1("hello");
// s1.push_back('!'); // 在字符串后追加一个感叹号
// s1.append(arr); // 在字符串后追加一个字符串
// s1 += " this"; // 在字符串后追加一个字符串
// s1 += "a"; // 在字符串后追加一个字符
// cout << s1 << endl;
// cout << s1.c_str() << endl; // 以C风格字符串打印
//
// string s2("string.cpp");
// size_t pos = s2.find('.'); // 从前向后在字符串s2中查找'.'位置
// string s3(s2.substr(0,pos)); // 从字符串s2首元素开始向后截取到pos处
// cout << s3 << endl;
//}
//int main()
//{
// string s1; // 构造空 string 对象s1
// string s2("hello"); // C风格字符串构造s2
// string s3(3, 'a'); // 3个字符'a'构造 s3对象
// string s4(s2); // 拷贝构造
// string s5(s2, 3); // 用s2中前3个字符构造s5
//
// //access_string();
// //CapacityOperator();
// ModifyString();
// return 0;
//} | [
"[email protected]"
] | |
887d3fcaa98326941e1de27234c1c1875437fe80 | 4a604abbf9d0f9f8b2710de7a60c1572cb34576b | /libs/logging/include/roboteam_logging/LogFileWriter.h | fa8c7dad06e677d80c117d91c98c59142544b0c9 | [] | no_license | RoboTeamTwente/roboteam_interface | 7cc56311988b28376152b7319c659487cc791aed | da63fa5f49f4430b68b28cdb542adb464a8464ed | refs/heads/development | 2022-08-19T17:49:42.498555 | 2022-07-03T20:40:44 | 2022-07-03T20:40:44 | 244,662,889 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,033 | h | //
// Created by rolf on 28-05-22.
//
#ifndef RTT_LOGFILEWRITER_H
#define RTT_LOGFILEWRITER_H
#include "LogFileHeader.h"
#include "proto/State.pb.h"
#include <fstream>
namespace rtt{
class LogFileWriter {
public:
LogFileWriter() = default;
/**
* @brief Opens a LogFile with file_name. Returns true if this is successful, otherwise it returns false.
*/
bool open(const std::string& file_name);
/**
* @brief If a file is open, closes it.
*/
void close();
/**
* @brief Adds a single message at the end of the LogFile.
* Returns true if done so succesfully.The given timestamp is checked: it must be the same or increasing!
*/
bool addMessage(const logged_proto_type& message, logged_time_type timestamp);
private:
std::unique_ptr<std::ofstream> file;
logged_time_type last_written_timestamp = 0;
std::vector<char> serialization_buffer;
};
}
#endif //RTT_LOGFILEWRITER_H
| [
"[email protected]"
] | |
2786965a6b96be80479e1d70ce614a6ac2fa79e1 | 74f50032f2f0ebe0881133bc4933bf3a87c49b12 | /CSC_342_COMPUTER ORG/CSC 342Computer Organization/Class_reports/codeOptimization/codeoptimization/codeoptimization/main.cpp | 3d8b78e920faf684888363985a20539caf228c25 | [] | no_license | MohamedSondo/SPRING_2017 | 7034e0df529f695255fdd5eb257f59df72c35fb3 | b114264083f66476093923640aa4eb9471919e9f | refs/heads/master | 2021-08-07T20:01:49.401425 | 2017-11-08T20:56:55 | 2017-11-08T20:56:55 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,074 | cpp | #include <tchar.h>
#include <windows.h>
#include <iostream>
void ClearUsingIndex(int Array[], int size);
int main() {
__int64 ctr1 = 0, ctr2 = 0, freq = 0;
int acc = 0, i = 0;
const int size = 100000;
int Array[size];
for (int i = 0; i < size; i++) {
Array[i] = i;
}
// Start timing the code.
if (QueryPerformanceCounter((LARGE_INTEGER *)&ctr1) != 0)
{
// Code segment is being timed.
ClearUsingIndex(Array, size);
// Finish timing the code.
QueryPerformanceCounter((LARGE_INTEGER *)&ctr2);
std::cout << "start" << ctr1 << std::endl;
std::cout << "end" << ctr2 << std::endl;
QueryPerformanceFrequency((LARGE_INTEGER *)&freq);
std::cout << "QueryPerformanceCounter minimum resolution : 1/ " << freq << "seconds" << std::endl;
std::cout << "time took to clean Array of : " << size<< " elements : "<< ((ctr2 - ctr1) * 1.0 / freq) * 1000000 << " Microseconds." << std::endl;
}
else
{
DWORD dwError = GetLastError();
std::cout << "Error vaflue = " << dwError << std::endl;
}
system("PAUSE");
return 0;
} | [
"[email protected]"
] | |
a7f07647d8b67cb3402246b0a7fb5e4b77f3b19a | 7f0a62a83f7febf8cfd595889cb1c8d3bd42bed7 | /opencv/modules/ml/opencv_test_ml_pch_dephelp.cxx | e357e8a36fbaa8e6a22b4dff50360d1252ca21ca | [] | no_license | dharmikthakkar/ECEN-5623_RTES | fbca94734ab3ef47536e390826d5e1ba9d5f226e | 257f7a7a85c65fdaa937b277c4027e063400a695 | refs/heads/master | 2020-05-27T21:25:00.382773 | 2017-04-05T06:54:38 | 2017-04-05T06:54:38 | 83,684,702 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 129 | cxx | #include "/var/www/yoda/opencv/opencv/modules/ml/test/test_precomp.hpp"
int testfunction();
int testfunction()
{
return 0;
}
| [
"[email protected]"
] | |
817220020027bd277327aef854dffa2a588ed876 | 359c06dcb6e5e924f3ccde80724dbb7631df9762 | /src/base58.h | 3b4ae255fa03a014e01b27c7eedee9162bd837c2 | [
"MIT"
] | permissive | CryptoHelp/kashmircoin | 7997dad8d63f298ee1b6c5a293b6cff01256579c | 2b794562c9a3dea373e3199f614b6af34193030a | refs/heads/master | 2021-01-18T06:44:59.958422 | 2014-12-05T18:52:41 | 2014-12-05T18:52:41 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 13,067 | h | // Copyright (c) 2009-2010 Satoshi Nakamoto
// Copyright (c) 2009-2012 The Bitcoin Developers
// Distributed under the MIT/X11 software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
//
// Why base-58 instead of standard base-64 encoding?
// - Don't want 0OIl characters that look the same in some fonts and
// could be used to create visually identical looking account numbers.
// - A string with non-alphanumeric characters is not as easily accepted as an account number.
// - E-mail usually won't line-break if there's no punctuation to break at.
// - Double-clicking selects the whole number as one word if it's all alphanumeric.
//
#ifndef BITCOIN_BASE58_H
#define BITCOIN_BASE58_H
#include <string>
#include <vector>
#include "bignum.h"
#include "key.h"
#include "script.h"
static const char* pszBase58 = "123456789ABCDEFGHJKLMNPQRSTUVWXYZabcdefghijkmnopqrstuvwxyz";
// Encode a byte sequence as a base58-encoded string
inline std::string EncodeBase58(const unsigned char* pbegin, const unsigned char* pend)
{
CAutoBN_CTX pctx;
CBigNum bn58 = 58;
CBigNum bn0 = 0;
// Convert big endian data to little endian
// Extra zero at the end make sure bignum will interpret as a positive number
std::vector<unsigned char> vchTmp(pend-pbegin+1, 0);
reverse_copy(pbegin, pend, vchTmp.begin());
// Convert little endian data to bignum
CBigNum bn;
bn.setvch(vchTmp);
// Convert bignum to std::string
std::string str;
// Expected size increase from base58 conversion is approximately 137%
// use 138% to be safe
str.reserve((pend - pbegin) * 138 / 100 + 1);
CBigNum dv;
CBigNum rem;
while (bn > bn0)
{
if (!BN_div(&dv, &rem, &bn, &bn58, pctx))
throw bignum_error("EncodeBase58 : BN_div failed");
bn = dv;
unsigned int c = rem.getulong();
str += pszBase58[c];
}
// Leading zeroes encoded as base58 zeros
for (const unsigned char* p = pbegin; p < pend && *p == 0; p++)
str += pszBase58[0];
// Convert little endian std::string to big endian
reverse(str.begin(), str.end());
return str;
}
// Encode a byte vector as a base58-encoded string
inline std::string EncodeBase58(const std::vector<unsigned char>& vch)
{
return EncodeBase58(&vch[0], &vch[0] + vch.size());
}
// Decode a base58-encoded string psz into byte vector vchRet
// returns true if decoding is successful
inline bool DecodeBase58(const char* psz, std::vector<unsigned char>& vchRet)
{
CAutoBN_CTX pctx;
vchRet.clear();
CBigNum bn58 = 58;
CBigNum bn = 0;
CBigNum bnChar;
while (isspace(*psz))
psz++;
// Convert big endian string to bignum
for (const char* p = psz; *p; p++)
{
const char* p1 = strchr(pszBase58, *p);
if (p1 == NULL)
{
while (isspace(*p))
p++;
if (*p != '\0')
return false;
break;
}
bnChar.setulong(p1 - pszBase58);
if (!BN_mul(&bn, &bn, &bn58, pctx))
throw bignum_error("DecodeBase58 : BN_mul failed");
bn += bnChar;
}
// Get bignum as little endian data
std::vector<unsigned char> vchTmp = bn.getvch();
// Trim off sign byte if present
if (vchTmp.size() >= 2 && vchTmp.end()[-1] == 0 && vchTmp.end()[-2] >= 0x80)
vchTmp.erase(vchTmp.end()-1);
// Restore leading zeros
int nLeadingZeros = 0;
for (const char* p = psz; *p == pszBase58[0]; p++)
nLeadingZeros++;
vchRet.assign(nLeadingZeros + vchTmp.size(), 0);
// Convert little endian data to big endian
reverse_copy(vchTmp.begin(), vchTmp.end(), vchRet.end() - vchTmp.size());
return true;
}
// Decode a base58-encoded string str into byte vector vchRet
// returns true if decoding is successful
inline bool DecodeBase58(const std::string& str, std::vector<unsigned char>& vchRet)
{
return DecodeBase58(str.c_str(), vchRet);
}
// Encode a byte vector to a base58-encoded string, including checksum
inline std::string EncodeBase58Check(const std::vector<unsigned char>& vchIn)
{
// add 4-byte hash check to the end
std::vector<unsigned char> vch(vchIn);
uint256 hash = Hash(vch.begin(), vch.end());
vch.insert(vch.end(), (unsigned char*)&hash, (unsigned char*)&hash + 4);
return EncodeBase58(vch);
}
// Decode a base58-encoded string psz that includes a checksum, into byte vector vchRet
// returns true if decoding is successful
inline bool DecodeBase58Check(const char* psz, std::vector<unsigned char>& vchRet)
{
if (!DecodeBase58(psz, vchRet))
return false;
if (vchRet.size() < 4)
{
vchRet.clear();
return false;
}
uint256 hash = Hash(vchRet.begin(), vchRet.end()-4);
if (memcmp(&hash, &vchRet.end()[-4], 4) != 0)
{
vchRet.clear();
return false;
}
vchRet.resize(vchRet.size()-4);
return true;
}
// Decode a base58-encoded string str that includes a checksum, into byte vector vchRet
// returns true if decoding is successful
inline bool DecodeBase58Check(const std::string& str, std::vector<unsigned char>& vchRet)
{
return DecodeBase58Check(str.c_str(), vchRet);
}
/** Base class for all base58-encoded data */
class CBase58Data
{
protected:
// the version byte
unsigned char nVersion;
// the actually encoded data
std::vector<unsigned char> vchData;
CBase58Data()
{
nVersion = 0;
vchData.clear();
}
~CBase58Data()
{
// zero the memory, as it may contain sensitive data
if (!vchData.empty())
memset(&vchData[0], 0, vchData.size());
}
void SetData(int nVersionIn, const void* pdata, size_t nSize)
{
nVersion = nVersionIn;
vchData.resize(nSize);
if (!vchData.empty())
memcpy(&vchData[0], pdata, nSize);
}
void SetData(int nVersionIn, const unsigned char *pbegin, const unsigned char *pend)
{
SetData(nVersionIn, (void*)pbegin, pend - pbegin);
}
public:
bool SetString(const char* psz)
{
std::vector<unsigned char> vchTemp;
DecodeBase58Check(psz, vchTemp);
if (vchTemp.empty())
{
vchData.clear();
nVersion = 0;
return false;
}
nVersion = vchTemp[0];
vchData.resize(vchTemp.size() - 1);
if (!vchData.empty())
memcpy(&vchData[0], &vchTemp[1], vchData.size());
memset(&vchTemp[0], 0, vchTemp.size());
return true;
}
bool SetString(const std::string& str)
{
return SetString(str.c_str());
}
std::string ToString() const
{
std::vector<unsigned char> vch(1, nVersion);
vch.insert(vch.end(), vchData.begin(), vchData.end());
return EncodeBase58Check(vch);
}
int CompareTo(const CBase58Data& b58) const
{
if (nVersion < b58.nVersion) return -1;
if (nVersion > b58.nVersion) return 1;
if (vchData < b58.vchData) return -1;
if (vchData > b58.vchData) return 1;
return 0;
}
bool operator==(const CBase58Data& b58) const { return CompareTo(b58) == 0; }
bool operator<=(const CBase58Data& b58) const { return CompareTo(b58) <= 0; }
bool operator>=(const CBase58Data& b58) const { return CompareTo(b58) >= 0; }
bool operator< (const CBase58Data& b58) const { return CompareTo(b58) < 0; }
bool operator> (const CBase58Data& b58) const { return CompareTo(b58) > 0; }
};
/** base58-encoded addresses.
* Public-key-hash-addresses have version 25 (or 111 testnet).
* The data vector contains RIPEMD160(SHA256(pubkey)), where pubkey is the serialized public key.
* Script-hash-addresses have version 85 (or 196 testnet).
* The data vector contains RIPEMD160(SHA256(cscript)), where cscript is the serialized redemption script.
*/
class CBitcoinAddress;
class CBitcoinAddressVisitor : public boost::static_visitor<bool>
{
private:
CBitcoinAddress *addr;
public:
CBitcoinAddressVisitor(CBitcoinAddress *addrIn) : addr(addrIn) { }
bool operator()(const CKeyID &id) const;
bool operator()(const CScriptID &id) const;
bool operator()(const CNoDestination &no) const;
};
class CBitcoinAddress : public CBase58Data
{
public:
enum
{
PUBKEY_ADDRESS = 46,
SCRIPT_ADDRESS = 5,
PUBKEY_ADDRESS_TEST = 111,
SCRIPT_ADDRESS_TEST = 196,
};
bool Set(const CKeyID &id) {
SetData(fTestNet ? PUBKEY_ADDRESS_TEST : PUBKEY_ADDRESS, &id, 20);
return true;
}
bool Set(const CScriptID &id) {
SetData(fTestNet ? SCRIPT_ADDRESS_TEST : SCRIPT_ADDRESS, &id, 20);
return true;
}
bool Set(const CTxDestination &dest)
{
return boost::apply_visitor(CBitcoinAddressVisitor(this), dest);
}
bool IsValid() const
{
unsigned int nExpectedSize = 20;
bool fExpectTestNet = false;
switch(nVersion)
{
case PUBKEY_ADDRESS:
nExpectedSize = 20; // Hash of public key
fExpectTestNet = false;
break;
case SCRIPT_ADDRESS:
nExpectedSize = 20; // Hash of CScript
fExpectTestNet = false;
break;
case PUBKEY_ADDRESS_TEST:
nExpectedSize = 20;
fExpectTestNet = true;
break;
case SCRIPT_ADDRESS_TEST:
nExpectedSize = 20;
fExpectTestNet = true;
break;
default:
return false;
}
return fExpectTestNet == fTestNet && vchData.size() == nExpectedSize;
}
CBitcoinAddress()
{
}
CBitcoinAddress(const CTxDestination &dest)
{
Set(dest);
}
CBitcoinAddress(const std::string& strAddress)
{
SetString(strAddress);
}
CBitcoinAddress(const char* pszAddress)
{
SetString(pszAddress);
}
CTxDestination Get() const {
if (!IsValid())
return CNoDestination();
switch (nVersion) {
case PUBKEY_ADDRESS:
case PUBKEY_ADDRESS_TEST: {
uint160 id;
memcpy(&id, &vchData[0], 20);
return CKeyID(id);
}
case SCRIPT_ADDRESS:
case SCRIPT_ADDRESS_TEST: {
uint160 id;
memcpy(&id, &vchData[0], 20);
return CScriptID(id);
}
}
return CNoDestination();
}
bool GetKeyID(CKeyID &keyID) const {
if (!IsValid())
return false;
switch (nVersion) {
case PUBKEY_ADDRESS:
case PUBKEY_ADDRESS_TEST: {
uint160 id;
memcpy(&id, &vchData[0], 20);
keyID = CKeyID(id);
return true;
}
default: return false;
}
}
bool IsScript() const {
if (!IsValid())
return false;
switch (nVersion) {
case SCRIPT_ADDRESS:
case SCRIPT_ADDRESS_TEST: {
return true;
}
default: return false;
}
}
};
bool inline CBitcoinAddressVisitor::operator()(const CKeyID &id) const { return addr->Set(id); }
bool inline CBitcoinAddressVisitor::operator()(const CScriptID &id) const { return addr->Set(id); }
bool inline CBitcoinAddressVisitor::operator()(const CNoDestination &id) const { return false; }
/** A base58-encoded secret key */
class CBitcoinSecret : public CBase58Data
{
public:
void SetSecret(const CSecret& vchSecret, bool fCompressed)
{
assert(vchSecret.size() == 32);
SetData(128 + (fTestNet ? CBitcoinAddress::PUBKEY_ADDRESS_TEST : CBitcoinAddress::PUBKEY_ADDRESS), &vchSecret[0], vchSecret.size());
if (fCompressed)
vchData.push_back(1);
}
CSecret GetSecret(bool &fCompressedOut)
{
CSecret vchSecret;
vchSecret.resize(32);
memcpy(&vchSecret[0], &vchData[0], 32);
fCompressedOut = vchData.size() == 33;
return vchSecret;
}
bool IsValid() const
{
bool fExpectTestNet = false;
switch(nVersion)
{
case (128 + CBitcoinAddress::PUBKEY_ADDRESS):
break;
case (128 + CBitcoinAddress::PUBKEY_ADDRESS_TEST):
fExpectTestNet = true;
break;
default:
return false;
}
return fExpectTestNet == fTestNet && (vchData.size() == 32 || (vchData.size() == 33 && vchData[32] == 1));
}
bool SetString(const char* pszSecret)
{
return CBase58Data::SetString(pszSecret) && IsValid();
}
bool SetString(const std::string& strSecret)
{
return SetString(strSecret.c_str());
}
CBitcoinSecret(const CSecret& vchSecret, bool fCompressed)
{
SetSecret(vchSecret, fCompressed);
}
CBitcoinSecret()
{
}
};
#endif
| [
"[email protected]"
] | |
fb8d8a3fba31534dcadf77b608a282ea9fb2db5f | cba674f10550c6a65cf73cc71f7bbdc27d7e5e34 | /Source/Urho3D/Audio/SoundSource.h | d917780f3cc45c05170fbcd5fcbe521d47a3fda1 | [
"LicenseRef-scancode-unknown-license-reference",
"MIT"
] | permissive | elix22/Urho3D-1 | 1641fea4c855b599b2efa36cae9c249e1c507fc8 | 955ea6212defd1f0515c1bffa89a4114b63af3cd | refs/heads/master | 2021-06-25T00:57:28.436933 | 2020-11-25T13:53:52 | 2020-11-25T13:53:52 | 148,736,020 | 0 | 2 | MIT | 2020-11-25T13:53:53 | 2018-09-14T04:32:49 | C++ | UTF-8 | C++ | false | false | 8,090 | h | //
// Copyright (c) 2008-2020 the Urho3D project.
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to deal
// in the Software without restriction, including without limitation the rights
// to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
// copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
// OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
// THE SOFTWARE.
//
#pragma once
#include "../Audio/AudioDefs.h"
#include "../Scene/Component.h"
namespace Urho3D
{
class Audio;
class Sound;
class SoundStream;
/// Compressed audio decode buffer length in milliseconds.
static const int STREAM_BUFFER_LENGTH = 100;
/// %Sound source component with stereo position. A sound source needs to be created to a node to be considered "enabled" and be able to play, however that node does not need to belong to a scene.
class URHO3D_API SoundSource : public Component
{
URHO3D_OBJECT(SoundSource, Component);
public:
/// Construct.
explicit SoundSource(Context* context);
/// Destruct. Remove self from the audio subsystem.
~SoundSource() override;
/// Register object factory.
static void RegisterObject(Context* context);
/// Seek to time.
void Seek(float seekTime);
/// Play a sound.
void Play(Sound* sound);
/// Play a sound with specified frequency.
void Play(Sound* sound, float frequency);
/// Play a sound with specified frequency and gain.
void Play(Sound* sound, float frequency, float gain);
/// Play a sound with specified frequency, gain and panning.
void Play(Sound* sound, float frequency, float gain, float panning);
/// Start playing a sound stream.
void Play(SoundStream* stream);
/// Stop playback.
void Stop();
/// Set sound type, determines the master gain group.
/// @property
void SetSoundType(const ea::string& type);
/// Set frequency.
/// @property
void SetFrequency(float frequency);
/// Set gain. 0.0 is silence, 1.0 is full volume.
/// @property
void SetGain(float gain);
/// Set attenuation. 1.0 is unaltered. Used for distance attenuated playback.
void SetAttenuation(float attenuation);
/// Set stereo panning. -1.0 is full left and 1.0 is full right.
/// @property
void SetPanning(float panning);
/// Set to remove either the sound source component or its owner node from the scene automatically on sound playback completion. Disabled by default.
/// @property
void SetAutoRemoveMode(AutoRemoveMode mode);
/// Set new playback position.
void SetPlayPosition(signed char* pos);
/// Return sound.
/// @property
Sound* GetSound() const { return sound_; }
/// Return playback position.
volatile signed char* GetPlayPosition() const { return position_; }
/// Return sound type, determines the master gain group.
/// @property
ea::string GetSoundType() const { return soundType_; }
/// Return playback time position.
/// @property
float GetTimePosition() const { return timePosition_; }
/// Return frequency.
/// @property
float GetFrequency() const { return frequency_; }
/// Return gain.
/// @property
float GetGain() const { return gain_; }
/// Return attenuation.
/// @property
float GetAttenuation() const { return attenuation_; }
/// Return stereo panning.
/// @property
float GetPanning() const { return panning_; }
/// Return automatic removal mode on sound playback completion.
/// @property
AutoRemoveMode GetAutoRemoveMode() const { return autoRemove_; }
/// Return whether is playing.
/// @property
bool IsPlaying() const;
/// Update the sound source. Perform subclass specific operations. Called by Audio.
virtual void Update(float timeStep);
/// Mix sound source output to a 32-bit clipping buffer. Called by Audio.
void Mix(int dest[], unsigned samples, int mixRate, bool stereo, bool interpolation);
/// Update the effective master gain. Called internally and by Audio when the master gain changes.
void UpdateMasterGain();
/// Set sound attribute.
void SetSoundAttr(const ResourceRef& value);
/// Set sound position attribute.
void SetPositionAttr(int value);
/// Return sound attribute.
ResourceRef GetSoundAttr() const;
/// Set sound playing attribute.
void SetPlayingAttr(bool value);
/// Return sound position attribute.
int GetPositionAttr() const;
protected:
/// Audio subsystem.
WeakPtr<Audio> audio_;
/// SoundSource type, determines the master gain group.
ea::string soundType_;
/// SoundSource type hash.
StringHash soundTypeHash_;
/// Frequency.
float frequency_;
/// Gain.
float gain_;
/// Attenuation.
float attenuation_;
/// Stereo panning.
float panning_;
/// Effective master gain.
float masterGain_{};
/// Whether finished event should be sent on playback stop.
bool sendFinishedEvent_;
/// Automatic removal mode.
AutoRemoveMode autoRemove_;
private:
/// Play a sound without locking the audio mutex. Called internally.
void PlayLockless(Sound* sound);
/// Play a sound stream without locking the audio mutex. Called internally.
void PlayLockless(const SharedPtr<SoundStream>& stream);
/// Stop sound without locking the audio mutex. Called internally.
void StopLockless();
/// Set new playback position without locking the audio mutex. Called internally.
void SetPlayPositionLockless(signed char* pos);
/// Mix mono sample to mono buffer.
void MixMonoToMono(Sound* sound, int dest[], unsigned samples, int mixRate);
/// Mix mono sample to stereo buffer.
void MixMonoToStereo(Sound* sound, int dest[], unsigned samples, int mixRate);
/// Mix mono sample to mono buffer interpolated.
void MixMonoToMonoIP(Sound* sound, int dest[], unsigned samples, int mixRate);
/// Mix mono sample to stereo buffer interpolated.
void MixMonoToStereoIP(Sound* sound, int dest[], unsigned samples, int mixRate);
/// Mix stereo sample to mono buffer.
void MixStereoToMono(Sound* sound, int dest[], unsigned samples, int mixRate);
/// Mix stereo sample to stereo buffer.
void MixStereoToStereo(Sound* sound, int dest[], unsigned samples, int mixRate);
/// Mix stereo sample to mono buffer interpolated.
void MixStereoToMonoIP(Sound* sound, int dest[], unsigned samples, int mixRate);
/// Mix stereo sample to stereo buffer interpolated.
void MixStereoToStereoIP(Sound* sound, int dest[], unsigned samples, int mixRate);
/// Advance playback pointer without producing audible output.
void MixZeroVolume(Sound* sound, unsigned samples, int mixRate);
/// Advance playback pointer to simulate audio playback in headless mode.
void MixNull(float timeStep);
/// Sound that is being played.
SharedPtr<Sound> sound_;
/// Sound stream that is being played.
SharedPtr<SoundStream> soundStream_;
/// Playback position.
volatile signed char* position_;
/// Playback fractional position.
volatile int fractPosition_;
/// Playback time position.
volatile float timePosition_;
/// Decode buffer.
SharedPtr<Sound> streamBuffer_;
/// Unused stream bytes from previous frame.
int unusedStreamSize_;
};
}
| [
"[email protected]"
] | |
c9bd42152cddf3a3348b1673470130020856edc0 | 021df2f4ed5796796aeda5a4323f23f9bf1a897e | /imaging/imagingplugins/codecs/ColorConverter.cpp | 53315791f20ebfc47e9c26403204c6ce3d730a75 | [] | no_license | SymbianSource/oss.FCL.sf.os.mmimaging | 5f484b77a8f77fd9d9496512bc0e62743793168e | dcc68da0bf7c10c664c864262d3213b5b30124c9 | refs/heads/master | 2021-01-12T11:16:03.475384 | 2010-10-22T05:01:17 | 2010-10-22T05:01:17 | 72,886,075 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 6,761 | cpp | // Copyright (c) 1999-2009 Nokia Corporation and/or its subsidiary(-ies).
// All rights reserved.
// This component and the accompanying materials are made available
// under the terms of "Eclipse Public License v1.0"
// which accompanies this distribution, and is available
// at the URL "http://www.eclipse.org/legal/epl-v10.html".
//
// Initial Contributors:
// Nokia Corporation - initial contribution.
//
// Contributors:
//
// Description:
//
#include <icl/imageprocessor.h>
_LIT(KBitmapUtilPanicCategory, "TImageBitmapUtil");
GLDEF_C void Panic(TImageBitmapUtilPanic aError)
{
User::Panic(KBitmapUtilPanicCategory, aError);
}
/**
@see TColorConvertor.
*/
class TGray2Convertor : public TColorConvertor
{
public:
virtual TInt ColorIndex(TRgb aColor) const { return RgbToMonochrome(aColor)>>7; }
virtual TRgb Color(TInt aColorIndex) const { return TRgb::Gray2(aColorIndex); }
virtual void ColorToIndex(TInt* aIndexBuffer,TRgb* aColorBuffer,TInt aCount) const
{
TInt* end = aIndexBuffer+aCount;
while(aIndexBuffer<end)
*(aIndexBuffer++) = RgbToMonochrome(*(aColorBuffer++))>>7;
}
};
/**
@see TColorConvertor.
*/
class TGray4Convertor : public TColorConvertor
{
public:
virtual TInt ColorIndex(TRgb aColor) const { return RgbToMonochrome(aColor)>>6; }
virtual TRgb Color(TInt aColorIndex) const { return TRgb::Gray4(aColorIndex); }
virtual void ColorToIndex(TInt* aIndexBuffer,TRgb* aColorBuffer,TInt aCount) const
{
TInt* end = aIndexBuffer+aCount;
while(aIndexBuffer<end)
*(aIndexBuffer++) = RgbToMonochrome(*(aColorBuffer++))>>6;
}
};
/**
@see TColorConvertor.
*/
class TGray16Convertor : public TColorConvertor
{
public:
virtual TInt ColorIndex(TRgb aColor) const { return RgbToMonochrome(aColor)>>4; }
virtual TRgb Color(TInt aColorIndex) const { return TRgb::Gray16(aColorIndex); }
virtual void ColorToIndex(TInt* aIndexBuffer,TRgb* aColorBuffer,TInt aCount) const
{
TInt* end = aIndexBuffer+aCount;
while(aIndexBuffer<end)
*(aIndexBuffer++) = RgbToMonochrome(*(aColorBuffer++))>>4;
}
};
/**
@see TColorConvertor.
*/
class TGray256Convertor : public TColorConvertor
{
public:
virtual TInt ColorIndex(TRgb aColor) const { return RgbToMonochrome(aColor); }
virtual TRgb Color(TInt aColorIndex) const { return TRgb::Gray256(aColorIndex); }
virtual void ColorToIndex(TInt* aIndexBuffer,TRgb* aColorBuffer,TInt aCount) const
{
TInt* end = aIndexBuffer+aCount;
while(aIndexBuffer<end)
*(aIndexBuffer++) = RgbToMonochrome(*(aColorBuffer++));
}
};
/**
@see TColorConvertor.
*/
class TColor16Convertor : public TColorConvertor
{
public:
virtual TInt ColorIndex(TRgb aColor) const { return aColor.Color16(); }
virtual TRgb Color(TInt aColorIndex) const { return TRgb::Color16(aColorIndex); }
virtual void ColorToIndex(TInt* aIndexBuffer,TRgb* aColorBuffer,TInt aCount) const
{
TInt* end = aIndexBuffer+aCount;
while(aIndexBuffer<end)
{
*(aIndexBuffer++) = (aColorBuffer++)->Color16();
}
}
};
/**
@see TColorConvertor.
*/
class TColor256Convertor : public TColorConvertor
{
public:
virtual TInt ColorIndex(TRgb aColor) const { return aColor.Color256(); }
virtual TRgb Color(TInt aColorIndex) const { return TRgb::Color256(aColorIndex); }
virtual void ColorToIndex(TInt* aIndexBuffer,TRgb* aColorBuffer,TInt aCount) const
{
TInt* end = aIndexBuffer+aCount;
while(aIndexBuffer<end)
*(aIndexBuffer++) = (aColorBuffer++)->Color256();
}
};
/**
@see TColorConvertor.
*/
class TColor4KConvertor : public TColorConvertor
{
public:
virtual TInt ColorIndex(TRgb aColor) const { return aColor._Color4K(); }
virtual TRgb Color(TInt aColorIndex) const { return TRgb::Color4K(aColorIndex); }
virtual void ColorToIndex(TInt* aIndexBuffer,TRgb* aColorBuffer,TInt aCount) const
{
TInt* end = aIndexBuffer+aCount;
while(aIndexBuffer<end)
{
*(aIndexBuffer++) = (aColorBuffer++)->_Color4K();
}
}
};
/**
@see TColorConvertor.
*/
class TColor64KConvertor : public TColorConvertor
{
public:
virtual TInt ColorIndex(TRgb aColor) const { return aColor._Color64K(); }
virtual TRgb Color(TInt aColorIndex) const { return TRgb::Color64K(aColorIndex); }
virtual void ColorToIndex(TInt* aIndexBuffer,TRgb* aColorBuffer,TInt aCount) const
{
TInt* end = aIndexBuffer+aCount;
while(aIndexBuffer<end)
{
*(aIndexBuffer++) = (aColorBuffer++)->_Color64K();
}
}
};
/**
@see TColorConvertor.
*/
class TColor16MConvertor : public TColorConvertor
{
public:
virtual TInt ColorIndex(TRgb aColor) const { return aColor.Internal(); }
virtual TRgb Color(TInt aColorIndex) const { return TRgb::Color16M(aColorIndex); }
virtual void ColorToIndex(TInt* aIndexBuffer,TRgb* aColorBuffer,TInt aCount) const
{
Mem::Copy(aIndexBuffer,aColorBuffer,aCount*sizeof(TRgb));
}
};
/**
@see TColorConvertor.
*/
class TColor16MUConvertor : public TColorConvertor
{
public:
virtual TInt ColorIndex(TRgb aColor) const { return aColor._Color16MU(); }
virtual TRgb Color(TInt aColorIndex) const { return TRgb::Color16MU(aColorIndex); }
virtual void ColorToIndex(TInt* aIndexBuffer,TRgb* aColorBuffer,TInt aCount) const
{
// do a Mem::Copy as this ensures that top byte (which
// in a 16MA context is interpreted as the alpha value)
// is 0xFF (opaque) instead of 0x00 (transparent)
Mem::Copy(aIndexBuffer,aColorBuffer,aCount*sizeof(TRgb));
}
};
/**
@see TColorConvertor.
*/
class TColor16MAConvertor : public TColorConvertor
{
public:
virtual TInt ColorIndex(TRgb aColor) const { return aColor._Color16MA(); }
virtual TRgb Color(TInt aColorIndex) const { return TRgb::Color16MA(aColorIndex); }
virtual void ColorToIndex(TInt* aIndexBuffer,TRgb* aColorBuffer,TInt aCount) const
{
Mem::Copy(aIndexBuffer,aColorBuffer,aCount*sizeof(TRgb));
}
};
TColorConvertor* CreateColorConvertorL(TDisplayMode aDisplayMode)
{
switch (aDisplayMode)
{
case EGray2: return new(ELeave) TGray2Convertor;
case EGray4: return new(ELeave) TGray4Convertor;
case EGray16: return new(ELeave) TGray16Convertor;
case EGray256: return new(ELeave) TGray256Convertor;
case EColor16: return new(ELeave) TColor16Convertor;
case EColor256: return new(ELeave) TColor256Convertor;
case EColor4K: return new(ELeave) TColor4KConvertor;
case EColor64K: return new(ELeave) TColor64KConvertor;
case EColor16M: return new(ELeave) TColor16MConvertor;
case EColor16MU: return new(ELeave) TColor16MUConvertor;
case EColor16MA: return new(ELeave) TColor16MAConvertor;
default:
User::Leave(KErrNotSupported);
return NULL; //Keep the compiler happy!!
};
}
| [
"[email protected]"
] | |
a493a9c09bb116a3ba4002aef8eb6ab13367b8c9 | 2489f20116dfa10e4514b636cbf92a6036edc21a | /tojcode/3126.cpp | 7b0185b8943766d9ee9f701d2d072d13fb536d69 | [] | no_license | menguan/toj_code | 7db20eaffce976932a3bc8880287f0111a621a40 | f41bd77ee333c58d5fcb26d1848a101c311d1790 | refs/heads/master | 2020-03-25T04:08:41.881068 | 2018-08-03T05:02:38 | 2018-08-03T05:02:38 | 143,379,558 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 886 | cpp | #include<iostream>//照打
#include<algorithm>
#include<cstdio>
using namespace std;
const long long int inf=10000000000000;
const int maxn=10002;
const int maxm=5000000;
int t,l,ll;
long long d[maxn],s[maxm],a,b;
void dfs(long long p,int step)
{
if(step>12) return;
d[l++]=p*10+4;
d[l++]=p*10+7;
dfs(p*10+4,step+1);
dfs(p*10+7,step+1);
}
void dfs1(long long p,int step)
{
if(step>=l)return;
if(d[step]>inf/p) return;
dfs1(p,step+1);
while(d[step]<=inf/p)
{
p*=d[step];
s[ll++]=p;
dfs1(p,step+1);
}
}
int main()
{
l=0,s[ll=1]=0;
dfs(0,1);
sort(d,d+l);
dfs1(1,0);
sort(s,s+ll);
int len=unique(s,s+ll)-s;
cin>>t;
while(t--)
{
cin>>a>>b;
int id1=upper_bound(s,s+len,a-1)-s;
int id2=upper_bound(s,s+len,b)-s;
cout<<id2-id1<<endl;
}
return 0;
}
| [
"[email protected]"
] | |
0dad46c05def0c2ecdd3cebce238e3705427d010 | ba100778b4fdd9459cb2d80c2d0179ddbb41f588 | /test/p5.cpp | 3158e6e6fabcd003d4974ae9c716352d71f036da | [] | no_license | itsukis/algo | 4df8a2da1f5474815479fb484339153830150383 | c12895f5f2023b5f5c265970fe547531931dcaa8 | refs/heads/master | 2020-04-16T16:12:22.259453 | 2016-08-18T04:46:12 | 2016-08-18T04:46:12 | 31,960,696 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,263 | cpp | #include <iostream>
#include <queue>
using namespace std;
// Open
int reachToW(char map[50][50], int i, int j, int M, int N)
{
char map2[50][50];
int ret = 0;
if (i == 0 || i == N-1) return 1;
if (j == 0 || j == M-1) return 1;
if (map[i][j] == '1' || map[i][j] == '2') return 0;
memcpy(map2, map, 50*50*sizeof(char));
map2[i][j] = '2';
// UP
if (map2[i-1][j] == '0') {
if (reachToW(map2, i-1, j, M, N))
return 1;
}
// DOWN
if (map2[i+1][j] == '0') {
if (reachToW(map2, i+1, j, M, N))
return 1;
}
// LEFT
if (map2[i][j-1] == '0') {
if (reachToW(map2, i, j-1, M, N))
return 1;
}
// RIGHT
if (map2[i][j+1] == '0') {
if (reachToW(map2, i, j+1, M, N))
return 1;
}
return ret;
}
int melt(char map[50][50], int nSnow, int M, int N)
{
int count = 0;
while (nSnow > 0) {
for (int i = 0 ; i < N ; i++) {
for (int j = 0 ; j < M ; j++) {
if (map[i][j] == '1') {
int flag = 0;
//cout << i << " " << j << " = " << map[i][j] << endl;
if ((i == 0) || (map[i-1][j] == '0')) {
if (reachToW(map, i-1, j, N, M))
flag++;
}
if ((i == N-1) || (map[i+1][j] == '0')) {
if (reachToW(map, i+1, j, N, M))
flag++;
}
if ((j == 0) || (map[i][j-1] == '0')) {
if (reachToW(map, i, j-1, N, M))
flag++;
}
if ((j == M-1) || (map[i][j+1] == '0')) {
if (reachToW(map, i, j+1, N, M))
flag++;
}
if (flag >= 2) {
map[i][j] = '2'; // Check to clear
nSnow--;
}
}
}
}
// Clear
for (int i = 0 ; i < N ; i++)
for (int j = 0 ; j < M ; j++)
if (map[i][j] == '2')
map[i][j] = '0';
count++;
}
return count;
}
int car(char map[50][50], int M, int N)
{
return 0;
}
void solve()
{
int M, N;
char map[50][50];
int nSnow = 0;
cin >> M >> N;
for (int i = 0 ; i < N ; i++) {
for (int j = 0 ; j < M ; j++) {
cin >> map[i][j];
if (map[i][j] == '1')
nSnow++;
}
}
cout << melt(map, nSnow, M, N) << " " << car(map, M, N) << endl;
return;
}
int main(void)
{
int t;
cin >> t;
while(t--) solve();
return 0;
} | [
"[email protected]"
] | |
d0351e7488970cc7268d6f8b47daec9aa3d0d88d | b983d323bd5765a6346eb65bb0a68ba52acfa112 | /pre_ecc_test/sourcefile/hash.cpp | 1f4a53297af7142af6dcd1875e7f16dcb55edf91 | [] | no_license | zwdong1994/ECC_Pretest | db0ffc857709c75925c2a4ec0cec6b52a4e7f0a3 | 0f9e97e41aea6212d2e3c798019c952e47e63d65 | refs/heads/master | 2021-01-19T21:05:26.492881 | 2017-05-12T08:02:13 | 2017-05-12T08:02:13 | 88,602,641 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 8,411 | cpp | // Created by victor on 4/5/17.
//
#include <iostream>
#include <stdio.h>
#include <stdlib.h>
#include <sys/types.h>
#include <sys/stat.h>
#include <fcntl.h>
#include <errno.h>
#include <time.h>
#include <sys/time.h>
#include <string.h>
#include <unistd.h>
#include <aio.h>
#include "hash.h"
#include "com_t.h"
hash::hash() {
chunk_num = 0;
time_total = 0.0;
time_aver = 0.0;
chunk_not_dup = 0;
}
hash::~hash() {
if(time_total > 0) {
time_aver = time_total / chunk_num;
std::cout <<std::endl<< "**************************"<<"This option's time performance***********************"<<std::endl;
std::cout << "The total time is " << time_total <<"ms"<< std::endl;
std::cout << "The chunk number is " << chunk_num << std::endl;
if(chunk_not_dup > 0){
std::cout << "The dedupe rate is " << (chunk_num - chunk_not_dup) * 100.0 / chunk_num <<"%"<<std::endl;
std::cout << "The not dedupe chunk number is " << chunk_not_dup << std::endl;
}
std::cout << "The average time is " << time_aver <<"ms"<< std::endl<<std::endl;
}
}
uint8_t hash::ecc_file_comp(char *filename, char *dev_name) {
FILE *fp;
uint8_t chk_cont[4097];
uint64_t another_chk = 0;
struct aiocb64 myaio;
struct aiocb64 *cblist[1];
double stat_time = 0.0, fin_time = 0.0;
cp_t time_cpt;
char file_dir[256];
// double xor1=0.0, xor2=0.0;
int fd = open(dev_name, O_RDWR|O_LARGEFILE);
if(fd==-1) //add by zwd
{
std::cout<<"open "<<dev_name<<" error!"<<std::endl;
exit(0);
}
bzero( (char *)cblist, sizeof(cblist) );
bzero((char *)&myaio,sizeof(struct aiocb64));
myaio.aio_buf=malloc(4097);
if(!myaio.aio_buf)
perror("malloc");
myaio.aio_fildes = fd;
myaio.aio_nbytes = 4096;
myaio.aio_offset = 0;
aio_write64(&myaio);
while (EINPROGRESS == aio_error64(&myaio )) ; //EINPROGRESS represent the request are not complete.
close(fd);
sprintf(file_dir, "/mnt/cdrom/kernel/%s", filename);
if((fp = fopen(file_dir, "r")) == NULL){
std::cout<<"Open file error!The file name is: "<<filename<<std::endl;
return 0;
}
while(!feof(fp)){
memset(chk_cont, 0, READ_LENGTH);
fread(chk_cont, sizeof(char), READ_LENGTH, fp);
/* if(fgets((char *)chk_cont, READ_LENGTH, fp) == NULL ){
// std::cout<<"The file: "<<filename<<" ecc computation is already finished"<<std::endl;
break;
}*/
double elps_time = 0.0;
stat_time = time_cpt.get_time();
//read overhead
// xor1 = time_cpt.get_time();
cblist[0] = &myaio;
aio_read64(&myaio);
aio_suspend64(cblist, 1, NULL);
// xor2 = time_cpt.get_time();
// std::cout<<"xor2 - xor1 = "<<(xor2-xor1)*1000<<std::endl;
//read over
//xor start
for(int i=0; i < 512; i++) {
uint64_t xor_num = 0;
string_convert_uint64(chk_cont + i * 8, &xor_num);
another_chk = another_chk ^ xor_num;
}
//xor finish
fin_time = time_cpt.get_time();
elps_time = (fin_time - stat_time) * 1000;//ms
// std::cout<<"finish - start = "<<elps_time<<std::endl;
time_cpt.cp_all(elps_time);
}
fclose(fp);
time_total += time_cpt.time_total;
chunk_num += time_cpt.chunk_num;
time_cpt.cp_aver(filename);
return 1;
}
uint8_t hash::md5_file_comp(char *filename) {
FILE *fp;
uint8_t chk_cont[4096];
uint8_t hv[17] = {0};
char result[33] = {0};
double stat_time = 0.0, fin_time = 0.0;
std::string mid_str;
cp_t time_cpt;
char file_dir[256];
sprintf(file_dir, "/mnt/cdrom/kernel/%s", filename);
if((fp = fopen(file_dir, "r")) == NULL){
std::cout<<"Open file error!The file name is:"<<filename<<std::endl;
return 0;
}
while(!feof(fp)){
memset(chk_cont, 0, READ_LENGTH);
fread(chk_cont, sizeof(char), READ_LENGTH, fp);
double elps_time = 0.0;
stat_time = time_cpt.get_time();
//md5 func
memset(hv, 0, 17);
md5(chk_cont, 4096, hv);
ByteToHexStr(hv, result, 16);
mid_str = result;
//md5 finish
fin_time = time_cpt.get_time();
elps_time = (fin_time - stat_time) * 1000;//ms
time_cpt.cp_all(elps_time);
if(list.find(mid_str) == list.end()){
chunk_not_dup++;
list.insert(mid_str);
}
}
fclose(fp);
time_cpt.cp_aver(filename);
time_total += time_cpt.time_total;
chunk_num += time_cpt.chunk_num;
return 1;
}
uint8_t hash::sha256_file_comp(char *filename) {
FILE *fp;
uint8_t chk_cont[4097];
sha256_context ctx;
uint8_t hv[33] = {0};
char result[65] = {0};
double stat_time = 0.0, fin_time = 0.0;
std::string mid_str;
cp_t time_cpt;
char file_dir[256];
sprintf(file_dir, "/mnt/cdrom/kernel/%s", filename);
if((fp = fopen(file_dir, "r")) == NULL){
std::cout<<"Open file error!The file name is:"<<file_dir<<std::endl;
return 0;
}
while(!feof(fp)){
memset(chk_cont, 0, READ_LENGTH);
fread(chk_cont, sizeof(char), READ_LENGTH, fp);
double elps_time = 0.0;
stat_time = time_cpt.get_time();
//sha256 func
memset(hv, 0, 33);
sha256_init(&ctx);
sha256_hash(&ctx, chk_cont, (uint32_t)strlen((char *)chk_cont));
sha256_done(&ctx, hv);
ByteToHexStr(hv, result, 32);
mid_str = result;
//sha256 finish
fin_time = time_cpt.get_time();
elps_time = (fin_time - stat_time) * 1000;//ms
time_cpt.cp_all(elps_time);
if(list.find(mid_str) == list.end()){
chunk_not_dup++;
list.insert(mid_str);
}
}
fclose(fp);
time_cpt.cp_aver(filename);
time_total += time_cpt.time_total;
chunk_num += time_cpt.chunk_num;
return 1;
}
uint8_t hash::sha1_file_comp(char *filename) {
FILE *fp;
uint8_t chk_cont[4096];
uint8_t result[21] = {0};
char hex_result[41] = {0};
double stat_time = 0.0, fin_time = 0.0;
std::string mid_str;
cp_t time_cpt;
char file_dir[256];
sprintf(file_dir, "/mnt/cdrom/kernel/%s", filename);
if((fp = fopen(file_dir, "r")) == NULL){
std::cout<<"Open file error!The file name is:"<<file_dir<<std::endl;
return 0;
}
while(!feof(fp)){
memset(chk_cont, 0, READ_LENGTH);
fread(chk_cont, sizeof(char), READ_LENGTH, fp);
double elps_time = 0.0;
stat_time = time_cpt.get_time();
//sha1 func
memset(result, 0, 21);
SHA1((char *)result, (char *)chk_cont, READ_LENGTH);
ByteToHexStr(result, hex_result, 41);
mid_str = hex_result;
//sha1 finish
fin_time = time_cpt.get_time();
elps_time = (fin_time - stat_time) * 1000;//ms
time_cpt.cp_all(elps_time);
if(list.find(mid_str) == list.end()){
chunk_not_dup++;
list.insert(mid_str);
}
}
fclose(fp);
time_cpt.cp_aver(filename);
time_total += time_cpt.time_total;
chunk_num += time_cpt.chunk_num;
return 1;
}
uint8_t hash::string_convert_uint64(uint8_t *content, uint64_t *num) {
uint64_t mid;
mid = (uint64_t)content[0];
*num = *num ^ ((mid<<56)>>56);
mid = (uint64_t)content[1];
*num = *num ^ ((mid<<56)>>48);
mid = (uint64_t)content[2];
*num = *num ^ ((mid<<56)>>40);
mid = (uint64_t)content[3];
*num = *num ^ ((mid<<56)>>32);
mid = (uint64_t)content[4];
*num = *num ^ ((mid<<56)>>24);
mid = (uint64_t)content[5];
*num = *num ^ ((mid<<56)>>16);
mid = (uint64_t)content[6];
*num = *num ^ ((mid<<56)>>8);
mid = (uint64_t)content[7];
*num = *num ^ (mid<<56);
return 1;
}
void hash::ByteToHexStr(const unsigned char *source, char *dest, int sourceLen) {
short i;
unsigned char highByte, lowByte;
for (i = 0; i < sourceLen; i++)
{
highByte = source[i] >> 4;
lowByte = source[i] & 0x0f ;
highByte += 0x30;
if (highByte > 0x39)
dest[i * 2] = highByte + 0x07;
else
dest[i * 2] = highByte;
lowByte += 0x30;
if (lowByte > 0x39)
dest[i * 2 + 1] = lowByte + 0x07;
else
dest[i * 2 + 1] = lowByte;
}
return ;
} | [
"[email protected]"
] | |
66a3ebbdf6ad45b7b0f76b9c0ae6e1f4bcc69701 | bb0878e7e20318c25317f8be5680c3bec4ba0839 | /CA4G.DemoApp/Shaders/Pathtracing/NEEPathtracingTechnique.h | 9ee258080949128536979fe46a17cf2334dc9546 | [
"MIT"
] | permissive | lleonart1984/subsurface_cvae_rendering | 4e8a37cccf241a5719038a9ac4c3ece75baa3c5f | 2b3e305640e106f83ffd4fe5dcf94a0aaad5382b | refs/heads/main | 2023-02-23T12:19:01.628841 | 2021-01-27T09:15:34 | 2021-01-27T09:15:34 | 333,360,992 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 11,014 | h | #pragma once
#include "ca4g.h"
#include "../../GUITraits.h"
using namespace CA4G;
class NEEPathtracingTechnique : public Technique, public IManageScene, public IGatherImageStatistics {
public:
~NEEPathtracingTechnique() {}
struct RTXPathtracing : public RaytracingPipelineBindings {
RTXPathtracing() {}
struct Program : public RTProgram<RTXPathtracing> {
void Setup() {
__set Payload(28);
__set StackSize(1);
__load Shader(Context()->Generating);
__load Shader(Context()->Missing);
__load Shader(Context()->Hitting);
}
void Bindings(gObj<RaytracingBinder> binder) {
binder _set Space(1);
binder _set UAV(0, Context()->OutputImage);
binder _set UAV(1, Context()->Accumulation);
binder _set UAV(2, Context()->SqrAccumulation);
binder _set UAV(3, Context()->Complexity);
binder _set SRV(0, Context()->VertexBuffer);
binder _set SRV(1, Context()->IndexBuffer);
binder _set SRV(2, Context()->Transforms);
binder _set SRV(3, Context()->Materials);
binder _set SRV(4, Context()->VolMaterials);
binder _set SRV_Array(5, Context()->Textures, Context()->TextureCount);
binder _set SMP_Static(0, Sampler::Linear());
binder _set CBV(1, Context()->AccumulativeInfo);
binder _set Space(0);
binder _set ADS(0, Context()->Scene);
binder _set CBV(0, Context()->Lighting);
binder _set CBV(1, Context()->ProjectionToWorld);
}
void HitGroup_Bindings(gObj<RaytracingBinder> binder) {
binder _set Space(1);
binder _set CBV(0, Context()->PerGeometry);
}
};
gObj<Program> MainProgram;
void Setup() {
__load Code(ShaderLoader::FromFile("./Shaders/Pathtracing/NEEPathtracing_RT.cso"));
Generating = __create Shader<RayGenerationHandle>(L"RayGen");
Missing = __create Shader<MissHandle>(L"OnMiss");
auto closestHit = __create Shader<ClosestHitHandle>(L"OnClosestHit");
Hitting = __create HitGroup(closestHit, nullptr, nullptr);
__load Program(MainProgram);
}
gObj<RayGenerationHandle> Generating;
gObj<HitGroupHandle> Hitting;
gObj<MissHandle> Missing;
// Space 1 (CommonRT.h, CommonPT.h)
gObj<Buffer> VertexBuffer;
gObj<Buffer> IndexBuffer;
gObj<Buffer> Transforms;
gObj<Buffer> Materials;
gObj<Buffer> VolMaterials;
gObj<Texture2D>* Textures;
int TextureCount;
gObj<Texture2D> OutputImage;
gObj<Texture2D> Accumulation;
gObj<Texture2D> SqrAccumulation;
gObj<Texture2D> Complexity;
struct PerGeometryInfo {
int StartTriangle;
int VertexOffset;
int TransformIndex;
int MaterialIndex;
} PerGeometry;
struct AccumulativeInfoCB {
int Pass;
int ShowComplexity;
float PathtracingRatio;
} AccumulativeInfo;
// Space 0
gObj<InstanceCollection> Scene;
gObj<Buffer> Lighting;
gObj<Buffer> ProjectionToWorld;
};
gObj<RTXPathtracing> pipeline;
struct LightingCB {
float3 LightPosition;
float rem0;
float3 LightIntensity;
float rem1;
float3 LightDirection;
float rem2;
};
// Used to build bottom level ADS
gObj<Buffer> GeometryTransforms;
void getAccumulators(gObj<Texture2D>& sum, gObj<Texture2D>& sqrSum, int& frames)
{
sum = pipeline->Accumulation;
sqrSum = pipeline->SqrAccumulation;
frames = pipeline->AccumulativeInfo.Pass;
}
// Inherited via Technique
virtual void OnLoad() override {
auto desc = scene->getScene();
pipeline = __create Pipeline<RTXPathtracing>();
GeometryTransforms = __create Buffer_SRV<float4x3>(desc->getTransformsBuffer().Count);
int globalGeometryCount = 0;
for (int i = 0; i < desc->Instances().Count; i++)
globalGeometryCount += desc->Instances().Data[i].Count;
// Allocate Memory for scene elements
pipeline->VertexBuffer = __create Buffer_SRV<SceneVertex>(desc->Vertices().Count);
pipeline->IndexBuffer = __create Buffer_SRV<int>(desc->Indices().Count);
pipeline->Transforms = __create Buffer_SRV<float4x3>(globalGeometryCount);
pipeline->Materials = __create Buffer_SRV<SceneMaterial>(desc->Materials().Count);
pipeline->VolMaterials = __create Buffer_SRV<VolumeMaterial>(desc->Materials().Count);
pipeline->TextureCount = desc->getTextures().Count;
pipeline->Textures = new gObj<Texture2D>[desc->getTextures().Count];
for (int i = 0; i < pipeline->TextureCount; i++)
pipeline->Textures[i] = __create Texture2D_SRV(desc->getTextures().Data[i]);
pipeline->OutputImage = __create Texture2D_UAV<RGBA>(render_target->Width, render_target->Height, 1, 1);
pipeline->Accumulation = __create Texture2D_UAV<float4>(render_target->Width, render_target->Height, 1, 1);
pipeline->SqrAccumulation = __create Texture2D_UAV<float4>(render_target->Width, render_target->Height, 1, 1);
pipeline->Complexity = __create Texture2D_UAV<uint>(render_target->Width, render_target->Height);
pipeline->Lighting = __create Buffer_CB<LightingCB>();
pipeline->ProjectionToWorld = __create Buffer_CB<float4x4>();
pipeline->AccumulativeInfo = {};
__dispatch member_collector(LoadAssets);
__dispatch member_collector(CreateRTXScene);
}
void LoadAssets(gObj<GraphicsManager> manager) {
SceneElement elements = scene->Updated(sceneVersion);
UpdateBuffers(manager, elements);
}
virtual void OnDispatch() override {
// Update dirty elements
__dispatch member_collector(UpdateAssets);
// Draw current Frame
__dispatch member_collector(DrawScene);
}
void UpdateAssets(gObj<RaytracingManager> manager) {
SceneElement elements = scene->Updated(sceneVersion);
UpdateBuffers(manager, elements);
if (+(elements & SceneElement::InstanceTransforms))
UpdateRTXScene(manager);
if (elements != SceneElement::None)
pipeline->AccumulativeInfo.Pass = 0; // restart frame for Pathtracing...
}
void UpdateBuffers(gObj<GraphicsManager> manager, SceneElement elements) {
auto desc = scene->getScene();
if (+(elements & SceneElement::Vertices))
{
pipeline->VertexBuffer _copy FromPtr(desc->Vertices().Data);
manager _load AllToGPU(pipeline->VertexBuffer);
}
if (+(elements & SceneElement::Indices))
{
pipeline->IndexBuffer _copy FromPtr(desc->Indices().Data);
manager _load AllToGPU(pipeline->IndexBuffer);
}
if (+(elements & SceneElement::Materials))
{
pipeline->Materials _copy FromPtr(desc->Materials().Data);
pipeline->VolMaterials _copy FromPtr(desc->VolumeMaterials().Data);
manager _load AllToGPU(pipeline->Materials);
manager _load AllToGPU(pipeline->VolMaterials);
}
if (+(elements & SceneElement::Textures)) {
for (int i = 0; i < pipeline->TextureCount; i++)
manager _load AllToGPU(pipeline->Textures[i]);
}
if (+(elements & SceneElement::Camera))
{
float4x4 proj, view;
scene->getCamera().GetMatrices(render_target->Width, render_target->Height, view, proj);
pipeline->ProjectionToWorld _copy FromValue(mul(inverse(proj), inverse(view)));
manager _load AllToGPU(pipeline->ProjectionToWorld);
}
if (+(elements & SceneElement::Lights))
{
pipeline->Lighting _copy FromValue(LightingCB{
scene->getMainLight().Position, 0,
scene->getMainLight().Intensity, 0,
scene->getMainLight().Direction, 0
});
manager _load AllToGPU(pipeline->Lighting);
}
if (+(elements & SceneElement::GeometryTransforms))
{
GeometryTransforms _copy FromPtr(desc->getTransformsBuffer().Data);
manager _load AllToGPU(GeometryTransforms);
}
if (+(elements & SceneElement::GeometryTransforms) ||
+(elements & SceneElement::InstanceTransforms))
{
int transformIndex = 0;
for (int i = 0; i < desc->Instances().Count; i++)
{
auto instance = desc->Instances().Data[i];
for (int j = 0; j < instance.Count; j++) {
auto geometry = desc->Geometries().Data[instance.GeometryIndices[j]];
float4x4 geometryTransform = geometry.TransformIndex == -1 ?
float4x4(1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1, 0, 0, 0, 0, 1) :
Transforms::FromAffine(desc->getTransformsBuffer().Data[geometry.TransformIndex]);
(pipeline->Transforms _create Slice(transformIndex, 1)) _copy FromValue(
(float4x3)mul(geometryTransform, instance.Transform)
);
transformIndex++;
}
}
manager _load AllToGPU(pipeline->Transforms);
}
}
gObj<InstanceCollection> rtxScene;
void CreateRTXScene(gObj<RaytracingManager> manager) {
auto desc = scene->getScene();
rtxScene = manager _create Intances();
int geometryOffset = 0;
for (int i = 0; i < desc->Instances().Count; i++)
{
auto instance = desc->Instances().Data[i];
auto geometryCollection = manager _create TriangleGeometries();
//geometryCollection _set Transforms(GeometryTransforms);
for (int j = 0; j < instance.Count; j++) // load every geometry
{
auto geometry = desc->Geometries().Data[instance.GeometryIndices[j]];
geometryCollection _create Geometry(
pipeline->VertexBuffer _create Slice(geometry.StartVertex, geometry.VertexCount),
pipeline->IndexBuffer _create Slice(geometry.StartIndex, geometry.IndexCount),
-1);
}
manager _load Geometry(geometryCollection);
rtxScene _create Instance(geometryCollection,
255U, geometryOffset, i, (float4x3)instance.Transform
);
geometryOffset += instance.Count;
}
manager _load Scene(rtxScene);
pipeline->Scene = rtxScene;
}
void UpdateRTXScene(gObj<RaytracingManager> manager) {
auto desc = scene->getScene();
for (int i = 0; i < desc->Instances().Count; i++)
{
auto instance = desc->Instances().Data[i];
rtxScene _load InstanceTransform(i, (float4x3)instance.Transform);
}
manager _load Scene(rtxScene);
}
void DrawScene(gObj<RaytracingManager> manager) {
manager _set Pipeline(pipeline);
manager _set Program(pipeline->MainProgram);
static bool firstTime = true;
if (firstTime) {
manager _set RayGeneration(pipeline->Generating);
manager _set Miss(pipeline->Missing, 0);
auto desc = scene->getScene();
int geometryOffset = 0;
for (int i = 0; i < desc->Instances().Count; i++)
{
auto instance = desc->Instances().Data[i];
for (int j = 0; j < instance.Count; j++) {
auto geometry = desc->Geometries().Data[instance.GeometryIndices[j]];
pipeline->PerGeometry.StartTriangle = geometry.StartIndex / 3;
pipeline->PerGeometry.VertexOffset = geometry.StartVertex;
pipeline->PerGeometry.MaterialIndex = geometry.MaterialIndex;
pipeline->PerGeometry.TransformIndex = geometryOffset + j;
manager _set HitGroup(pipeline->Hitting, j, 0, 1, geometryOffset);
geometryOffset += instance.Count;
}
}
firstTime = false;
}
if (pipeline->AccumulativeInfo.Pass == 0) // first frame after scene dirty
{
pipeline->AccumulativeInfo.PathtracingRatio = 1;
pipeline->AccumulativeInfo.Pass = 0;
manager _clear UAV(pipeline->Accumulation, uint4(0));
manager _clear UAV(pipeline->Complexity, uint4(0));
}
manager _dispatch Rays(render_target->Width, render_target->Height);
manager _copy Resource(render_target, pipeline->OutputImage);
pipeline->AccumulativeInfo.Pass++;
}
}; | [
"[email protected]"
] | |
c1cc820c5d48db4564c9467c2315620a371922dc | 6ff7f8cc5b053682be9b84b3588f45c2aa6f4225 | /UnitTests/dotNetInstallerLibUnitTests/DownloadCallbackImpl.cpp | c357c29ab667c86e61523f5e07dfdcecca9c2dbb | [
"MIT"
] | permissive | webdev1001/dotnetinstaller | da72f9b763c7ccf0c9cfcefe5e4716b36063981c | f9b4acfb175432975720be80bccc9b2ff3cf2e88 | refs/heads/master | 2020-07-13T11:13:07.691761 | 2015-09-09T06:28:13 | 2015-09-09T06:28:13 | 44,548,252 | 2 | 0 | null | 2015-10-19T16:28:09 | 2015-10-19T16:28:09 | null | UTF-8 | C++ | false | false | 1,378 | cpp | #include "StdAfx.h"
#include "DownloadCallbackImpl.h"
using namespace DVLib::UnitTests;
DownloadCallbackImpl::DownloadCallbackImpl()
: m_cancelled(false)
, m_complete(0)
, m_error(0)
, m_downloading(false)
, m_copying(false)
{
}
void DownloadCallbackImpl::Connecting(const std::wstring& host)
{
std::wcout << std::endl << "Connecting to " << host << L"...";
}
void DownloadCallbackImpl::SendingRequest(const std::wstring& host)
{
std::wcout << std::endl << "Sending request to " << host << L"...";
}
void DownloadCallbackImpl::Status(ULONG progress_current, ULONG progress_max, const std::wstring& description)
{
std::wcout << std::endl << description << L" (" << progress_current << L"/" << progress_max << L")";
}
void DownloadCallbackImpl::DownloadComplete()
{
InterlockedIncrement(& m_complete);
std::wcout << std::endl << "Download complete.";
}
void DownloadCallbackImpl::DownloadError(const std::wstring& message)
{
InterlockedIncrement(& m_error);
std::wcout << std::endl << message;
}
void DownloadCallbackImpl::CopyingFile(const std::wstring& filename)
{
std::wcout << std::endl << "Copying " << filename << L"...";
m_copying = true;
}
void DownloadCallbackImpl::DownloadingFile(const std::wstring& url)
{
std::wcout << std::endl << "Downloading " << url << L"...";
m_downloading = true;
}
| [
"[email protected]"
] | |
543bc064d8c50450dac3a574d02b18c1ca2a4c2e | d24975c1f4cc7553936f90a032696857237a681d | /UVa Online Judge/10487 - Closest Sums.cpp | 1489852cce352c2a46d13c1f7d1cd7e9d9b46010 | [
"Apache-2.0"
] | permissive | SamanKhamesian/ACM-ICPC-Problems | 304b5cfe6e227cce2d63209711bee7c2982620cd | c68c04bee4de9ba9f30e665cd108484e0fcae4d7 | refs/heads/master | 2020-04-29T08:42:58.942037 | 2019-03-21T20:11:57 | 2019-03-21T20:11:57 | 175,996,101 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 843 | cpp | #include <iostream>
#include <cmath>
#include <algorithm>
using namespace std;
int main()
{
int n, m, c = 1;
cin >> n;
while (n != 0)
{
int* a = new int[n];
for (int i = 0; i < n; i++)
{
cin >> a[i];
}
cin >> m;
int* q = new int[m];
for (int i = 0; i < m; i++)
{
cin >> q[i];
}
int sum = 0, ans = 0, minDis = 900000000;
printf("Case %d:\n", c);
for (int k = 0; k < m; k++)
{
sum = 0;
ans = 0;
minDis = 900000000;
for (int i = 0; i < n; i++)
{
for (int j = i + 1; j < n; j++)
{
sum = a[i] + a[j];
if (abs(q[k] - a[i] - a[j]) < minDis)
{
minDis = abs(q[k] - a[i] - a[j]);
ans = sum;
}
}
}
printf("Closest sum to %d is %d.\n", q[k], ans);
}
c++;
cin >> n;
}
} | [
"[email protected]"
] | |
bb3406c15725ad90c4d35b2c7251a7c713433437 | 2c32342156c0bb00e3e1d1f2232935206283fd88 | /cam/src/dark/daielem.cpp | f3bfe1fe86e05867018b859eb658a0c417e93f30 | [] | no_license | infernuslord/DarkEngine | 537bed13fc601cd5a76d1a313ab4d43bb06a5249 | c8542d03825bc650bfd6944dc03da5b793c92c19 | refs/heads/master | 2021-07-15T02:56:19.428497 | 2017-10-20T19:37:57 | 2017-10-20T19:37:57 | 106,126,039 | 7 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 2,939 | cpp | ///////////////////////////////////////////////////////////////////////////////
// $Header: r:/t2repos/thief2/src/dark/daielem.cpp,v 1.3 1998/11/07 21:58:33 CCAROLLO Exp $
//
//
//
#include <lg.h>
#include <comtools.h>
#include <appagg.h>
#include <property.h>
#include <propman.h>
#include <propface.h>
#include <ai.h>
#include <aiutils.h>
#include <daielem.h>
#include <objslit.h>
#include <slitprop.h>
#include <linkman.h>
#include <relation.h>
#include <autolink.h>
#include <pgrpprop.h>
// Must be last header
#include <dbmem.h>
///////////////////////////////////////////////////////////////////////////////
//
// CLASS: cAIElemental
//
STDMETHODIMP_(float) cAIElemental::GetGroundOffset()
{
return cAI::GetGroundOffset() + sin(((AIGetTime() % 4000) / 2000.0) * PI) * 0.5;
}
///////////////////////////////////////////////////////////////////////////////
//
// CLASS: cAIElementalLightAbility
//
cAIElementalLightAbility::cAIElementalLightAbility()
: m_lastLightProp(0)
{
}
///////////////////////////////////////
STDMETHODIMP_(void) cAIElementalLightAbility::Init()
{
SetNotifications(kAICN_ModeChange);
}
///////////////////////////////////////
STDMETHODIMP_(const char *) cAIElementalLightAbility::GetName()
{
return "Elemental light ability";
}
///////////////////////////////////////
STDMETHODIMP_(void) cAIElementalLightAbility::OnModeChange(eAIMode previous, eAIMode mode)
{
// Waking up
if ((previous < kAIM_Normal) && (mode >= kAIM_Normal))
{
// turn on dynamic light
ObjSetSelfLit(m_pAIState->GetID(), m_lastLightProp);
// turn on particle groups
AutoAppIPtr_(LinkManager, pLinkMan);
IRelation *particle_attach = pLinkMan->GetRelationNamed(LINK_PARTICLE_ATTACHMENT_NAME);
cAutoLinkQuery query(particle_attach, LINKOBJ_WILDCARD, m_pAIState->GetID());
for (; !query->Done(); query->Next())
ObjParticleSetActive(query.GetSource(), TRUE);
SafeRelease(particle_attach);
}
// Going to sleep
if ((previous >= kAIM_Normal) && (mode < kAIM_Normal))
{
AutoAppIPtr_(PropertyManager, pPropMan);
IProperty *pSelfLitProp;
// turn off dynamic light
if ((pSelfLitProp = pPropMan->GetPropertyNamed(PROP_SELF_LIT_NAME)) != NULL)
{
((IIntProperty *)pSelfLitProp)->Get(m_pAIState->GetID(), &m_lastLightProp);
pSelfLitProp->Delete(m_pAIState->GetID());
SafeRelease(pSelfLitProp);
}
// turn off particle groups
AutoAppIPtr_(LinkManager, pLinkMan);
IRelation *particle_attach = pLinkMan->GetRelationNamed(LINK_PARTICLE_ATTACHMENT_NAME);
cAutoLinkQuery query(particle_attach, LINKOBJ_WILDCARD, m_pAIState->GetID());
for (; !query->Done(); query->Next())
ObjParticleSetActive(query.GetSource(), FALSE);
SafeRelease(particle_attach);
}
}
///////////////////////////////////////////////////////////////////////////////
| [
"[email protected]"
] | |
1058daef1d543c9d8b88950e2f3d420c78d16638 | a1ce1c416e8cd75b51fc0a05e8483dfbc8eab79e | /Engine/source/gui/controls/guiTreeViewCtrl.cpp | 55459eb21e76f6d3fa25002b3afed099c314d699 | [
"MIT",
"LicenseRef-scancode-unknown-license-reference"
] | permissive | wwhitehead/OmniEngine.Net | 238da56998ac5473c3d3b9f0da705c7c08c0ee17 | b52de3ca5e15a18a6320ced6cbabc41d6fa6be86 | refs/heads/master | 2020-12-26T04:16:46.475080 | 2015-06-18T00:16:45 | 2015-06-18T00:16:45 | 34,730,441 | 0 | 0 | null | 2015-04-28T12:57:08 | 2015-04-28T12:57:08 | null | UTF-8 | C++ | false | false | 183,991 | cpp | //-----------------------------------------------------------------------------
// Copyright (c) 2012 GarageGames, LLC
//
// Permission is hereby granted, free of charge, to any person obtaining a copy
// of this software and associated documentation files (the "Software"), to
// deal in the Software without restriction, including without limitation the
// rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
// sell copies of the Software, and to permit persons to whom the Software is
// furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included in
// all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
// IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
// AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS
// IN THE SOFTWARE.
//-----------------------------------------------------------------------------
#include "platform/platform.h"
#include "gui/controls/guiTreeViewCtrl.h"
#include "core/frameAllocator.h"
#include "core/strings/findMatch.h"
#include "gui/containers/guiScrollCtrl.h"
#include "gui/worldEditor/editorIconRegistry.h"
#include "console/consoleTypes.h"
#include "console/console.h"
#include "gui/core/guiTypes.h"
#include "gfx/gfxDrawUtil.h"
#include "gui/controls/guiTextEditCtrl.h"
#ifdef TORQUE_TOOLS
#include "gui/editor/editorFunctions.h"
#endif
#include "console/engineAPI.h"
IMPLEMENT_CONOBJECT(GuiTreeViewCtrl);
ConsoleDocClass( GuiTreeViewCtrl,
"@brief Hierarchical list of text items with optional icons.\n\n"
"Can also be used to inspect SimObject hierarchies, primarily within editors.\n\n"
"GuiTreeViewCtrls can either display arbitrary user-defined trees or can be used to display SimObject hierarchies where "
"each parent node in the tree is a SimSet or SimGroup and each leaf node is a SimObject.\n\n"
"Each item in the tree has a text and a value. For trees that display SimObject hierarchies, the text for each item "
"is automatically derived from objects while the value for each item is the ID of the respective SimObject. For trees "
"that are not tied to SimObjects, both text and value of each item are set by the user.\n\n"
"Additionally, items in the tree can have icons.\n\n"
"Each item in the tree has a distinct numeric ID that is unique within its tree. The ID of the root item, which is always "
"present on a tree, is 0.\n\n"
"@tsexample\n"
"new GuiTreeViewCtrl(DatablockEditorTree)\n"
"{\n"
" tabSize = \"16\";\n"
" textOffset = \"2\";\n"
" fullRowSelect = \"0\";\n"
" itemHeight = \"21\";\n"
" destroyTreeOnSleep = \"0\";\n"
" MouseDragging = \"0\";\n"
" MultipleSelections = \"1\";\n"
" DeleteObjectAllowed = \"1\";\n"
" DragToItemAllowed = \"0\";\n"
" ClearAllOnSingleSelection = \"1\";\n"
" showRoot = \"1\";\n"
" internalNamesOnly = \"0\";\n"
" objectNamesOnly = \"0\";\n"
" compareToObjectID = \"0\";\n"
" Profile = \"GuiTreeViewProfile\";\n"
" tooltipprofile = \"GuiToolTipProfile\";\n"
" hovertime = \"1000\";\n"
"};\n"
"@endtsexample\n\n"
"@ingroup GuiContainers\n");
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onDeleteObject, bool, ( SimObject* object ), ( object ), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, isValidDragTarget, bool, ( S32 id, const char* value ), ( id, value ), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onDefineIcons, void, (), (), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onAddGroupSelected, void, ( SimGroup* group ), ( group ), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onAddSelection, void, ( S32 itemOrObjectId, bool isLastSelection ), ( itemOrObjectId, isLastSelection ), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onInspect, void, ( S32 itemOrObjectId ), ( itemOrObjectId ), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onRemoveSelection, void, ( S32 itemOrObjectId ), ( itemOrObjectId ), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onUnselect, void, ( S32 itemOrObjectId ), ( itemOrObjectId ), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onDeleteSelection, void, (), (), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onObjectDeleteCompleted, void, (), (), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onKeyDown, void, ( S32 modifier, S32 keyCode ), ( modifier, keyCode ), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onMouseUp, void, ( S32 hitItemId, S32 mouseClickCount ), ( hitItemId, mouseClickCount ), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onMouseDragged, void, (), (), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onRightMouseUp, void, ( S32 itemId, const Point2I& mousePos, SimObject* object ), ( itemId, mousePos, object ), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onBeginReparenting, void, (), (), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onEndReparenting, void, (), (), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onReparent, void, ( S32 itemOrObjectId, S32 oldParentItemOrObjectId, S32 newParentItemOrObjectId ), ( itemOrObjectId, oldParentItemOrObjectId, newParentItemOrObjectId ), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onDragDropped, void, (), (), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onAddMultipleSelectionBegin, void, (), (), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onAddMultipleSelectionEnd, void, (), (), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, canRenameObject, bool, ( SimObject* object ), ( object ), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, handleRenameObject, bool, ( const char* newName, SimObject* object ), ( newName, object ), "" );
IMPLEMENT_CALLBACK( GuiTreeViewCtrl, onClearSelection, void, (), (), "" );
static S32 QSORT_CALLBACK itemCompareCaseSensitive( const void *a, const void *b )
{
GuiTreeViewCtrl::Item* itemA = *( ( GuiTreeViewCtrl::Item** ) a );
GuiTreeViewCtrl::Item* itemB = *( ( GuiTreeViewCtrl::Item** ) b );
char bufferA[ 1024 ];
char bufferB[ 1024 ];
itemA->getDisplayText( sizeof( bufferA ), bufferA );
itemB->getDisplayText( sizeof( bufferB ), bufferB );
return dStrnatcmp( bufferA, bufferB );
}
static S32 QSORT_CALLBACK itemCompareCaseInsensitive( const void *a, const void *b )
{
GuiTreeViewCtrl::Item* itemA = *( ( GuiTreeViewCtrl::Item** ) a );
GuiTreeViewCtrl::Item* itemB = *( ( GuiTreeViewCtrl::Item** ) b );
char bufferA[ 1024 ];
char bufferB[ 1024 ];
itemA->getDisplayText( sizeof( bufferA ), bufferA );
itemB->getDisplayText( sizeof( bufferB ), bufferB );
return dStrnatcasecmp( bufferA, bufferB );
}
static void itemSortList( GuiTreeViewCtrl::Item*& firstChild, bool caseSensitive, bool traverseHierarchy, bool parentsFirst )
{
// Sort the children.
// Do this in a separate scope, so we release the buffers before
// recursing.
{
Vector< GuiTreeViewCtrl::Item* > parents;
Vector< GuiTreeViewCtrl::Item* > items;
// Put all items into the two vectors.
for( GuiTreeViewCtrl::Item* item = firstChild; item != NULL; item = item->mNext )
if( parentsFirst && item->isParent() )
parents.push_back( item );
else
items.push_back( item );
// Sort both vectors.
dQsort( parents.address(), parents.size(), sizeof( GuiTreeViewCtrl::Item* ), caseSensitive ? itemCompareCaseSensitive : itemCompareCaseInsensitive );
dQsort( items.address(), items.size(), sizeof( GuiTreeViewCtrl::Item* ), caseSensitive ? itemCompareCaseSensitive : itemCompareCaseInsensitive );
// Wipe current child chain then reconstruct it in reverse
// as we prepend items.
firstChild = NULL;
// Add child items.
for( U32 i = items.size(); i > 0; -- i )
{
GuiTreeViewCtrl::Item* child = items[ i - 1 ];
child->mNext = firstChild;
if( firstChild )
firstChild->mPrevious = child;
firstChild = child;
}
// Add parent child items, if requested.
for( U32 i = parents.size(); i > 0; -- i )
{
GuiTreeViewCtrl::Item* child = parents[ i - 1 ];
child->mNext = firstChild;
if( firstChild )
firstChild->mPrevious = child;
firstChild = child;
}
firstChild->mPrevious = NULL;
}
// Traverse hierarchy, if requested.
if( traverseHierarchy )
{
GuiTreeViewCtrl::Item* child = firstChild;
while( child )
{
if( child->isParent() )
child->sort( caseSensitive, traverseHierarchy, parentsFirst );
child = child->mNext;
}
}
}
//=============================================================================
// GuiTreeViewCtrl::Item.
//=============================================================================
// MARK: ---- GuiTreeViewCtrl::Item ----
//-----------------------------------------------------------------------------
GuiTreeViewCtrl::Item::Item( GuiTreeViewCtrl* parent, GuiControlProfile *pProfile )
{
AssertFatal( pProfile != NULL , "Cannot create a tree item without a valid tree and control profile!");
mParentControl = parent;
mState = 0;
mId = -1;
mTabLevel = 0;
mIcon = 0;
mDataRenderWidth = 0;
mParent = NULL;
mChild = NULL;
mNext = NULL;
mPrevious = NULL;
mProfile = pProfile;
mScriptInfo.mNormalImage = BmpCon;
mScriptInfo.mExpandedImage = BmpExp;
mScriptInfo.mText = NULL;
mScriptInfo.mValue = NULL;
}
//-----------------------------------------------------------------------------
GuiTreeViewCtrl::Item::~Item()
{
_disconnectMonitors();
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::Item::_connectMonitors()
{
if( mInspectorInfo.mObject != NULL )
{
SimSet* set = dynamic_cast< SimSet* >( mInspectorInfo.mObject.getPointer() );
if( set )
set->getSetModificationSignal().notify( mParentControl, &GuiTreeViewCtrl::_onInspectorSetObjectModified );
}
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::Item::_disconnectMonitors()
{
if( mInspectorInfo.mObject != NULL )
{
SimSet* set = dynamic_cast< SimSet* >( mInspectorInfo.mObject.getPointer() );
if( set )
set->getSetModificationSignal().remove( mParentControl, &GuiTreeViewCtrl::_onInspectorSetObjectModified );
}
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::Item::setNormalImage(S8 id)
{
if(mState.test(InspectorData))
{
Con::errorf("Tried to set normal image %d for item %d, which is InspectorData!", id, mId);
return;
}
mScriptInfo.mNormalImage = id;
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::Item::setExpandedImage(S8 id)
{
if(mState.test(InspectorData))
{
Con::errorf("Tried to set expanded image %d for item %d, which is InspectorData!", id, mId);
return;
}
mScriptInfo.mExpandedImage = id;
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::Item::setText(StringTableEntry txt)
{
if(mState.test(InspectorData))
{
Con::errorf("Tried to set text for item %d, which is InspectorData!", mId);
return;
}
mScriptInfo.mText = txt;
// Update Render Data
if( !mProfile.isNull() )
mDataRenderWidth = getDisplayTextWidth( mProfile->mFont );
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::Item::setValue(StringTableEntry val)
{
if(mState.test(InspectorData))
{
Con::errorf("Tried to set value for item %d, which is InspectorData!", mId);
return;
}
mScriptInfo.mValue = const_cast<char*>(val); // mValue really ought to be a StringTableEntry
// Update Render Data
if( !mProfile.isNull() )
mDataRenderWidth = getDisplayTextWidth( mProfile->mFont );
}
//-----------------------------------------------------------------------------
S8 GuiTreeViewCtrl::Item::getNormalImage() const
{
if(mState.test(InspectorData))
{
Con::errorf("Tried to get the normal image for item %d, which is InspectorData!", mId);
return 0; // fail safe for width determinations
}
return mScriptInfo.mNormalImage;
}
//-----------------------------------------------------------------------------
S8 GuiTreeViewCtrl::Item::getExpandedImage() const
{
if(mState.test(InspectorData))
{
Con::errorf("Tried to get the expanded image for item %d, which is InspectorData!", mId);
return 0; // fail safe for width determinations
}
return mScriptInfo.mExpandedImage;
}
//-----------------------------------------------------------------------------
StringTableEntry GuiTreeViewCtrl::Item::getText()
{
if(mState.test(InspectorData))
{
Con::errorf("Tried to get the text for item %d, which is InspectorData!", mId);
return NULL;
}
return ( mScriptInfo.mText ) ? mScriptInfo.mText : StringTable->EmptyString();
}
//-----------------------------------------------------------------------------
StringTableEntry GuiTreeViewCtrl::Item::getValue()
{
if(mState.test(InspectorData))
{
Con::errorf("Tried to get the value for item %d, which is InspectorData!", mId);
return NULL;
}
return ( mScriptInfo.mValue ) ? mScriptInfo.mValue : StringTable->EmptyString();
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::Item::setObject(SimObject *obj)
{
if(!mState.test(InspectorData))
{
Con::errorf("Tried to set the object for item %d, which is not InspectorData!", mId);
return;
}
_disconnectMonitors();
mInspectorInfo.mObject = obj;
_connectMonitors();
// Update Render Data
if( !mProfile.isNull() )
mDataRenderWidth = getDisplayTextWidth( mProfile->mFont );
}
//-----------------------------------------------------------------------------
SimObject *GuiTreeViewCtrl::Item::getObject()
{
if(!mState.test(InspectorData))
{
Con::errorf("Tried to get the object for item %d, which is not InspectorData!", mId);
return NULL;
}
return mInspectorInfo.mObject;
}
//-----------------------------------------------------------------------------
U32 GuiTreeViewCtrl::Item::getDisplayTextLength()
{
if( mState.test( InspectorData ) )
{
SimObject *obj = getObject();
if( !obj )
return 0;
StringTableEntry name = obj->getName();
StringTableEntry internalName = obj->getInternalName();
StringTableEntry className = obj->getClassName();
if( showInternalNameOnly() )
{
if( internalName && internalName[ 0 ] )
return dStrlen( internalName );
else
return dStrlen( "(none)" );
}
else if( showObjectNameOnly() )
{
if( name && name[ 0 ] )
return dStrlen( name );
else if( mState.test( ShowClassNameForUnnamed ) )
return dStrlen( className );
else
return dStrlen( "(none)" );
}
dsize_t len = 0;
if( mState.test( ShowObjectId ) )
len += dStrlen( obj->getIdString() ) + 2; // '<id>: '
if( mState.test( ShowClassName ) )
{
if( name && name[ 0 ] )
len += dStrlen( className ) + 3; // '<class> - '
else
len += dStrlen( className );
}
if( mState.test( ShowObjectName ) )
{
if( name && name[ 0 ] )
len += dStrlen( name );
else if( mState.test( ShowClassNameForUnnamed ) )
len += dStrlen( className );
}
if( mState.test( ShowInternalName ) )
{
if( internalName && internalName[ 0 ] )
len += dStrlen( internalName ) + 3; // ' [<internalname>]'
}
return len;
}
StringTableEntry pText = getText();
if( pText == NULL )
return 0;
return dStrlen( pText );
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::Item::getDisplayText(U32 bufLen, char *buf)
{
FrameAllocatorMarker txtAlloc;
if( mState.test( InspectorData ) )
{
SimObject *pObject = getObject();
if( pObject )
{
const char* pObjName = pObject->getName();
const char* pInternalName = pObject->getInternalName();
bool hasInternalName = pInternalName && pInternalName[0];
bool hasObjectName = pObjName && pObjName[0];
const char* pClassName = pObject->getClassName();
if( showInternalNameOnly() )
dSprintf( buf, bufLen, "%s", hasInternalName ? pInternalName : "(none)" );
else if( showObjectNameOnly() )
{
if( !hasObjectName && mState.test( ShowClassNameForUnnamed ) )
dSprintf( buf, bufLen, "%s", pClassName );
else
dSprintf( buf, bufLen, "%s", hasObjectName ? pObjName : "(none)" );
}
else
{
char* ptr = buf;
int len = bufLen;
if( mState.test( ShowObjectId ) )
{
S32 n = dSprintf( ptr, len, "%d: ", pObject->getId() );
ptr += n;
len -= n;
}
if( mState.test( ShowClassName ) )
{
S32 n;
if( hasObjectName && mState.test( ShowObjectName ) )
n = dSprintf( ptr, len, "%s - ", pClassName );
else
n = dSprintf( ptr, len, "%s", pClassName );
ptr += n;
len -= n;
}
if( mState.test( ShowObjectName ) )
{
S32 n = 0;
if( hasObjectName )
n = dSprintf( ptr, len, "%s", pObjName );
else if( mState.test( ShowClassNameForUnnamed ) )
n = dSprintf( ptr, len, "%s", pClassName );
ptr += n;
len -= n;
}
if( hasInternalName && mState.test( ShowInternalName ) )
dSprintf( ptr, len, " [%s]", pInternalName );
}
}
else
buf[ 0 ] = '\0';
}
else
{
// Script data! (copy it in)
dStrncpy(buf, getText(), bufLen);
}
}
//-----------------------------------------------------------------------------
S32 GuiTreeViewCtrl::Item::getDisplayTextWidth(GFont *font)
{
if( !font )
return 0;
FrameAllocatorMarker txtAlloc;
U32 bufLen = getDisplayTextLength();
if( bufLen == 0 )
return 0;
// Add space for the string terminator
bufLen++;
char *buf = (char*)txtAlloc.alloc(bufLen);
getDisplayText(bufLen, buf);
return font->getStrWidth(buf);
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::Item::hasObjectBasedTooltip()
{
if(mState.test(Item::InspectorData))
{
SimObject *pObject = getObject();
if(pObject)
{
const char* pClassName = pObject->getClassName();
// Retrieve custom tooltip string
String method("GetTooltip");
method += pClassName;
if(mParentControl->isMethod(method.c_str()))
{
return true;
}
}
}
return false;
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::Item::getTooltipText(U32 bufLen, char *buf)
{
getDisplayText(bufLen, buf);
if(mState.test(Item::InspectorData))
{
SimObject *pObject = getObject();
if(pObject)
{
const char* pClassName = pObject->getClassName();
// Retrieve custom tooltip string
String method("GetTooltip");
method += pClassName;
if(mParentControl->isMethod(method.c_str()))
{
const char* tooltip = Con::executef( mParentControl, method.c_str(), pObject->getIdString() );
dsize_t len = dStrlen(buf);
S32 newBufLen = bufLen-len;
if(dStrlen(tooltip) > 0 && newBufLen > 0)
{
dSprintf(buf+len, newBufLen, "\n%s", tooltip);
}
}
}
}
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::Item::isParent() const
{
if(mState.test(VirtualParent))
{
if( !isInspectorData() )
return true;
// Does our object have any children?
if(mInspectorInfo.mObject)
{
SimSet *pSimSet = dynamic_cast<SimSet*>( (SimObject*)mInspectorInfo.mObject);
if ( pSimSet != NULL && pSimSet->size() > 0)
return pSimSet->size();
}
}
// Otherwise, just return whether the child list is populated.
return mChild;
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::Item::isExpanded() const
{
if(mState.test(InspectorData))
return mInspectorInfo.mObject ? mInspectorInfo.mObject->isExpanded() : false;
else
return mState.test(Expanded);
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::Item::setExpanded(bool f)
{
if( mState.test(InspectorData) )
{
if( !mInspectorInfo.mObject.isNull() )
mInspectorInfo.mObject->setExpanded(f);
}
else
mState.set(Expanded, f);
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::Item::setVirtualParent( bool value )
{
mState.set(VirtualParent, value);
}
//-----------------------------------------------------------------------------
GuiTreeViewCtrl::Item* GuiTreeViewCtrl::Item::findChildByName( const char* name )
{
Item* child = mChild;
while( child )
{
if( dStricmp( child->mScriptInfo.mText, name ) == 0 )
return child;
child = child->mNext;
}
return NULL;
}
//-----------------------------------------------------------------------------
GuiTreeViewCtrl::Item *GuiTreeViewCtrl::Item::findChildByValue(const SimObject *obj)
{
// Iterate over our children and try to find the given
// SimObject
Item *pResultObj = mChild;
while(pResultObj)
{
// CodeReview this check may need to be removed
// if we want to use the tree for data that
// isn't related to SimObject based objects with
// arbitrary values associated with them [5/5/2007 justind]
// Skip non-inspector data stuff.
if(pResultObj->mState.test(InspectorData))
{
if(pResultObj->getObject() == obj)
break; // Whoa.
}
pResultObj = pResultObj->mNext;
}
// If the loop terminated we are NULL, otherwise we have the result in res.
return pResultObj;
}
//-----------------------------------------------------------------------------
GuiTreeViewCtrl::Item *GuiTreeViewCtrl::Item::findChildByValue( StringTableEntry Value )
{
// Iterate over our children and try to find the given Value
// Note : This is a case-insensitive search
Item *pResultObj = mChild;
while(pResultObj)
{
// check the script value of the item against the specified value
if( pResultObj->mScriptInfo.mValue != NULL && dStricmp( pResultObj->mScriptInfo.mValue, Value ) == 0 )
return pResultObj;
pResultObj = pResultObj->mNext;
}
// If the loop terminated we didn't find an item with the specified script value
return NULL;
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::Item::sort( bool caseSensitive, bool traverseHierarchy, bool parentsFirst )
{
itemSortList( mChild, caseSensitive, traverseHierarchy, parentsFirst );
}
//=============================================================================
// GuiTreeViewCtrl.
//=============================================================================
// MARK: ---- GuiTreeViewCtrl ----
//-----------------------------------------------------------------------------
GuiTreeViewCtrl::GuiTreeViewCtrl()
{
VECTOR_SET_ASSOCIATION(mItems);
VECTOR_SET_ASSOCIATION(mVisibleItems);
VECTOR_SET_ASSOCIATION(mSelectedItems);
VECTOR_SET_ASSOCIATION(mSelected);
mItemFreeList = NULL;
mRoot = NULL;
mItemCount = 0;
mSelectedItem = 0;
mStart = 0;
mPossibleRenameItem = NULL;
mRenamingItem = NULL;
mTempItem = NULL;
mRenameCtrl = NULL;
mDraggedToItem = 0;
mCurrentDragCell = 0;
mPreviousDragCell = 0;
mDragMidPoint = NomDragMidPoint;
mMouseDragged = false;
mDebug = false;
// persist info..
mTabSize = 16;
mTextOffset = 2;
mFullRowSelect = false;
mItemHeight = 20;
//
setSize(Point2I(1, 0));
// Set up default state
mFlags.set(ShowTreeLines);
mFlags.set(IsEditable, false);
mDestroyOnSleep = true;
mSupportMouseDragging = true;
mMultipleSelections = true;
mDeleteObjectAllowed = true;
mDragToItemAllowed = true;
mShowRoot = true;
mUseInspectorTooltips = false;
mTooltipOnWidthOnly = false;
mCompareToObjectID = true;
mShowObjectIds = true;
mShowClassNames = true;
mShowObjectNames = true;
mShowInternalNames = true;
mShowClassNameForUnnamedObjects = false;
mFlags.set(RebuildVisible);
mCanRenameObjects = true;
mRenameInternal = false;
mClearAllOnSingleSelection = true;
mBitmapBase = StringTable->insert("");
mTexRollover = NULL;
mTexSelected = NULL;
mRenderTooltipDelegate.bind( this, &GuiTreeViewCtrl::renderTooltip );
}
//-----------------------------------------------------------------------------
GuiTreeViewCtrl::~GuiTreeViewCtrl()
{
_destroyTree();
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::initPersistFields()
{
addGroup( "TreeView" );
addField( "tabSize", TypeS32, Offset(mTabSize, GuiTreeViewCtrl));
addField( "textOffset", TypeS32, Offset(mTextOffset, GuiTreeViewCtrl));
addField( "fullRowSelect", TypeBool, Offset(mFullRowSelect, GuiTreeViewCtrl));
addField( "itemHeight", TypeS32, Offset(mItemHeight, GuiTreeViewCtrl));
addField( "destroyTreeOnSleep", TypeBool, Offset(mDestroyOnSleep, GuiTreeViewCtrl),
"If true, the entire tree item hierarchy is deleted when the control goes to sleep." );
addField( "mouseDragging", TypeBool, Offset(mSupportMouseDragging, GuiTreeViewCtrl));
addField( "multipleSelections", TypeBool, Offset(mMultipleSelections, GuiTreeViewCtrl),
"If true, multiple items can be selected concurrently." );
addField( "deleteObjectAllowed", TypeBool, Offset(mDeleteObjectAllowed, GuiTreeViewCtrl));
addField( "dragToItemAllowed", TypeBool, Offset(mDragToItemAllowed, GuiTreeViewCtrl));
addField( "clearAllOnSingleSelection", TypeBool, Offset(mClearAllOnSingleSelection, GuiTreeViewCtrl));
addField( "showRoot", TypeBool, Offset(mShowRoot, GuiTreeViewCtrl),
"If true, the root item is shown in the tree." );
addField( "useInspectorTooltips", TypeBool, Offset(mUseInspectorTooltips, GuiTreeViewCtrl));
addField( "tooltipOnWidthOnly", TypeBool, Offset(mTooltipOnWidthOnly, GuiTreeViewCtrl));
endGroup( "TreeView" );
addGroup( "Inspector Trees" );
addField( "showObjectIds", TypeBool, Offset( mShowObjectIds, GuiTreeViewCtrl ),
"If true, item text labels for objects will include object IDs." );
addField( "showClassNames", TypeBool, Offset( mShowClassNames, GuiTreeViewCtrl ),
"If true, item text labels for objects will include class names." );
addField( "showObjectNames", TypeBool, Offset( mShowObjectNames, GuiTreeViewCtrl ),
"If true, item text labels for objects will include object names." );
addField( "showInternalNames", TypeBool, Offset( mShowInternalNames, GuiTreeViewCtrl ),
"If true, item text labels for obje ts will include internal names." );
addField( "showClassNameForUnnamedObjects", TypeBool, Offset( mShowClassNameForUnnamedObjects, GuiTreeViewCtrl ),
"If true, class names will be used as object names for unnamed objects." );
addField( "compareToObjectID", TypeBool, Offset(mCompareToObjectID, GuiTreeViewCtrl));
addField( "canRenameObjects", TypeBool, Offset(mCanRenameObjects, GuiTreeViewCtrl),
"If true clicking on a selected item ( that is an object and not the root ) will allow you to rename it." );
addField( "renameInternal", TypeBool, Offset(mRenameInternal, GuiTreeViewCtrl),
"If true then object renaming operates on the internalName rather than the object name." );
endGroup( "Inspector Trees" );
Parent::initPersistFields();
// Copyright (C) 2013 WinterLeaf Entertainment LLC.
// @Copyright start
removeField( "lockControl" );
removeField( "moveControl" );
// @Copyright end
}
//------------------------------------------------------------------------------
GuiTreeViewCtrl::Item * GuiTreeViewCtrl::getItem(S32 itemId) const
{
if ( itemId > 0 && itemId <= mItems.size() )
return mItems[itemId-1];
return NULL;
}
//------------------------------------------------------------------------------
GuiTreeViewCtrl::Item * GuiTreeViewCtrl::createItem(S32 icon)
{
Item * pNewItem = NULL;
// grab from the free list?
if( mItemFreeList )
{
pNewItem = mItemFreeList;
mItemFreeList = pNewItem->mNext;
// re-add to vector
mItems[ pNewItem->mId - 1 ] = pNewItem;
}
else
{
pNewItem = new Item( this, mProfile );
AssertFatal( pNewItem != NULL, "Fatal : unable to allocate tree item!");
mItems.push_back( pNewItem );
// set the id
pNewItem->mId = mItems.size();
}
// reset
if (icon)
pNewItem->mIcon = icon;
else
pNewItem->mIcon = Default; //default icon to stick next to an item
pNewItem->mState = Item::ShowObjectId | Item::ShowClassName | Item::ShowObjectName | Item::ShowInternalName;
pNewItem->mTabLevel = 0;
// Null out item pointers
pNewItem->mNext = 0;
pNewItem->mPrevious = 0;
pNewItem->mChild = 0;
pNewItem->mParent = 0;
mItemCount++;
return pNewItem;
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::_destroyChildren( Item* item, Item* parent, bool deleteObjects )
{
if ( !item || item == parent || !mItems[item->mId-1] )
return;
// destroy depth first, then siblings from last to first
if ( item->isParent() && item->mChild )
_destroyChildren(item->mChild, item, deleteObjects);
if( item->mNext )
_destroyChildren(item->mNext, parent, deleteObjects);
// destroy the item
_destroyItem( item, deleteObjects );
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::_destroyItem( Item* item, bool deleteObject )
{
if(!item)
return;
if(item->isInspectorData())
{
// make sure the SimObjectPtr is clean!
SimObject *pObject = item->getObject();
if( pObject && pObject->isProperlyAdded() )
{
bool skipDelete = !deleteObject;
if( !skipDelete && isMethod( "onDeleteObject" ) )
skipDelete = onDeleteObject_callback( pObject );
if ( !skipDelete )
pObject->deleteObject();
}
item->setObject( NULL );
}
// Remove item from the selection
if (mSelectedItem == item->mId)
mSelectedItem = 0;
for ( S32 i = 0; i < mSelectedItems.size(); i++ )
{
if ( mSelectedItems[i] == item )
{
mSelectedItems.erase( i );
break;
}
}
item->mState.clear();
// unlink
if( item->mPrevious )
item->mPrevious->mNext = item->mNext;
if( item->mNext )
item->mNext->mPrevious = item->mPrevious;
if( item->mParent && ( item->mParent->mChild == item ) )
item->mParent->mChild = item->mNext;
// remove from vector
mItems[item->mId-1] = 0;
// set as root free item
item->mNext = mItemFreeList;
mItemFreeList = item;
mItemCount--;
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::_deleteItem(Item *item)
{
removeItem(item->mId);
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::_destroyTree()
{
// clear the item list
for(U32 i = 0; i < mItems.size(); i++)
{
Item *pFreeItem = mItems[ i ];
if( pFreeItem != NULL )
delete pFreeItem;
}
mItems.clear();
// clear the free list
while(mItemFreeList)
{
Item *next = mItemFreeList->mNext;
delete mItemFreeList;
mItemFreeList = next;
}
mVisibleItems.clear();
mSelectedItems.clear();
//
mRoot = NULL;
mItemFreeList = NULL;
mItemCount = 0;
mSelectedItem = 0;
mDraggedToItem = 0;
mRenamingItem = NULL;
mTempItem = NULL;
mPossibleRenameItem = NULL;
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::_onInspectorSetObjectModified( SetModification modification, SimSet* set, SimObject* object )
{
// Don't bother searching for the Item to see if it is actually visible and instead just
// mark our tree state as dirty so we get a rebuild on the next render.
mFlags.set( RebuildVisible );
}
//------------------------------------------------------------------------------
GuiTreeViewCtrl::Item* GuiTreeViewCtrl::_findItemByAmbiguousId( S32 itemOrObjectId, bool buildVirtual )
{
Item* item = getItem( itemOrObjectId );
if( item )
return item;
SimObject* object = Sim::findObject( itemOrObjectId );
if( object )
{
// If we should expand virtual trees in order to find the item,
// do so now.
if( buildVirtual )
{
if( mFlags.test( RebuildVisible ) )
buildVisibleTree();
SimGroup* group = object->getGroup();
if( group )
_expandObjectHierarchy( group );
}
if( objectSearch( object, &item ) )
return item;
}
return NULL;
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::_expandObjectHierarchy( SimGroup* group )
{
SimGroup* parent = group->getGroup();
if( parent && !parent->isExpanded() )
_expandObjectHierarchy( parent );
if( !group->isExpanded() )
{
Item* item;
if( objectSearch( group, &item ) )
{
item->setExpanded();
onVirtualParentBuild( item, false );
}
}
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::_buildItem( Item* item, U32 tabLevel, bool bForceFullUpdate )
{
if (!item || !mActive || !isVisible() || !mProfile )
return;
// If it's inspector data, make sure we still have it, if not, kill it.
if(item->isInspectorData() && !item->getObject() )
{
removeItem(item->mId);
return;
}
// If it's a virtual parent, give a chance to update itself...
if(item->mState.test( Item::VirtualParent) )
{
// If it returns false the item has been removed.
if( !onVirtualParentBuild( item, bForceFullUpdate ) )
return;
}
// If we have a filter pattern, sync the item's filtering status to it.
if( !getFilterText().isEmpty() )
{
// Determine the filtering status by looking for the filter
// text in the item's display text.
char displayText[ 2048 ];
item->getDisplayText( sizeof( displayText ), displayText );
if( !dStristr( displayText, mFilterText ) )
{
item->mState.set( Item::Filtered );
// If it's not a parent, we're done. Otherwise, there may be children
// that are not filtered so we need to process them first.
if( !item->isParent() )
return;
}
else
item->mState.clear( Item::Filtered );
}
else
item->mState.clear( Item::Filtered );
// Is this the root item?
const bool isRoot = item == mRoot;
// Add non-root items or the root if we're supposed to show it.
if( ( mShowRoot || !isRoot ) &&
!item->isFiltered() )
{
item->mTabLevel = tabLevel;
mVisibleItems.push_back( item );
if( mProfile != NULL )
{
mProfile->incLoadCount();
S32 width = mTextOffset + ( mTabSize * item->mTabLevel ) + getInspectorItemIconsWidth( item ) + item->getDisplayTextWidth( mProfile->mFont );
// check image
S32 image = BmpChild;
if ( item->isInspectorData() )
image = item->isExpanded() ? BmpExp : BmpCon;
else
image = item->isExpanded() ? item->getExpandedImage() : item->getNormalImage();
if ( ( image >= 0 ) && ( image < mProfile->mBitmapArrayRects.size() ) )
width += mProfile->mBitmapArrayRects[image].extent.x;
if ( width > mMaxWidth )
mMaxWidth = width;
mProfile->decLoadCount();
}
}
// If expanded or a hidden root, add all the
// children items as well.
if ( item->isExpanded() ||
bForceFullUpdate ||
( isRoot && !mShowRoot ) )
{
Item* child = item->mChild;
while ( child )
{
// Bit of a hack so we can safely remove items as we
// traverse.
Item *pChildTemp = child;
child = child->mNext;
_buildItem( pChildTemp, tabLevel + 1, bForceFullUpdate );
}
}
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::buildVisibleTree(bool bForceFullUpdate)
{
// Recursion Prevention.
if( mFlags.test( BuildingVisTree ) )
return;
mFlags.set( BuildingVisTree, true );
if( mDebug )
Con::printf( "Rebuilding visible tree" );
mMaxWidth = 0;
mVisibleItems.clear();
// If we're filtering, force a full update.
if( !mFilterText.isEmpty() )
bForceFullUpdate = true;
// Update the flags.
mFlags.clear(RebuildVisible);
// build the root items
Item *traverse = mRoot;
while(traverse)
{
_buildItem(traverse, 0, bForceFullUpdate);
traverse = traverse->mNext;
}
// adjust the GuiArrayCtrl
mCellSize.set( mMaxWidth + mTextOffset, mItemHeight );
setSize(Point2I(1, mVisibleItems.size()));
syncSelection();
// Done Recursing.
mFlags.clear( BuildingVisTree );
}
//------------------------------------------------------------------------------
bool GuiTreeViewCtrl::scrollVisible( S32 itemId )
{
Item* item = getItem(itemId);
if(item)
return scrollVisible(item);
return false;
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::scrollVisible( Item *item )
{
// Now, make sure it's visible (ie, all parents expanded)
Item *parent = item->mParent;
if( !item->isInspectorData() && item->mState.test(Item::VirtualParent) )
onVirtualParentExpand(item);
while(parent)
{
parent->setExpanded(true);
if( !parent->isInspectorData() && parent->mState.test(Item::VirtualParent) )
onVirtualParentExpand(parent);
parent = parent->mParent;
}
// Get our scroll-pappy, if any.
GuiScrollCtrl *pScrollParent = dynamic_cast<GuiScrollCtrl*>( getParent() );
if ( !pScrollParent )
{
Con::warnf("GuiTreeViewCtrl::scrollVisible - parent control is not a GuiScrollCtrl!");
return false;
}
// And now, build the visible tree so we know where we have to scroll.
if( mFlags.test( RebuildVisible ) )
buildVisibleTree();
// All done, let's figure out where we have to scroll...
for(S32 i=0; i<mVisibleItems.size(); i++)
{
if(mVisibleItems[i] == item)
{
// Fetch X Details.
const S32 xPos = pScrollParent->getChildRelPos().x;
const S32 xWidth = ( mMaxWidth - xPos );
// Scroll to View the Item.
// Note: Delta X should be 0 so that we maintain the X axis position.
pScrollParent->scrollRectVisible( RectI( xPos, i * mItemHeight, xWidth, mItemHeight ) );
return true;
}
}
// If we got here, it's probably bad...
Con::errorf("GuiTreeViewCtrl::scrollVisible - was unable to find specified item in visible list!");
return false;
}
//------------------------------------------------------------------------------
S32 GuiTreeViewCtrl::insertItem(S32 parentId, const char * text, const char * value, const char * iconString, S16 normalImage, S16 expandedImage)
{
if( ( parentId < 0 ) || ( parentId > mItems.size() ) )
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::insertItem: invalid parent id!");
return 0;
}
if((parentId != 0) && (mItems[parentId-1] == 0))
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::insertItem: parent item invalid!");
return 0;
}
const char * pItemText = ( text != NULL ) ? text : "";
const char * pItemValue = ( value != NULL ) ? value : "";
S32 icon = getIcon(iconString);
// create an item (assigns id)
Item * pNewItem = createItem(icon);
if( pNewItem == NULL )
return 0;
pNewItem->setText( StringTable->insert( pItemText, true ) );
pNewItem->setValue( StringTable->insert( pItemValue, true ) );
pNewItem->setNormalImage( normalImage );
pNewItem->setExpandedImage( expandedImage );
// root level?
if(parentId == 0)
{
// insert back
if( mRoot != NULL )
{
Item * pTreeTraverse = mRoot;
while( pTreeTraverse != NULL && pTreeTraverse->mNext != NULL )
pTreeTraverse = pTreeTraverse->mNext;
pTreeTraverse->mNext = pNewItem;
pNewItem->mPrevious = pTreeTraverse;
}
else
mRoot = pNewItem;
mFlags.set(RebuildVisible);
}
else if( mItems.size() >= ( parentId - 1 ) )
{
Item * pParentItem = mItems[parentId-1];
// insert back
if( pParentItem != NULL && pParentItem->mChild)
{
Item * pTreeTraverse = pParentItem->mChild;
while( pTreeTraverse != NULL && pTreeTraverse->mNext != NULL )
pTreeTraverse = pTreeTraverse->mNext;
pTreeTraverse->mNext = pNewItem;
pNewItem->mPrevious = pTreeTraverse;
}
else
pParentItem->mChild = pNewItem;
pNewItem->mParent = pParentItem;
if( pParentItem->isExpanded() )
mFlags.set(RebuildVisible);
}
return pNewItem->mId;
}
//------------------------------------------------------------------------------
bool GuiTreeViewCtrl::removeItem( S32 itemId, bool deleteObjects )
{
if( isSelected( itemId ) )
removeSelection( itemId );
// tree?
if(itemId == 0)
{
//RD: this does not delete objects and thus isn't coherent with the semantics of this method
_destroyTree();
return(true);
}
Item * item = getItem(itemId);
if(!item)
{
//Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::removeItem: invalid item id!");
return false;
}
// root?
if(item == mRoot)
mRoot = item->mNext;
// Dispose of any children...
if (item->mChild)
_destroyChildren( item->mChild, item, deleteObjects );
// Kill the item...
_destroyItem( item, deleteObjects );
// Update the rendered tree...
mFlags.set(RebuildVisible);
return true;
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::removeAllChildren(S32 itemId)
{
Item * item = getItem(itemId);
if(item)
{
_destroyChildren(item->mChild, item);
}
}
//------------------------------------------------------------------------------
const S32 GuiTreeViewCtrl::getFirstRootItem() const
{
return (mRoot ? mRoot->mId : 0);
}
//------------------------------------------------------------------------------
S32 GuiTreeViewCtrl::getChildItem(S32 itemId)
{
Item * item = getItem(itemId);
if(!item)
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::getChild: invalid item id!");
return(0);
}
return(item->mChild ? item->mChild->mId : 0);
}
//-----------------------------------------------------------------------------
S32 GuiTreeViewCtrl::getParentItem(S32 itemId)
{
Item * item = getItem(itemId);
if(!item)
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::getParent: invalid item id!");
return(0);
}
return(item->mParent ? item->mParent->mId : 0);
}
//-----------------------------------------------------------------------------
S32 GuiTreeViewCtrl::getNextSiblingItem(S32 itemId)
{
Item * item = getItem(itemId);
if(!item)
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::getNextSibling: invalid item id!");
return(0);
}
return(item->mNext ? item->mNext->mId : 0);
}
//-----------------------------------------------------------------------------
S32 GuiTreeViewCtrl::getPrevSiblingItem(S32 itemId)
{
Item * item = getItem(itemId);
if(!item)
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::getPrevSibling: invalid item id!");
return(0);
}
return(item->mPrevious ? item->mPrevious->mId : 0);
}
//------------------------------------------------------------------------------
bool GuiTreeViewCtrl::isValidDragTarget( Item* item )
{
bool isValid = true;
// If this is inspector data, first make sure the item accepts all
// selected objects as children. This prevents bad surprises when
// certain SimSet subclasses reject children and start shoving them
// off to places of their own choosing.
if( item->isInspectorData() )
{
if( mDebug )
Con::printf( "Checking %i:%s as drag-parent",
item->getObject()->getId(), item->getObject()->getClassName() );
SimSet* set = dynamic_cast< SimSet*>( item->getObject() );
if( set )
{
for( U32 i = 0; i < mSelectedItems.size(); ++ i )
{
Item* selectedItem = mSelectedItems[ i ];
if( mDebug )
Con::printf( "Checking %i:%s as drag-object",
selectedItem->getObject()->getId(),
selectedItem->getObject()->getClassName() );
if( selectedItem->isInspectorData()
&& !set->acceptsAsChild( selectedItem->getObject() ) )
return false;
}
}
}
if( isMethod( "isValidDragTarget" ) )
{
// We have a callback. Exclusively leave the decision whether
// the item is a valid drag target to it.
isValid = isValidDragTarget_callback( item->mId, getItemValue( item->mId ) );
}
else
{
// Make the item a valid drag target if it either already is
// a parent (including VirtualParents) or if dragging to non-parent
// items is explicitly allowed.
isValid = item->isParent() || mDragToItemAllowed;
}
return isValid;
}
//------------------------------------------------------------------------------
S32 GuiTreeViewCtrl::getItemCount()
{
return(mItemCount);
}
//-----------------------------------------------------------------------------
S32 GuiTreeViewCtrl::getSelectedItem()
{
return mSelectedItem;
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::moveItemUp( S32 itemId )
{
GuiTreeViewCtrl::Item* pItem = getItem( itemId );
if ( !pItem )
{
Con::errorf( ConsoleLogEntry::General, "GuiTreeViewCtrl::moveItemUp: invalid item id!");
return;
}
Item * pParent = pItem->mParent;
Item * pPrevItem = pItem->mPrevious;
if ( pPrevItem == NULL || pParent == NULL )
{
Con::errorf( ConsoleLogEntry::General, "GuiTreeViewCtrl::moveItemUp: Unable to move item up, bad data!");
return;
}
// Diddle the linked list!
if ( pPrevItem->mPrevious )
pPrevItem->mPrevious->mNext = pItem;
else if ( pItem->mParent )
pItem->mParent->mChild = pItem;
if ( pItem->mNext )
pItem->mNext->mPrevious = pPrevItem;
pItem->mPrevious = pPrevItem->mPrevious;
pPrevItem->mNext = pItem->mNext;
pItem->mNext = pPrevItem;
pPrevItem->mPrevious = pItem;
// Update SimObjects if Appropriate.
SimObject * pSimObject = NULL;
SimSet * pParentSet = NULL;
// Fetch Current Add Set
if( pParent->isInspectorData() )
pParentSet = dynamic_cast<SimSet*>( pParent->getObject() );
else
{
// parent is probably script data so we search up the tree for a
// set to put our object in
Item * pTraverse = pItem->mParent;
while ( pTraverse != NULL && !pTraverse->isInspectorData() )
pTraverse = pTraverse->mParent;
// found an ancestor who is an inspectorData?
if (pTraverse != NULL)
pParentSet = pTraverse->isInspectorData() ? dynamic_cast<SimSet*>( pTraverse->getObject() ) : NULL;
}
// Reorder the item and make sure that the children of the item get updated
// correctly prev item may be script... so find a prevItem if there is.
// We only need to reorder if there you move it above an inspector item.
if ( pSimObject != NULL && pParentSet != NULL )
{
Item * pTraverse = pItem->mNext;
while(pTraverse)
{
if (pTraverse->isInspectorData())
break;
pTraverse = pTraverse->mNext;
}
if (pTraverse && pItem->getObject() && pTraverse->getObject())
pParentSet->reOrder(pItem->getObject(), pTraverse->getObject());
}
mFlags.set(RebuildVisible);
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::moveItemDown( S32 itemId )
{
GuiTreeViewCtrl::Item* item = getItem( itemId );
if ( !item )
{
Con::errorf( ConsoleLogEntry::General, "GuiTreeViewCtrl::moveItemDown: invalid item id!");
return;
}
Item* nextItem = item->mNext;
if ( !nextItem )
{
Con::errorf( ConsoleLogEntry::General, "GuiTreeViewCtrl::moveItemDown: no next sibling?");
return;
}
// Diddle the linked list!
if ( nextItem->mNext )
nextItem->mNext->mPrevious = item;
if ( item->mPrevious )
item->mPrevious->mNext = nextItem;
else if ( item->mParent )
item->mParent->mChild = nextItem;
item->mNext = nextItem->mNext;
nextItem->mPrevious = item->mPrevious;
item->mPrevious = nextItem;
nextItem->mNext = item;
// And update the simobjects if apppropriate...
SimObject * simobj = NULL;
if (item->isInspectorData())
simobj = item->getObject();
SimSet *parentSet = NULL;
// grab the current parentSet if there is any...
if(item->mParent->isInspectorData())
parentSet = dynamic_cast<SimSet*>(item->mParent->getObject());
else
{
// parent is probably script data so we search up the tree for a
// set to put our object in
Item * temp = item->mParent;
while (temp && !temp->isInspectorData())
temp = temp->mParent;
// found an ancestor who is an inspectorData?
parentSet = (temp && temp->isInspectorData()) ? dynamic_cast<SimSet*>(temp->getObject()) : NULL;
}
// Reorder the item and make sure that the children of the item get updated
// correctly prev item may be script... so find a prevItem if there is.
// We only need to reorder if there you move it above an inspector item.
if (simobj && parentSet)
{
Item * temp = item->mPrevious;
while(temp)
{
if (temp->isInspectorData())
break;
temp = temp->mPrevious;
}
if (temp && item->getObject() && temp->getObject())
parentSet->reOrder(temp->getObject(), item->getObject());
}
mFlags.set(RebuildVisible);
}
//------------------------------------------------------------------------------
bool GuiTreeViewCtrl::onAdd()
{
if( !Parent::onAdd() )
return false;
// If we have dynamic fields, convert the "internalNamesOnly" and "objectNamesOnly"
// legacy fields.
if( getFieldDictionary() )
{
static StringTableEntry sInternalNamesOnly = StringTable->insert( "internalNamesOnly" );
static StringTableEntry sObjectNamesOnly = StringTable->insert( "objectNamesOnly" );
const char* internalNamesOnly = getDataField( sInternalNamesOnly, NULL );
if( internalNamesOnly && internalNamesOnly[ 0 ] && dAtob( internalNamesOnly ) )
{
mShowObjectIds = false;
mShowClassNames = false;
mShowObjectNames = false;
mShowInternalNames = true;
}
const char* objectNamesOnly = getDataField( sObjectNamesOnly, NULL );
if( objectNamesOnly && objectNamesOnly[ 0 ] && dAtob( objectNamesOnly ) )
{
mShowObjectIds = false;
mShowClassNames = false;
mShowObjectNames = true;
mShowInternalNames = false;
}
}
return true;
}
//------------------------------------------------------------------------------
bool GuiTreeViewCtrl::onWake()
{
if(!Parent::onWake() || !mProfile->constructBitmapArray())
return false;
// If destroy on sleep, then we have to give things a chance to rebuild.
if(mDestroyOnSleep)
{
onDefineIcons_callback();
}
// Update the row height, if appropriate.
if(mProfile->mAutoSizeHeight)
{
// make sure it's big enough for both bitmap AND font...
mItemHeight = getMax((S32)mFont->getHeight(), (S32)mProfile->mBitmapArrayRects[0].extent.y);
}
return true;
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::onSleep()
{
Parent::onSleep();
// If appropriate, blast the tree. (We probably rebuild it on wake.)
if( mDestroyOnSleep )
_destroyTree();
if ( mRenameCtrl )
{
mRenameCtrl->deleteObject();
mRenameCtrl = NULL;
}
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::buildIconTable(const char * icons)
{
// Icons should be designated by the bitmap/png file names (minus the file extensions)
// and separated by colons (:). This list should be synchronized with the Icons enum.
// Figure the size of the buffer we need...
const char* temp = dStrchr( icons, '\t' );
U32 textLen = temp ? ( temp - icons ) : dStrlen( icons );
// Allocate temporary space.
FrameAllocatorMarker txtBuff;
char* drawText = (char*)txtBuff.alloc(sizeof(char) * (textLen + 4));
dStrncpy( drawText, icons, textLen );
drawText[textLen] = '\0';
U32 numIcons = 0;
char buf[ 1024 ];
char* pos = drawText;
// Count the number of icons and store them.
while( *pos && numIcons < MaxIcons )
{
char* start = pos;
while( *pos && *pos != ':' )
pos ++;
const U32 len = pos - start;
if( len )
{
dStrncpy( buf, start, getMin( sizeof( buf ) / sizeof( buf[ 0 ] ) - 1, len ) );
buf[ len ] = '\0';
mIconTable[ numIcons ] = GFXTexHandle( buf, &GFXDefaultPersistentProfile, avar( "%s() - mIconTable[%d] (line %d)", __FUNCTION__, numIcons, __LINE__ ) );
}
else
mIconTable[ numIcons ] = GFXTexHandle();
numIcons ++;
if( *pos )
pos ++;
}
return true;
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::onPreRender()
{
Parent::onPreRender();
S32 nRootItemId = getFirstRootItem();
if( nRootItemId == 0 )
return;
Item *pRootItem = getItem( nRootItemId );
if( pRootItem == NULL )
return;
// Update every render in case new objects are added
if(mFlags.test(RebuildVisible))
{
buildVisibleTree();
mFlags.clear(RebuildVisible);
}
}
//------------------------------------------------------------------------------
bool GuiTreeViewCtrl::_hitTest(const Point2I & pnt, Item* & item, BitSet32 & flags)
{
// Initialize some things.
const Point2I pos = globalToLocalCoord(pnt);
flags.clear();
item = 0;
// get the hit cell
Point2I cell((pos.x < 0 ? -1 : pos.x / mCellSize.x),
(pos.y < 0 ? -1 : pos.y / mCellSize.y));
// valid?
if((cell.x < 0 || cell.x >= mSize.x) ||
(cell.y < 0 || cell.y >= mSize.y))
return false;
flags.set(OnRow);
// Grab the cell.
if (cell.y >= mVisibleItems.size())
return false; //Invalid cell, so don't do anything
item = mVisibleItems[cell.y];
S32 min = mTabSize * item->mTabLevel;
// left of icon/text?
if(pos.x < min)
{
flags.set(OnIndent);
return true;
}
// check image
S32 image = BmpChild;
if(item->isInspectorData())
image = item->isExpanded() ? BmpExp : BmpCon;
else
image = item->isExpanded() ? item->getExpandedImage() : item->getNormalImage();
if((image >= 0) && (image < mProfile->mBitmapArrayRects.size()))
min += mProfile->mBitmapArrayRects[image].extent.x;
// Is it on the image?
if(pos.x < min)
{
flags.set(OnImage);
return(true);
}
// Check the icon.
min += getInspectorItemIconsWidth( item );
if ( pos.x < min )
{
flags.set(OnIcon);
return true;
}
// Check the text.
min += mProfile->mTextOffset.x;
FrameAllocatorMarker txtAlloc;
U32 bufLen = item->getDisplayTextLength() + 1;
char *buf = (char*)txtAlloc.alloc(bufLen);
item->getDisplayText(bufLen, buf);
min += mProfile->mFont->getStrWidth(buf);
if(pos.x < min)
flags.set(OnText);
return true;
}
//-----------------------------------------------------------------------------
S32 GuiTreeViewCtrl::getInspectorItemIconsWidth(Item* & item)
{
S32 width = 0;
if( item->isInspectorData() )
{
// Based on code in onRenderCell()
S32 icon = Lock1;
S32 icon2 = Hidden;
if (item->getObject() && item->getObject()->isLocked())
{
if (mIconTable[icon])
{
width += mIconTable[icon].getWidth();
}
}
if (item->getObject() && item->getObject()->isHidden())
{
if (mIconTable[icon2])
{
width += mIconTable[icon2].getWidth();
}
}
GFXTexHandle iconHandle;
if ( ( item->mIcon != -1 ) && mIconTable[item->mIcon] )
iconHandle = mIconTable[item->mIcon];
#ifdef TORQUE_TOOLS
else
iconHandle = gEditorIcons.findIcon( item->getObject() );
#endif
if ( iconHandle.isValid() )
{
width += iconHandle.getWidth();
}
}
else
{
S32 icon = item->isExpanded() ? item->mScriptInfo.mExpandedImage : item->mScriptInfo.mNormalImage;
if ( ( icon != -1 ) && mIconTable[icon] )
{
width += mIconTable[icon].getWidth();
}
}
return width;
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::setAddGroup(SimObject * obj)
{
// make sure we're talking about a group.
SimGroup * grp = dynamic_cast<SimGroup*>(obj);
if(grp)
{
onAddGroupSelected_callback( grp );
return true;
}
return false;
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::syncSelection()
{
// for each visible item check to see if it is on the mSelected list.
// if it is then make sure that it is on the mSelectedItems list as well.
for (S32 i = 0; i < mVisibleItems.size(); i++)
{
for (S32 j = 0; j < mSelected.size(); j++)
{
if (mVisibleItems[i]->mId == mSelected[j])
{
// check to see if it is on the visible items list.
bool addToSelectedItems = true;
for (S32 k = 0; k < mSelectedItems.size(); k++)
{
if (mSelected[j] == mSelectedItems[k]->mId)
{
// don't add it
addToSelectedItems = false;
}
}
if (addToSelectedItems)
{
mVisibleItems[i]->mState.set(Item::Selected, true);
mSelectedItems.push_front(mVisibleItems[i]);
break;
}
}
else if (mVisibleItems[i]->isInspectorData())
{
if(mCompareToObjectID)
{
if (mVisibleItems[i]->getObject() && mVisibleItems[i]->getObject()->getId() == mSelected[j])
{
// check to see if it is on the visible items list.
bool addToSelectedItems = true;
for (S32 k = 0; k < mSelectedItems.size(); k++)
{
if (mSelectedItems[k]->isInspectorData() && mSelectedItems[k]->getObject() )
{
if (mSelected[j] == mSelectedItems[k]->getObject()->getId())
{
// don't add it
addToSelectedItems = false;
}
}
else
{
if (mSelected[j] == mSelectedItems[k]->mId)
{
// don't add it
addToSelectedItems = false;
}
}
}
if (addToSelectedItems)
{
mVisibleItems[i]->mState.set(Item::Selected, true);
mSelectedItems.push_front(mVisibleItems[i]);
break;
}
}
}
}
}
}
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::removeSelection( S32 itemOrObjectId )
{
if (mDebug)
Con::printf( "removeSelection %i", itemOrObjectId );
Item* item = _findItemByAmbiguousId( itemOrObjectId, false );
if (!item)
return;
// Make sure we have a true item ID even if we started with
// an object ID.
S32 itemId = item->getID();
S32 objectId = -1;
if ( item->isInspectorData() && item->getObject() )
objectId = item->getObject()->getId();
// Remove from vector of selected object ids if it exists there
if ( objectId != -1 )
{
for ( S32 i = 0; i < mSelected.size(); i++ )
{
if ( objectId == mSelected[i] || itemId == mSelected[i] )
{
mSelected.erase( i );
break;
}
}
}
else
{
for ( S32 i = 0; i < mSelected.size(); i++ )
{
if ( itemId == mSelected[i] )
{
mSelected.erase( i );
break;
}
}
}
item->mState.set(Item::Selected, false);
// Remove from vector of selected items if it exists there.
for ( S32 i = 0; i < mSelectedItems.size(); i++ )
{
if ( mSelectedItems[i] == item )
{
mSelectedItems.erase( i );
break;
}
}
// Callback.
onRemoveSelection( item );
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::addSelection( S32 itemOrObjectId, bool update, bool isLastSelection )
{
if (mDebug)
Con::printf( "addSelection %i", itemOrObjectId );
Item* item = _findItemByAmbiguousId( itemOrObjectId );
// Add Item?
if ( !item || isSelected( item ) || !canAddSelection( item ) )
{
// Nope.
return;
}
const S32 itemId = item->getID();
// Ok, we have an item to select which isn't already selected....
// Do we want to allow more than one selected item?
if( !mMultipleSelections )
clearSelection();
// Add this object id to the vector of selected objectIds
// if it is not already.
bool foundMatch = false;
for ( S32 i = 0; i < mSelected.size(); i++)
{
if ( mSelected[i] == itemId )
foundMatch = true;
}
if ( !foundMatch )
mSelected.push_front(itemId);
item->mState.set(Item::Selected, true);
if( mSelected.size() == 1 )
{
onItemSelected( item );
}
// Callback Start
// Set and add the selection to the selected items group
item->mState.set(Item::Selected, true);
mSelectedItems.push_front(item);
if ( item->isInspectorData() &&
item->getObject() )
{
SimObject *obj = item->getObject();
onAddSelection_callback( obj->getId(), isLastSelection );
}
else
{
onAddSelection_callback( item->mId, isLastSelection );
}
// Callback end
mFlags.set( RebuildVisible );
if( update )
{
// Also make it so we can see it if we didn't already.
scrollVisible( item );
}
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::onItemSelected( Item *item )
{
mSelectedItem = item->getID();
if (item->isInspectorData())
{
SimObject* object = item->getObject();
if( object )
onSelect_callback(Con::getIntArg( object->getId()),"" );
if( !item->isParent() && object )
onInspect_callback( object->getId() );
}
else
{
onSelect_callback(Con::getIntArg( item->mId ),"");
if( !item->isParent() )
onInspect_callback( item->mId );
}
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::onRemoveSelection( Item *item )
{
S32 id = item->mId;
if( item->isInspectorData() &&
item->getObject() )
{
SimObject* obj = item->getObject();
id = obj->getId();
//obj->setSelected( false );
}
if( isMethod( "onRemoveSelection" ) )
onRemoveSelection_callback( id );
else
onUnselect_callback( id );
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::setItemSelected(S32 itemId, bool select)
{
Item * item = getItem(itemId);
if( isSelected( item ) == select )
return true;
if (select)
{
if (mDebug) Con::printf("setItemSelected called true");
mSelected.push_front(itemId);
}
else
{
if (mDebug) Con::printf("setItemSelected called false");
// remove it from the mSelected list
for (S32 j = 0; j <mSelected.size(); j++)
{
if (item)
{
if (item->isInspectorData())
{
if (item->getObject())
{
if(item->getObject()->getId() == mSelected[j])
{
mSelected.erase(j);
break;
}
}
else
{
// Zombie, kill it!
mSelected.erase(j);
j--;
break;
}
}
}
if (mSelected[j] == itemId)
{
mSelected.erase(j);
break;
}
}
}
if(!item)
{
// maybe what we were passed wasn't an item id but an object id.
for (S32 i = 0; i <mItems.size(); i++)
{
if (mItems[i] != 0)
{
if (mItems[i]->isInspectorData())
{
if (mItems[i]->getObject())
{
if(mItems[i]->getObject()->getId() == itemId)
{
item = mItems[i];
break;
}
}
else
{
// It's a zombie, blast it.
mItems.erase(i);
i--;
}
}
}
}
if (!item)
{
//Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::setItemSelected: invalid item id! Perhaps it isn't visible yet.");
return(false);
}
}
mFlags.set( RebuildVisible );
if(select)
{
addSelection( item->mId );
onItemSelected( item );
}
else
{
// deselect the item, if it's present.
item->mState.set(Item::Selected, false);
if (item->isInspectorData() && item->getObject())
onUnselect_callback( item->getObject()->getId() );
else
onUnselect_callback( item->mId );
// remove it from the selected items list
for (S32 i = 0; i < mSelectedItems.size(); i++)
{
if (mSelectedItems[i] == item)
{
mSelectedItems.erase(i);
break;
}
}
}
setUpdate();
return(true);
}
//-----------------------------------------------------------------------------
// Given an item's index in the selection list, return its itemId
S32 GuiTreeViewCtrl::getSelectedItem(S32 index)
{
if(index >= 0 && index < getSelectedItemsCount())
{
return mSelectedItems[index]->mId;
}
return -1;
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::setItemExpanded(S32 itemId, bool expand)
{
Item * item = getItem(itemId);
if(!item)
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::setItemExpanded: invalid item id!");
return(false);
}
if(item->isExpanded() == expand)
return(true);
// expand parents
if(expand)
{
while(item)
{
if(item->mState.test(Item::VirtualParent))
onVirtualParentExpand(item);
item->setExpanded(true);
item = item->mParent;
}
}
else
{
if(item->mState.test(Item::VirtualParent))
onVirtualParentCollapse(item);
item->setExpanded(false);
}
return(true);
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::setItemValue(S32 itemId, StringTableEntry Value)
{
Item * item = getItem(itemId);
if(!item)
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::setItemValue: invalid item id!");
return(false);
}
item->setValue( ( Value ) ? Value : "" );
return(true);
}
//-----------------------------------------------------------------------------
const char * GuiTreeViewCtrl::getItemText(S32 itemId)
{
Item * item = getItem(itemId);
if(!item)
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::getItemText: invalid item id!");
return("");
}
return(item->getText() ? item->getText() : "");
}
//-----------------------------------------------------------------------------
const char * GuiTreeViewCtrl::getItemValue(S32 itemId)
{
Item * item = getItem(itemId);
if(!item)
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::getItemValue: invalid item id!");
return("");
}
if(item->mState.test(Item::InspectorData))
{
// If it's InspectorData, we let people use this call to get an object reference.
return item->mInspectorInfo.mObject->getIdString();
}
else
{
// Just return the script value...
return item->getValue();
}
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::editItem( S32 itemId, const char* newText, const char* newValue )
{
Item* item = getItem( itemId );
if ( !item )
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::editItem: invalid item id: %d!", itemId);
return false;
}
if ( item->mState.test(Item::InspectorData) )
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::editItem: item %d is inspector data and may not be modified!", itemId);
return false;
}
item->setText( StringTable->insert( newText, true ) );
item->setValue( StringTable->insert( newValue, true ) );
// Update the widths and such:
mFlags.set(RebuildVisible);
return true;
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::markItem( S32 itemId, bool mark )
{
Item *item = getItem( itemId );
if ( !item )
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::markItem: invalid item id: %d!", itemId);
return false;
}
item->mState.set(Item::Marked, mark);
return true;
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::isItemSelected( S32 itemId )
{
for( U32 i = 0, num = mSelectedItems.size(); i < num; ++ i )
if( mSelectedItems[ i ]->mId == itemId )
return true;
return false;
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::deleteSelection()
{
onDeleteSelection_callback();
if (mSelectedItems.empty())
{
for (S32 i = 0; i < mSelected.size(); i++)
{
S32 objectId = mSelected[i];
// find the object
SimObject* obj = Sim::findObject(objectId);
if ( !obj )
continue;
bool skipDelete = onDeleteObject_callback( obj );
if ( !skipDelete )
obj->deleteObject();
}
}
else
{
Vector<Item*> delSelection;
delSelection = mSelectedItems;
mSelectedItems.clear();
while (!delSelection.empty())
{
Item * item = delSelection.front();
setItemSelected(item->mId,false);
if ( item->mParent )
_deleteItem( item );
delSelection.pop_front();
}
}
mSelected.clear();
mSelectedItems.clear();
mSelectedItem = 0;
onObjectDeleteCompleted_callback();
}
//------------------------------------------------------------------------------
// keyboard movement of items is restricted to just one item at a time
// if more than one item is selected then movement operations are not performed
bool GuiTreeViewCtrl::onKeyDown( const GuiEvent& event )
{
if ( !mVisible || !mActive || !mAwake )
return false;
// All the keyboard functionality requires a selected item, so if none exists...
// Deal with enter and delete
if ( event.modifier == 0 )
{
if ( event.keyCode == KEY_RETURN )
{
execAltConsoleCallback();
return true;
}
if ( event.keyCode == KEY_DELETE && mDeleteObjectAllowed )
{
// Don't delete the root!
if (mSelectedItems.empty())
return true;
//this may be fighting with the world editor delete
deleteSelection();
return true;
}
//call a generic bit of script that will let the subclass know that a key was pressed
onKeyDown_callback( event.modifier, event.keyCode );
}
// only do operations if only one item is selected
if ( mSelectedItems.empty() || (mSelectedItems.size() > 1))
return false;
Item* item = mSelectedItems.first();
if ( !item )
return false;
// The Alt key lets you move items around!
if ( mFlags.test(IsEditable) && event.modifier & SI_ALT )
{
switch ( event.keyCode )
{
case KEY_UP:
// Move us up.
if ( item->mPrevious )
{
moveItemUp( item->mId );
scrollVisible(item);
}
return true;
case KEY_DOWN:
// Move the item under us up.
if ( item->mNext )
{
moveItemUp( item->mNext->mId );
scrollVisible(item);
}
return true;
case KEY_LEFT:
if ( item->mParent )
{
if ( item->mParent->mParent )
{
// Ok, we have both an immediate parent, and a grandparent.
// The goal of left-arrow alt is to become the child of our
// grandparent, ie, to become a sibling of our parent.
// First, unlink item from its siblings.
if ( item->mPrevious )
item->mPrevious->mNext = item->mNext;
else
item->mParent->mChild = item->mNext;
if ( item->mNext )
item->mNext->mPrevious = item->mPrevious;
// Now, relink as the next sibling of our parent.
item->mPrevious = item->mParent;
item->mNext = item->mParent->mNext;
// If there was already a next sibling, deal with that case.
if ( item->mNext )
item->mNext->mPrevious = item;
item->mParent->mNext = item;
// Snag the current parent set if any...
SimSet *parentSet = NULL;
if(item->mParent->isInspectorData())
parentSet = dynamic_cast<SimSet*>(item->mParent->getObject());
else
{
// parent is probably script data so we search up the tree for a
// set to put our object in
Item * temp = item->mParent;
while (!temp->isInspectorData())
temp = temp->mParent;
// found a ancestor who is an inspectorData
if (temp->isInspectorData())
parentSet = dynamic_cast<SimSet*>(temp->getObject());
else parentSet = NULL;
}
// Get our active SimObject if any
SimObject *simObj = NULL;
if(item->isInspectorData())
simObj = item->getObject();
// Remove from the old parentset...
if(simObj && parentSet) {
if (parentSet->size()>0)
{
SimObject *lastObject = parentSet->last();
parentSet->removeObject(simObj);
parentSet->reOrder(lastObject);
} else
parentSet->removeObject(simObj);
}
// And finally, update our item
item->mParent = item->mParent->mParent;
// Snag the newparent set if any...
SimSet *newParentSet = NULL;
if(item->mParent->isInspectorData())
newParentSet = dynamic_cast<SimSet*>(item->mParent->getObject());
else
{
// parent is probably script data so we search up the tree for a
// set to put our object in
Item * temp = item->mParent;
while (!temp->isInspectorData())
temp = temp->mParent;
// found a ancestor who is an inspectorData
if (temp->isInspectorData())
newParentSet = dynamic_cast<SimSet*>(temp->getObject());
else newParentSet = NULL;
}
if(simObj && newParentSet)
{
newParentSet->addObject(simObj);
Item * temp = item->mNext;
// item->mNext may be script, so find an inspector item to reorder with if any
if (temp) {
do {
if (temp->isInspectorData())
break;
temp = temp->mNext;
} while (temp);
if (temp && item->getObject() && temp->getObject()) //do we still have a item->mNext? If not then don't bother reordering
newParentSet->reOrder(item->getObject(), temp->getObject());
}
} else if (!simObj&&newParentSet) {
// our current item is script data. but it may have children who
// is inspector data who need an updated set
if (item->mChild)
inspectorSearch(item->mChild, item, parentSet, newParentSet);
}
// And update everything hurrah.
buildVisibleTree();
scrollVisible(item);
}
}
return true;
case KEY_RIGHT:
if ( item->mPrevious )
{
// Make the item the last child of its previous sibling.
// First, unlink from the current position in the list
item->mPrevious->mNext = item->mNext;
if ( item->mNext )
item->mNext->mPrevious = item->mPrevious;
// Get the object we're poking with.
SimObject *simObj = NULL;
SimSet *parentSet = NULL;
if(item->isInspectorData())
simObj = item->getObject();
if(item->mParent->isInspectorData())
parentSet = dynamic_cast<SimSet*>(item->mParent->getObject());
else {
// parent is probably script data so we search up the tree for a
// set to put our object in
Item * temp = item->mParent;
while (!temp->isInspectorData())
temp = temp->mParent;
// found an ancestor who is an inspectorData
if (temp->isInspectorData())
parentSet = dynamic_cast<SimSet*>(temp->getObject());
}
// If appropriate, remove from the current SimSet.
if(parentSet && simObj) {
if (parentSet->size()>0)
{
SimObject *lastObject = parentSet->last();
parentSet->removeObject(simObj);
parentSet->reOrder(lastObject);
} else
parentSet->removeObject(simObj);
}
// Now, make our previous sibling our parent...
item->mParent = item->mPrevious;
item->mNext = NULL;
// And sink us down to the end of its siblings, if appropriate.
if ( item->mParent->mChild )
{
Item* temp = item->mParent->mChild;
while ( temp->mNext )
temp = temp->mNext;
temp->mNext = item;
item->mPrevious = temp;
}
else
{
// only child...<sniff>
item->mParent->mChild = item;
item->mPrevious = NULL;
}
// Make sure the new parent is expanded:
if ( !item->mParent->mState.test( Item::Expanded ) )
setItemExpanded( item->mParent->mId, true );
// Snag the new parent simset if any.
SimSet *newParentSet = NULL;
// new parent might be script. so figure out what set we need to add it to.
if(item->mParent->isInspectorData())
newParentSet = dynamic_cast<SimSet*>(item->mParent->getObject());
else
{
// parent is probably script data so we search up the tree for a
// set to put our object in
if (mDebug) Con::printf("oh nos my parent is script!");
Item * temp = item->mParent;
while (!temp->isInspectorData())
temp = temp->mParent;
// found a ancestor who is an inspectorData
if (temp->isInspectorData())
newParentSet = dynamic_cast<SimSet*>(temp->getObject());
else newParentSet = NULL;
}
// Add the item's SimObject to the new parent simset, at the end.
if(newParentSet && simObj)
newParentSet->addObject(simObj);
else if (!simObj&&newParentSet&&parentSet) {
// our current item is script data. but it may have children who
// is inspector data who need an updated set
if (item->mChild) {
inspectorSearch(item->mChild, item, parentSet, newParentSet);
}
}
scrollVisible(item);
}
return true;
default:
break;
}
}
// Explorer-esque navigation...
switch( event.keyCode )
{
case KEY_UP:
// Select previous visible item:
if ( item->mPrevious )
{
item = item->mPrevious;
while ( item->isParent() && item->isExpanded() )
{
item = item->mChild;
while ( item->mNext )
item = item->mNext;
}
clearSelection();
addSelection( item->mId );
return true;
}
// or select parent:
if ( item->mParent )
{
clearSelection();
addSelection( item->mParent->mId );
return true;
}
return false;
break;
case KEY_DOWN:
// Selected child if it is visible:
if ( item->isParent() && item->isExpanded() )
{
clearSelection();
addSelection( item->mChild->mId );
return true;
}
// or select next sibling (recursively):
do
{
if ( item->mNext )
{
clearSelection();
addSelection( item->mNext->mId );
return true;
}
item = item->mParent;
} while ( item );
return false;
break;
case KEY_LEFT:
// Contract current menu:
if ( item->isExpanded() )
{
setItemExpanded( item->mId, false );
scrollVisible(item);
return true;
}
// or select parent:
if ( item->mParent )
{
clearSelection();
addSelection( item->mParent->mId );
return true;
}
return false;
break;
case KEY_RIGHT:
// Expand selected item:
if ( item->isParent() )
{
if ( !item->isExpanded() )
{
setItemExpanded( item->mId, true );
scrollVisible(item);
return true;
}
// or select child:
clearSelection();
addSelection( item->mChild->mId );
return true;
}
return false;
break;
default:
break;
}
// Not processed, so pass the event on:
return Parent::onKeyDown( event );
}
//------------------------------------------------------------------------------
// on mouse up look at the current item and check to see if it is valid
// to move the selected item(s) to it.
void GuiTreeViewCtrl::onMouseUp(const GuiEvent &event)
{
if( !mActive || !mAwake || !mVisible )
return;
if( isMethod("onMouseUp") )
{
BitSet32 hitFlags = 0;
Item* item;
S32 hitItemId = -1;
if( _hitTest( event.mousePoint, item, hitFlags ) )
hitItemId = item->mId;
onMouseUp_callback( hitItemId, event.mouseClickCount );
}
mouseUnlock();
if ( mSelectedItems.empty())
{
mDragMidPoint = NomDragMidPoint;
return;
}
BitSet32 hitFlags = 0;
Item *item;
bool hitCheck = _hitTest( event.mousePoint, item, hitFlags );
mRenamingItem = NULL;
if( hitCheck )
{
if ( event.mouseClickCount == 1 && !mMouseDragged && mPossibleRenameItem != NULL )
{
if ( item == mPossibleRenameItem )
showItemRenameCtrl( item );
}
else // If mouseUp occurs on the same item as mouse down
{
bool wasSelected = isSelected( item );
bool multiSelect = getSelectedItemsCount() > 1;
if( wasSelected && multiSelect && item == mTempItem )
{
clearSelection();
addSelection( item->mId );
}
}
}
mPossibleRenameItem = NULL;
if (!mMouseDragged)
return;
Item* newItem = NULL;
Item* newItem2 = NULL;
if (mFlags.test(IsEditable))
{
Parent::onMouseMove( event );
BitSet32 hitFlags = 0;
if( !_hitTest( event.mousePoint, newItem2, hitFlags ) )
{
if( !mShowRoot )
newItem2 = mRoot;
else
{
if( mDebug )
Con::printf( "Nothing hit" );
mDragMidPoint = NomDragMidPoint;
return;
}
}
newItem2->mState.clear(Item::MouseOverBmp | Item::MouseOverText );
// If the hit item is the visible root, make sure
// we don't allow dragging above.
if( newItem2 == mRoot && mDragMidPoint == AbovemDragMidPoint )
{
if( mDebug )
Con::printf( "Rejecting to make child sibling of root" );
mDragMidPoint = NomDragMidPoint;
return;
}
// if the newItem isn't in the mSelectedItemList then continue.
Vector<Item *>::iterator k;
for(k = mSelectedItems.begin(); k != mSelectedItems.end(); k++)
{
newItem = newItem2;
if (*(k) == newItem)
{
mDragMidPoint = NomDragMidPoint;
return;
}
Item * temp = *(k);
Item * grandpaTemp = newItem->mParent;
// grandpa check, kick out if an item would be its own ancestor
while (grandpaTemp)
{
if (temp == grandpaTemp)
{
if (mDebug)
{
Con::printf("grandpa check");
if (temp->isInspectorData())
Con::printf("temp's name: %s",temp->getObject()->getName());
if (grandpaTemp->isInspectorData())
Con::printf("grandpa's name: %s",grandpaTemp->getObject()->getName());
}
mDragMidPoint = NomDragMidPoint;
return;
}
grandpaTemp = grandpaTemp->mParent;
}
}
// Notify script for undo.
onBeginReparenting_callback();
// Reparent the items.
for (S32 i = 0; i <mSelectedItems.size();i++)
{
newItem = newItem2;
Item * item = mSelectedItems[i];
if (mDebug) Con::printf("----------------------------");
// clear old highlighting of the item
item->mState.clear(Item::MouseOverBmp | Item::MouseOverText );
// move the selected item to the newItem
Item* oldParent = item->mParent;
// Snag the current parent set if any for future reference
SimSet *parentSet = NULL;
if(oldParent->isInspectorData())
parentSet = dynamic_cast<SimSet*>(oldParent->getObject());
else
{
// parent is probably script data so we search up the tree for a
// set to put our object in
Item * temp = oldParent;
while (temp)
{
if (temp->isInspectorData())
break;
temp = temp->mParent;
}
// found an ancestor who is an inspectorData
if (temp)
{
if (temp->isInspectorData())
parentSet = dynamic_cast<SimSet*>(temp->getObject());
}
}
// unlink from the current position in the list
unlinkItem(item);
// update the parent's children
// check if we an only child
if (item->mParent->mChild == item)
{
if (item->mNext)
item->mParent->mChild = item->mNext;
else
item->mParent->mChild = NULL;
}
if (mDragMidPoint != NomDragMidPoint)
{
//if it is below an expanded tree, place as last item in the tree
//if it is below a parent who isn't expanded put below it
// position the item above or below another item
if (mDragMidPoint == AbovemDragMidPoint)
{
// easier to treat everything as "Below the mDragMidPoint" so make some adjustments
if (mDebug) Con::printf("adding item above mDragMidPoint");
// above the mid point of an item, so grab either the parent
// or the previous sibling
// does the item have a previous sibling?
if (newItem->mPrevious)
{
newItem = newItem->mPrevious;
if (mDebug) Con::printf("treating as if below an item that isn't expanded");
// otherwise add below that item as a sibling
item->mParent = newItem->mParent;
item->mPrevious = newItem;
item->mNext = newItem->mNext;
if (newItem->mNext)
newItem->mNext->mPrevious = item;
newItem->mNext = item;
}
else
{
if (mDebug) Con::printf("treating as if adding below the parent of the item");
// instead we add as the first item below the newItem's parent
item->mParent = newItem->mParent;
item->mNext = newItem;
item->mPrevious = NULL;
newItem->mPrevious = item;
item->mParent->mChild = item;
}
}
else if (mDragMidPoint == BelowmDragMidPoint)
{
if ((newItem->isParent())&&(newItem->isExpanded()))
{
if (mDebug) Con::printf("adding item to an expanded parent below the mDragMidPoint");
item->mParent = newItem;
// then add the new item as a child
item->mNext = newItem->mChild;
if (newItem->mChild)
newItem->mChild->mPrevious = item;
item->mParent->mChild = item;
item->mPrevious = NULL;
}
else if ((!newItem->mNext)&&(newItem->mParent)&&(newItem->mParent->mParent))
{
// add below it's parent.
if (mDebug) Con::printf("adding below a tree");
item->mParent = newItem->mParent->mParent;
item->mNext = newItem->mParent->mNext;
item->mPrevious = newItem->mParent;
if (newItem->mParent->mNext)
newItem->mParent->mNext->mPrevious = item;
newItem->mParent->mNext = item;
}
else
{
// adding below item not as a child
if (mDebug) Con::printf("adding item below the mDragMidPoint of an item");
item->mParent = newItem->mParent;
// otherwise the item is a sibling
if (newItem->mNext)
newItem->mNext->mPrevious = item;
item->mNext = newItem->mNext;
item->mPrevious = newItem;
newItem->mNext = item;
}
}
}
// if we're not allowed to add to items, then try to add to the parent of the hit item.
// if we are, just add to the item we hit.
else
{
if (mDebug)
{
if (item->isInspectorData() && item->getObject())
Con::printf("Item: %i",item->getObject()->getId());
if (newItem->isInspectorData() && newItem->getObject())
Con::printf("Parent: %i",newItem->getObject()->getId());
Con::printf("dragged onto an item");
}
// If the hit item is not a valid drag target,
// then try to add to the parent.
if( !isValidDragTarget( newItem ) )
{
// add to the item's parent.
if(!newItem->mParent || !newItem->mParent->isParent())
{
if(mDebug)
Con::printf("could not find the parent of that item. dragging to an item is not allowed, kicking out.");
mDragMidPoint = NomDragMidPoint;
continue;
}
newItem = newItem->mParent;
}
// new parent is the item in the current cell
item->mParent = newItem;
// adjust children if any
if (newItem->mChild)
{
if (mDebug) Con::printf("not the first child");
// put it at the top of the list (easier to find if there are many children)
if (newItem->mChild)
newItem->mChild->mPrevious = item;
item->mNext = newItem->mChild;
newItem->mChild = item;
item->mPrevious = NULL;
}
else
{
if (mDebug) Con::printf("first child");
// only child
newItem->mChild = item;
item->mNext = NULL;
item->mPrevious = NULL;
}
}
// expand the item we added to, if it isn't expanded already
if( !item->mParent->mState.test( Item::Expanded ) )
setItemExpanded( item->mParent->mId, true );
//----------------------------------------------------------------
// handle objects
// Get our active SimObject if any
SimObject *simObj = NULL;
if(item->isInspectorData())
{
simObj = item->getObject();
}
// Remove from the old parentset
if((simObj && parentSet)&&(oldParent != item->mParent))
{
if (mDebug) Con::printf("removing item from old parentset");
// hack to get around the way removeObject takes the last item of the set
// and moves it into the place of the object we removed
if (parentSet->size()>0)
{
SimObject *lastObject = parentSet->last();
parentSet->removeObject(simObj);
parentSet->reOrder(lastObject);
}
else
{
parentSet->removeObject(simObj);
}
}
// Snag the newparent set if any...
SimSet *newParentSet = NULL;
if(item->mParent->isInspectorData())
{
if (mDebug) Con::printf("getting a new parent set");
SimObject * tmpObj = item->mParent->getObject();
newParentSet = dynamic_cast<SimSet*>(tmpObj);
}
else
{
// parent is probably script data so we search up the tree for a
// set to put our object in
if (mDebug) Con::printf("oh nos my parent is script!");
Item * temp = item->mParent;
while (temp)
{
if (temp->isInspectorData())
break;
temp = temp->mParent;
}
// found a ancestor who is an inspectorData
if (temp)
{
if (temp->isInspectorData())
newParentSet = dynamic_cast<SimSet*>(temp->getObject());
}
else
{
newParentSet = NULL;
}
}
if(simObj && newParentSet)
{
if (mDebug) Con::printf("simobj and new ParentSet");
if (oldParent != item->mParent)
newParentSet->addObject(simObj);
//order the objects in the simset according to their
//order in the tree view control
if(!item->mNext)
{
if( item->mPrevious )
{
//bring to the end of the set
SimObject *prevObject = item->mPrevious->getObject();
if (prevObject && item->getObject())
{
newParentSet->reOrder(item->getObject(), prevObject);
}
}
}
else
{
//reorder within the set
SimObject *nextObject = item->mNext->getObject();
if(nextObject && item->getObject())
{
newParentSet->reOrder(item->getObject(), nextObject);
}
}
}
else if (!simObj&&newParentSet)
{
// our current item is script data. but it may have children who
// is inspector data who need an updated set
if (mDebug) Con::printf("no simobj but new parentSet");
if (item->mChild)
inspectorSearch(item->mChild, item, parentSet, newParentSet);
}
else if (simObj&&!newParentSet)
{
if (mDebug) Con::printf("simobject and no new parent set");
}
else
if (mDebug) Con::printf("no simobject and no new parent set");
// Notify script.
if( item->isInspectorData() )
onReparent_callback(
item->getObject()->getId(),
oldParent->getObject()->getId(),
item->mParent->getObject()->getId()
);
else
onReparent_callback(
item->mId,
oldParent->mId,
item->mParent->mId
);
}
onEndReparenting_callback();
// And update everything.
scrollVisible(newItem);
onDragDropped_callback();
buildVisibleTree(false);
}
mDragMidPoint = NomDragMidPoint;
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::onMouseDragged(const GuiEvent &event)
{
if( mDragStartInSelection )
onMouseDragged_callback();
if(!mSupportMouseDragging)
return;
if( !mActive || !mAwake || !mVisible )
return;
if (mSelectedItems.size() == 0)
return;
// Give us a little delta before we actually start a mouse drag so that
// if the user moves the mouse a little while clicking, he/she does not
// accidentally trigger a drag.
if( mFabs( ( mMouseDownPoint - event.mousePoint ).len() ) <= 4.f )
return;
Point2I pt = globalToLocalCoord(event.mousePoint);
Parent::onMouseMove(event);
mouseLock();
mMouseDragged = true;
// If the drag is outside of our visible area,
// start scrolling.
GuiScrollCtrl* scrollCtrl = dynamic_cast< GuiScrollCtrl* >( getParent() );
if( scrollCtrl && !scrollCtrl->isPointVisible( pt ) )
{
S32 widthDelta = 0;
S32 heightDelta = 0;
if( pt.x < scrollCtrl->getChildRelPos().x )
widthDelta = pt.x - scrollCtrl->getChildRelPos().x;
else if( pt.x > scrollCtrl->getChildRelPos().x + scrollCtrl->getContentExtent().x )
widthDelta = pt.x - scrollCtrl->getChildRelPos().x - scrollCtrl->getContentExtent().x;
if( pt.y < scrollCtrl->getChildRelPos().y )
heightDelta = pt.y - scrollCtrl->getChildRelPos().y;
else if( pt.y > scrollCtrl->getChildRelPos().y + scrollCtrl->getContentExtent().y )
heightDelta = pt.y - scrollCtrl->getChildRelPos().y - scrollCtrl->getContentExtent().y;
const F32 SCROLL_RATIO = 0.5f;
scrollCtrl->scrollDelta( S32( F32( widthDelta ) * SCROLL_RATIO ), S32( F32( heightDelta ) * SCROLL_RATIO ) );
}
// whats our mDragMidPoint?
mCurrentDragCell = mMouseOverCell.y;
S32 midpCell = mCurrentDragCell * mItemHeight + (mItemHeight/2);
S32 currentY = pt.y;
S32 yDiff = currentY-midpCell;
S32 variance = (mItemHeight/5);
if( mPreviousDragCell >= 0 && mPreviousDragCell < mVisibleItems.size() )
mVisibleItems[mPreviousDragCell]->mState.clear( Item::MouseOverBmp | Item::MouseOverText | Item::MouseOverIcon );
bool hoverItem = false;
if (mAbs(yDiff) <= variance)
{
mDragMidPoint = NomDragMidPoint;
// highlight the current item
// hittest to detect whether we are on an item
// ganked from onMouseMouse
// used for tracking what our last cell was so we can clear it.
mPreviousDragCell = mCurrentDragCell;
if (mCurrentDragCell >= 0)
{
Item* item = NULL;
BitSet32 hitFlags = 0;
if ( !_hitTest( event.mousePoint, item, hitFlags ) )
return;
// If the item is a valid drag target, activate the item
// highlighting.
if( isValidDragTarget( item ) )
{
hoverItem = true;
if ( hitFlags.test( OnImage ) )
item->mState.set( Item::MouseOverBmp );
if ( hitFlags.test( OnText ) )
item->mState.set( Item::MouseOverText );
if ( hitFlags.test( OnIcon ) )
item->mState.set( Item::MouseOverIcon );
// Always redraw the entire mouse over item, since we are distinguishing
// between the bitmap and the text:
setUpdateRegion( Point2I( mMouseOverCell.x * mCellSize.x, mMouseOverCell.y * mCellSize.y ), mCellSize );
}
}
}
if ( !hoverItem )
{
//above or below an item?
if (yDiff < 0)
mDragMidPoint = AbovemDragMidPoint;
else
mDragMidPoint = BelowmDragMidPoint;
}
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::onMiddleMouseDown(const GuiEvent & event)
{
//for debugging items
if (mDebug) {
Item* item;
BitSet32 hitFlags = 0;
_hitTest( event.mousePoint, item, hitFlags );
Con::printf("debugging %d", item->mId);
Point2I pt = globalToLocalCoord(event.mousePoint);
if (item->isInspectorData() && item->getObject()) {
Con::printf("object data:");
Con::printf("name:%s",item->getObject()->getName());
Con::printf("className:%s",item->getObject()->getClassName());
}
Con::printf("contents of mSelectedItems:");
for(S32 i = 0; i < mSelectedItems.size(); i++) {
if (mSelectedItems[i]->isInspectorData()) {
Con::printf("%d",mSelectedItems[i]->getObject()->getId());
} else
Con::printf("wtf %d", mSelectedItems[i]);
}
Con::printf("contents of mSelected");
for (S32 j = 0; j < mSelected.size(); j++) {
Con::printf("%d", mSelected[j]);
}
mCurrentDragCell = mMouseOverCell.y;
S32 midpCell = (mCurrentDragCell) * mItemHeight + (mItemHeight/2);
S32 currentY = pt.y;
S32 yDiff = currentY-midpCell;
Con::printf("cell info: (%d,%d) mCurrentDragCell=%d est=(%d,%d,%d) ydiff=%d",pt.x,pt.y,mCurrentDragCell,mCurrentDragCell*mItemHeight, midpCell, (mCurrentDragCell+1)*mItemHeight,yDiff);
}
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::onMouseDown(const GuiEvent & event)
{
if( !mActive || !mAwake || !mVisible )
{
Parent::onMouseDown(event);
return;
}
if ( mProfile->mCanKeyFocus )
setFirstResponder();
Item * item = 0;
BitSet32 hitFlags;
mDragMidPoint = NomDragMidPoint;
mMouseDragged = false;
mMouseDownPoint = event.mousePoint;
//
if(!_hitTest(event.mousePoint, item, hitFlags))
return;
mPossibleRenameItem = NULL;
mRenamingItem = NULL;
mTempItem = NULL;
//
if( event.modifier & SI_MULTISELECT )
{
bool selectFlag = item->mState.test(Item::Selected);
if (selectFlag == true)
{
// already selected, so unselect it and remove it
removeSelection(item->mId);
}
else
{
addSelection(item->mId);
}
}
else if( event.modifier & SI_RANGESELECT && mMultipleSelections )
{
// is something already selected?
S32 firstSelectedIndex = 0;
Item * firstItem = NULL;
if (!mSelectedItems.empty())
{
firstItem = mSelectedItems.front();
for (S32 i = 0; i < mVisibleItems.size();i++)
{
if (mVisibleItems[i] == mSelectedItems.front())
{
firstSelectedIndex = i;
break;
}
}
mCurrentDragCell = mMouseOverCell.y;
if (mVisibleItems[firstSelectedIndex] != firstItem )
{
/*
Con::printf("something isn't right...");
if (mVisibleItems[firstSelectedIndex]->isInspectorData())
Con::printf("visibleItem %s",mVisibleItems[firstSelectedIndex]->getObject()->getName());
if (firstItem->isInspectorData())
Con::printf("firstItem %s",firstItem->getObject()->getName());
*/
}
else
{
// select the cells
onAddMultipleSelectionBegin_callback();
if ((mCurrentDragCell) < firstSelectedIndex)
{
//select up
for (S32 j = (mCurrentDragCell); j < firstSelectedIndex; j++)
{
if( j != (firstSelectedIndex - 1) )
addSelection(mVisibleItems[j]->mId, false, false);
else
addSelection(mVisibleItems[j]->mId, false);
}
}
else
{
// select down
for (S32 j = firstSelectedIndex+1; j < (mCurrentDragCell+1); j++)
{
if( j != mCurrentDragCell )
addSelection(mVisibleItems[j]->mId, false, false);
else
addSelection(mVisibleItems[j]->mId, false);
}
}
// Scroll to view the last selected cell.
scrollVisible( mVisibleItems[mCurrentDragCell] );
onAddMultipleSelectionEnd_callback();
}
}
}
else if ( event.modifier & SI_PRIMARY_ALT )
{
if ( item->isInspectorData() && item->getObject() )
setAddGroup(item->getObject());
}
else if ( !hitFlags.test(OnImage) )
{
mTempItem = item;
bool wasSelected = isSelected( item );
bool multiSelect = getSelectedItemsCount() > 1;
if( !wasSelected || !multiSelect )
{
if ( mClearAllOnSingleSelection )
clearSelection();
if ( !wasSelected || mClearAllOnSingleSelection )
addSelection( item->mId );
if ( wasSelected &&
!multiSelect &&
mCanRenameObjects &&
hitFlags.test(OnText) &&
mFlags.test(IsEditable) &&
item->isInspectorData() &&
item->getObject() &&
item->getObject()->isNameChangeAllowed() &&
item != mRoot &&
event.mouseClickCount == 1 )
{
mPossibleRenameItem = item;
if ( isMethod( "canRenameObject" ) )
{
if( canRenameObject_callback( item->getObject() ) )
mPossibleRenameItem = NULL;
}
}
}
}
if ( ( hitFlags.test( OnText ) || hitFlags.test( OnIcon ) ) &&
event.mouseClickCount > 1 )
execAltConsoleCallback();
// For dragging, note if hit is in selection.
mDragStartInSelection = isItemSelected( item->mId );
if(!item->isParent())
return;
//
if ( mFullRowSelect || hitFlags.test( OnImage ) )
{
item->setExpanded(!item->isExpanded());
if( !item->isInspectorData() && item->mState.test(Item::VirtualParent) )
onVirtualParentExpand(item);
mFlags.set( RebuildVisible );
scrollVisible(item);
}
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::onMouseMove( const GuiEvent &event )
{
if ( mMouseOverCell.y >= 0 && mVisibleItems.size() > mMouseOverCell.y)
mVisibleItems[mMouseOverCell.y]->mState.clear( Item::MouseOverBmp | Item::MouseOverText | Item::MouseOverIcon);
Parent::onMouseMove( event );
if ( mMouseOverCell.y >= 0 )
{
Item* item = NULL;
BitSet32 hitFlags = 0;
if ( !_hitTest( event.mousePoint, item, hitFlags ) )
return;
if ( hitFlags.test( OnImage ) )
item->mState.set( Item::MouseOverBmp );
if ( hitFlags.test( OnText ) )
item->mState.set( Item::MouseOverText );
if ( hitFlags.test( OnIcon ) )
item->mState.set( Item::MouseOverIcon );
// Always redraw the entire mouse over item, since we are distinguishing
// between the bitmap and the text:
setUpdateRegion( Point2I( mMouseOverCell.x * mCellSize.x, mMouseOverCell.y * mCellSize.y ), mCellSize );
}
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::onMouseEnter( const GuiEvent &event )
{
Parent::onMouseEnter( event );
onMouseMove( event );
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::onMouseLeave( const GuiEvent &event )
{
if ( mMouseOverCell.y >= 0 && mVisibleItems.size() > mMouseOverCell.y)
mVisibleItems[mMouseOverCell.y]->mState.clear( Item::MouseOverBmp | Item::MouseOverText | Item::MouseOverIcon );
Parent::onMouseLeave( event );
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::onRightMouseDown(const GuiEvent & event)
{
if(!mActive)
{
Parent::onRightMouseDown(event);
return;
}
Item * item = NULL;
BitSet32 hitFlags;
//
if(!_hitTest(event.mousePoint, item, hitFlags))
return;
//
char buf[32];
dSprintf( buf, sizeof( buf ), "%d %d", event.mousePoint.x, event.mousePoint.y );
if (item->isInspectorData() && item->getObject())
onRightMouseDown_callback(Con::getIntArg( item->mId), buf, Con::getIntArg(item->getObject()->getId()) );
else
onRightMouseDown_callback( Con::getIntArg(item->mId),buf,"" );
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::onRightMouseUp(const GuiEvent & event)
{
Item *item = NULL;
BitSet32 hitFlags;
if ( !_hitTest( event.mousePoint, item, hitFlags ) )
return;
if ( hitFlags.test( OnText ) || hitFlags.test( OnIcon ) )
{
if ( !isItemSelected( item->getID() ) )
{
clearSelection();
addSelection( item->getID() );
}
if (item->isInspectorData() && item->getObject())
onRightMouseUp_callback( item->mId, event.mousePoint, item->getObject() );
else
onRightMouseUp_callback( item->mId, event.mousePoint );
}
else
{
clearSelection();
}
Parent::onRightMouseUp(event);
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::onRender(Point2I offset, const RectI &updateRect)
{
if ( !mRenamingItem && mRenameCtrl )
{
mRenameCtrl->deleteObject();
mRenameCtrl = NULL;
}
// Get all our contents drawn!
Parent::onRender(offset,updateRect);
// Deal with drawing the drag & drop line, if any...
GFX->setClipRect(updateRect);
// only do it if we have a mDragMidPoint
if (mDragMidPoint == NomDragMidPoint || !mSupportMouseDragging )
return;
ColorF greyLine(0.5,0.5,0.5,1);
Point2F squarePt;
// CodeReview: LineWidth is not supported in Direct3D. This is lame. [5/10/2007 Pat]
// draw mDragMidPoint lines with a diamond
if (mDragMidPoint == AbovemDragMidPoint)
{
S32 tempY = mItemHeight*mCurrentDragCell+offset.y ;
squarePt.y = (F32)tempY;
squarePt.x = 125.f+offset.x;
GFX->getDrawUtil()->drawLine(0+offset.x, tempY, 250+offset.x, tempY,greyLine);
GFX->getDrawUtil()->draw2DSquare(squarePt, 6, 90 );
}
if (mDragMidPoint == BelowmDragMidPoint)
{
S32 tempY2 = mItemHeight*(mCurrentDragCell+1) +offset.y;
squarePt.y = (F32)tempY2;
squarePt.x = 125.f+offset.x;
GFX->getDrawUtil()->drawLine(0+offset.x, tempY2, 250+offset.x, tempY2,greyLine);
GFX->getDrawUtil()->draw2DSquare(squarePt,6, 90 );
}
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::onRenderCell(Point2I offset, Point2I cell, bool, bool )
{
if( !mVisibleItems.size() )
return;
// Do some sanity checking and data retrieval.
AssertFatal(cell.y < mVisibleItems.size(), "GuiTreeViewCtrl::onRenderCell: invalid cell");
Item * item = mVisibleItems[cell.y];
// If there's no object, deal with it.
if(item->isInspectorData())
if(!item->getObject())
return;
RectI drawRect( offset, mCellSize );
GFXDrawUtil *drawer = GFX->getDrawUtil();
drawer->clearBitmapModulation();
FrameAllocatorMarker txtBuff;
// Ok, we have the item. There are a few possibilities at this point:
// - We need to draw inheritance lines and a treeview-chosen icon
// OR
// - We have to draw an item-dependent icon
// - If we're mouseover, we have to highlight it.
//
// - We have to draw the text for the item
// - Taking into account various mouseover states
// - Taking into account the value (set or not)
// - If it's an inspector data, we have to do some custom rendering
// - ADDED: If it is being renamed, we also have custom rendering.
// Ok, first draw the tab and icon.
// Do we draw the tree lines?
if( mFlags.test(ShowTreeLines) )
{
drawRect.point.x += ( mTabSize * item->mTabLevel );
Item* parent = item->mParent;
for ( S32 i = item->mTabLevel; ( parent && i > 0 ); i-- )
{
drawRect.point.x -= mTabSize;
if ( parent->mNext )
drawer->drawBitmapSR( mProfile->mTextureObject, drawRect.point, mProfile->mBitmapArrayRects[BmpLine] );
parent = parent->mParent;
}
}
// Now, the icon...
drawRect.point.x = offset.x + mTabSize * item->mTabLevel;
// First, draw the rollover glow, if it's an inner node.
if ( item->isParent() && item->mState.test( Item::MouseOverBmp ) )
drawer->drawBitmapSR( mProfile->mTextureObject, drawRect.point, mProfile->mBitmapArrayRects[BmpGlow] );
// Now, do we draw a treeview-selected item or an item dependent one?
S32 newOffset = 0; // This is stored so we can render glow, then update render pos.
S32 bitmap = 0;
// Ok, draw the treeview lines as appropriate.
bool drawBitmap = true;
if ( !item->isParent() )
{
if( mFlags.test( ShowTreeLines ) )
{
if( ( item->mNext && item->mPrevious )
|| ( item->mNext && item->mParent && ( !_isRootLevelItem( item ) || mShowRoot ) ) )
bitmap = BmpChild;
else if( item->mNext && ( !item->mParent || !mShowRoot ) )
bitmap = BmpFirstChild;
else if( item->mPrevious || ( item->mParent && !_isRootLevelItem( item ) ) )
bitmap = BmpLastChild;
else
drawBitmap = false;
}
else
drawBitmap = false;
}
else
{
bitmap = item->isExpanded() ? BmpExp : BmpCon;
if( mFlags.test( ShowTreeLines ) )
{
// Shift indices to show versions with tree lines.
if ( item->mParent || item->mPrevious )
bitmap += ( item->mNext ? 3 : 2 );
else
bitmap += ( item->mNext ? 1 : 0 );
}
}
if( ( bitmap >= 0 ) && ( bitmap < mProfile->mBitmapArrayRects.size() ) )
{
if( drawBitmap )
drawer->drawBitmapSR( mProfile->mTextureObject, drawRect.point, mProfile->mBitmapArrayRects[bitmap] );
newOffset = mProfile->mBitmapArrayRects[bitmap].extent.x;
}
if(item->isInspectorData())
{
// draw lock icon if need be
S32 icon = Lock1;
S32 icon2 = Hidden;
if (item->getObject() && item->getObject()->isLocked())
{
if (mIconTable[icon])
{
//drawRect.point.x = offset.x + mTabSize * item->mTabLevel + mIconTable[icon].getWidth();
drawRect.point.x += mIconTable[icon].getWidth();
drawer->drawBitmap( mIconTable[icon], drawRect.point );
}
}
if (item->getObject() && item->getObject()->isHidden())
{
if (mIconTable[icon2])
{
//drawRect.point.x = offset.x + mTabSize * item->mTabLevel + mIconTable[icon].getWidth();
drawRect.point.x += mIconTable[icon2].getWidth();
drawer->drawBitmap( mIconTable[icon2], drawRect.point );
}
}
SimObject * pObject = item->getObject();
SimGroup * pGroup = ( pObject == NULL ) ? NULL : dynamic_cast<SimGroup*>( pObject );
// If this item is a VirtualParent we can use the generic SimGroup123 icons.
// However if there is already an icon in the EditorIconRegistry for this
// exact class (not counting parent class icons) we want to use that instead.
bool hasClassIcon = false;
#ifdef TORQUE_TOOLS
hasClassIcon = gEditorIcons.hasIconNoRecurse( pObject );
#endif
// draw the icon associated with the item
if ( !hasClassIcon && item->mState.test(Item::VirtualParent))
{
if ( pGroup != NULL)
{
if (item->isExpanded())
item->mIcon = SimGroup1;
else
item->mIcon = SimGroup2;
}
else
item->mIcon = SimGroup2;
}
if ( !hasClassIcon && item->mState.test(Item::Marked))
{
if (item->isInspectorData())
{
if ( pGroup != NULL )
{
if (item->isExpanded())
item->mIcon = SimGroup3;
else
item->mIcon = SimGroup4;
}
}
}
GFXTexHandle iconHandle;
if ( ( item->mIcon != -1 ) && mIconTable[item->mIcon] )
iconHandle = mIconTable[item->mIcon];
#ifdef TORQUE_TOOLS
else
iconHandle = gEditorIcons.findIcon( item->getObject() );
#endif
if ( iconHandle.isValid() )
{
S32 iconHeight = (mItemHeight - iconHandle.getHeight()) / 2;
S32 oldHeight = drawRect.point.y;
if(iconHeight > 0)
drawRect.point.y += iconHeight;
drawRect.point.x += iconHandle.getWidth();
drawer->drawBitmap( iconHandle, drawRect.point );
drawRect.point.y = oldHeight;
}
}
else
{
S32 icon = item->isExpanded() ? item->mScriptInfo.mExpandedImage : item->mScriptInfo.mNormalImage;
if ( icon )
{
if (mIconTable[icon])
{
S32 iconHeight = (mItemHeight - mIconTable[icon].getHeight()) / 2;
S32 oldHeight = drawRect.point.y;
if(iconHeight > 0)
drawRect.point.y += iconHeight;
drawRect.point.x += mIconTable[icon].getWidth();
drawer->drawBitmap( mIconTable[icon], drawRect.point );
drawRect.point.y = oldHeight;
}
}
}
// Ok, update offset so we can render some text!
drawRect.point.x += newOffset;
// Ok, now we're off to rendering the actual data for the treeview item.
U32 bufLen = 1024; //item->mDataRenderWidth + 1;
char *displayText = (char *)txtBuff.alloc(bufLen);
displayText[bufLen-1] = 0;
item->getDisplayText(bufLen, displayText);
// Draw the rollover/selected bitmap, if one was specified.
drawRect.extent.x = mProfile->mFont->getStrWidth( displayText ) + ( 2 * mTextOffset );
if ( item->mState.test( Item::Selected ) && mTexSelected )
drawer->drawBitmapStretch( mTexSelected, drawRect );
else if ( item->mState.test( Item::MouseOverText ) && mTexRollover )
drawer->drawBitmapStretch( mTexRollover, drawRect );
// Offset a bit so as to space text properly.
drawRect.point.x += mTextOffset;
// Determine what color the font should be.
ColorI fontColor;
fontColor = item->mState.test( Item::Selected ) ? mProfile->mFontColorSEL :
( item->mState.test( Item::MouseOverText ) ? mProfile->mFontColorHL : mProfile->mFontColor );
if (item->mState.test(Item::Selected))
{
drawer->drawRectFill(drawRect, mProfile->mFillColorSEL);
}
else if (item->mState.test(Item::MouseOverText))
{
drawer->drawRectFill(drawRect, mProfile->mFillColorHL);
}
if( item->mState.test(Item::MouseOverText) )
{
fontColor = mProfile->mFontColorHL;
}
drawer->setBitmapModulation( fontColor );
// Center the text horizontally.
S32 height = (mItemHeight - mProfile->mFont->getHeight()) / 2;
if(height > 0)
drawRect.point.y += height;
// JDD - offset by two pixels or so to keep the text from rendering RIGHT ONTOP of the outline
drawRect.point.x += 2;
drawer->drawText( mProfile->mFont, drawRect.point, displayText, mProfile->mFontColors );
if ( mRenamingItem == item && mRenameCtrl )
{
Point2I ctrPos = globalToLocalCoord( drawRect.point );
ctrPos.y -= height;
ctrPos.x -= 2;
Point2I ctrExtent( getWidth() - ctrPos.x, drawRect.extent.y );
mRenameCtrl->setPosition( ctrPos );
mRenameCtrl->setExtent( ctrExtent );
mRenameCtrl->setVisible( true );
}
}
//------------------------------------------------------------------------------
bool GuiTreeViewCtrl::renderTooltip( const Point2I &hoverPos, const Point2I& cursorPos, const char* tipText )
{
Item* item;
BitSet32 flags = 0;
char buf[ 2048 ];
if( _hitTest( cursorPos, item, flags ) && (!item->mTooltip.isEmpty() || mUseInspectorTooltips) )
{
bool render = true;
if( mTooltipOnWidthOnly && !item->hasObjectBasedTooltip() )
{
// Only render tooltip if the item's text is cut off with its
// parent scroll control, unless there is custom object-based
// tooltip information.
GuiScrollCtrl *pScrollParent = dynamic_cast<GuiScrollCtrl*>( getParent() );
if ( pScrollParent )
{
Point2I textStart;
Point2I textExt;
const Point2I pos = globalToLocalCoord(cursorPos);
textStart.y = pos.y / mCellSize.y;
textStart.y *= mCellSize.y;
// The following is taken from _hitTest()
textStart.x = mTabSize * item->mTabLevel;
S32 image = BmpChild;
if((image >= 0) && (image < mProfile->mBitmapArrayRects.size()))
textStart.x += mProfile->mBitmapArrayRects[image].extent.x;
textStart.x += mTextOffset;
textStart.x += getInspectorItemIconsWidth( item );
FrameAllocatorMarker txtAlloc;
U32 bufLen = item->getDisplayTextLength() + 1;
char *buf = (char*)txtAlloc.alloc(bufLen);
item->getDisplayText(bufLen, buf);
textExt.x = mProfile->mFont->getStrWidth(buf);
textExt.y = mProfile->mFont->getHeight();
if( pScrollParent->isRectCompletelyVisible(RectI(textStart, textExt)) )
render = false;
}
}
if( render )
{
if( mUseInspectorTooltips )
{
item->getTooltipText( sizeof( buf ), buf );
tipText = buf;
}
else
{
tipText = item->mTooltip.c_str();
}
}
}
return defaultTooltipRender( cursorPos, cursorPos, tipText );
}
//------------------------------------------------------------------------------
void GuiTreeViewCtrl::clearSelection()
{
if( mDebug ) Con::printf( "clearSelection called" );
while ( !mSelectedItems.empty() )
{
removeSelection( mSelectedItems.last()->mId );
}
mSelectedItems.clear();
mSelected.clear();
onClearSelection();
onClearSelection_callback();
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::lockSelection(bool lock)
{
for(U32 i = 0; i < mSelectedItems.size(); i++)
{
if(mSelectedItems[i]->isInspectorData())
mSelectedItems[i]->getObject()->setLocked(lock);
}
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::hideSelection(bool hide)
{
for(U32 i = 0; i < mSelectedItems.size(); i++)
{
if(mSelectedItems[i]->isInspectorData())
mSelectedItems[i]->getObject()->setHidden(hide);
}
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::toggleLockSelection()
{
for(U32 i = 0; i < mSelectedItems.size(); i++)
{
if( mSelectedItems[i]->isInspectorData() )
{
SimObject* object = mSelectedItems[ i ]->getObject();
object->setLocked( !object->isLocked() );
}
}
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::toggleHideSelection()
{
for(U32 i = 0; i < mSelectedItems.size(); i++)
{
if( mSelectedItems[i]->isInspectorData() )
{
SimObject* object = mSelectedItems[ i ]->getObject();
object->setHidden( !object->isHidden() );
}
}
}
//------------------------------------------------------------------------------
// handles icon assignments
S32 GuiTreeViewCtrl::getIcon(const char * iconString)
{
return -1;
}
//-----------------------------------------------------------------------------
GuiTreeViewCtrl::Item* GuiTreeViewCtrl::addInspectorDataItem(Item *parent, SimObject *obj)
{
S32 icon = getIcon(obj->getClassName());
Item *item = createItem(icon);
item->mState.set(Item::InspectorData);
// Set the item text label flags.
if( !mShowObjectIds )
item->mState.clear( Item::ShowObjectId );
else
item->mState.set( Item::ShowObjectId );
if( !mShowClassNames )
item->mState.clear( Item::ShowClassName );
else
item->mState.set( Item::ShowClassName );
if( !mShowObjectNames )
item->mState.clear( Item::ShowObjectName );
else
item->mState.set( Item::ShowObjectName );
if( !mShowInternalNames )
item->mState.clear( Item::ShowInternalName );
else
item->mState.set( Item::ShowInternalName );
if( mShowClassNameForUnnamedObjects )
item->mState.set( Item::ShowClassNameForUnnamed );
// Deal with child objects...
if(dynamic_cast<SimSet*>(obj))
item->mState.set(Item::VirtualParent);
// Actually store the data!
item->setObject(obj);
// Now add us to the data structure...
if(parent)
{
// Add as child of parent.
if(parent->mChild)
{
Item * traverse = parent->mChild;
while(traverse->mNext)
traverse = traverse->mNext;
traverse->mNext = item;
item->mPrevious = traverse;
}
else
parent->mChild = item;
item->mParent = parent;
}
else
{
// If no parent, add to root.
item->mNext = mRoot;
mRoot = item;
item->mParent = NULL;
}
mFlags.set(RebuildVisible);
return item;
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::unlinkItem(Item * item)
{
if (item->mPrevious)
item->mPrevious->mNext = item->mNext;
if (item->mNext)
item->mNext->mPrevious = item->mPrevious;
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::childSearch(Item * item, SimObject *obj, bool yourBaby)
{
Item * temp = item->mChild;
while (temp)
{
//do you have my baby?
if (temp->isInspectorData())
{
if (temp->getObject() == obj)
yourBaby = false; //probably a child of an inner script
}
yourBaby = childSearch(temp,obj, yourBaby);
temp = temp->mNext;
}
return yourBaby;
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::inspectorSearch(Item * item, Item * parent, SimSet * parentSet, SimSet * newParentSet)
{
if (!parentSet||!newParentSet)
return;
if (item == parent->mNext)
return;
if (item)
{
if (item->isInspectorData())
{
// remove the object from the parentSet and add it to the newParentSet
SimObject* simObj = item->getObject();
if (parentSet->size())
{
SimObject *lastObject = parentSet->last();
parentSet->removeObject(simObj);
parentSet->reOrder(lastObject);
}
else
parentSet->removeObject(simObj);
newParentSet->addObject(simObj);
if (item->mNext)
{
inspectorSearch(item->mNext, parent, parentSet, newParentSet);
return;
}
else
{
// end of children so backing up
if (item->mParent == parent)
return;
else
{
inspectorSearch(item->mParent->mNext, parent, parentSet, newParentSet);
return;
}
}
}
if (item->mChild)
{
inspectorSearch(item->mChild, parent, parentSet, newParentSet);
return;
}
if (item->mNext)
{
inspectorSearch(item->mNext, parent, parentSet, newParentSet);
return;
}
}
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::objectSearch( const SimObject *object, Item **item )
{
for ( U32 i = 0; i < mItems.size(); i++ )
{
Item *pItem = mItems[i];
if ( !pItem )
continue;
SimObject *pObj = pItem->getObject();
if ( pObj && pObj == object )
{
*item = pItem;
return true;
}
}
return false;
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::onVirtualParentBuild(Item *item, bool bForceFullUpdate)
{
if(!item->mState.test(Item::InspectorData))
return true;
// Blast an item if it doesn't have a corresponding SimObject...
if(item->mInspectorInfo.mObject == NULL)
{
removeItem(item->mId);
return false;
}
// Skip the next stuff unless we're expanded...
if(!item->isExpanded() && !bForceFullUpdate && !( item == mRoot && !mShowRoot ) )
return true;
// Verify that we have all the kids we should in here...
SimSet *srcObj = dynamic_cast<SimSet*>(&(*item->mInspectorInfo.mObject));
// If it's not a SimSet... WTF are we doing here?
if(!srcObj)
return true;
// This is slow but probably ok.
for( SimSet::iterator i = srcObj->begin(); i != srcObj->end(); ++ i )
{
SimObject *obj = *i;
// If we can't find it, add it.
// unless it has a parent that is a child that is a script
Item *res = item->findChildByValue(obj);
bool foundChild = true;
// search the children. if any of them are the parent of the object then don't add it.
foundChild = childSearch(item,obj,foundChild);
if(!res && foundChild)
{
if (mDebug) Con::printf( "adding object %i to item %i", obj->getId(), item->mId );
res = addInspectorDataItem(item, obj);
}
if( res )
res->mState.set( Item::RebuildVisited );
}
// Go through our items and purge those that have disappeared from
// the set.
for( Item* ptr = item->mChild; ptr != NULL; )
{
Item* next = ptr->mNext;
if( !ptr->mState.test( Item::RebuildVisited ) )
{
if( mDebug ) Con::printf( "removing item %i for object %i that is no longer in the set",
ptr->mId, ptr->getObject()->getId() );
removeItem( ptr->mId, false );
}
else
ptr->mState.clear( Item::RebuildVisited );
ptr = next;
}
return true;
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::onVirtualParentExpand(Item *item)
{
// Do nothing...
return true;
}
//-----------------------------------------------------------------------------
bool GuiTreeViewCtrl::onVirtualParentCollapse(Item *item)
{
// Do nothing...
return true;
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::inspectObject( SimObject* obj, bool okToEdit )
{
_destroyTree();
mFlags.set( IsEditable, okToEdit );
mFlags.set( IsInspector );
onDefineIcons_callback();
addInspectorDataItem( NULL, obj );
}
//-----------------------------------------------------------------------------
S32 GuiTreeViewCtrl::insertObject( S32 parent, SimObject* obj, bool okToEdit )
{
mFlags.set( IsEditable, okToEdit );
mFlags.set( IsInspector );
//onDefineIcons_callback();
GuiTreeViewCtrl::Item *item = addInspectorDataItem( getItem(parent), obj );
return item->getID();
}
//-----------------------------------------------------------------------------
S32 GuiTreeViewCtrl::findItemByName(const char *name)
{
for (S32 i = 0; i < mItems.size(); i++)
{
if( mItems[i]->mState.test( Item::InspectorData ) )
continue;
if (mItems[i] && dStrcmp(mItems[i]->getText(),name) == 0)
return mItems[i]->mId;
}
return 0;
}
//-----------------------------------------------------------------------------
S32 GuiTreeViewCtrl::findItemByValue(const char *name)
{
for (S32 i = 0; i < mItems.size(); i++)
{
if( mItems[i]->mState.test( Item::InspectorData ) )
continue;
if (mItems[i] && dStrcmp(mItems[i]->getValue(),name) == 0)
return mItems[i]->mId;
}
return 0;
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::sortTree( bool caseSensitive, bool traverseHierarchy, bool parentsFirst )
{
itemSortList( mRoot, caseSensitive, traverseHierarchy, parentsFirst );
}
//-----------------------------------------------------------------------------
StringTableEntry GuiTreeViewCtrl::getTextToRoot( S32 itemId, const char * delimiter )
{
Item * item = getItem(itemId);
if(!item)
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::getTextToRoot: invalid start item id!");
return StringTable->insert("");
}
if(item->isInspectorData())
{
Con::errorf(ConsoleLogEntry::General, "GuiTreeViewCtrl::getTextToRoot: cannot get text to root of inspector data items");
return StringTable->insert("");
}
char bufferOne[1024];
char bufferTwo[1024];
char bufferNodeText[128];
dMemset( bufferOne, 0, sizeof(bufferOne) );
dMemset( bufferTwo, 0, sizeof(bufferTwo) );
dStrcpy( bufferOne, item->getText() );
Item *prevNode = item->mParent;
while ( prevNode )
{
dMemset( bufferNodeText, 0, sizeof(bufferNodeText) );
dStrcpy( bufferNodeText, prevNode->getText() );
dSprintf( bufferTwo, 1024, "%s%s%s",bufferNodeText, delimiter, bufferOne );
dStrcpy( bufferOne, bufferTwo );
dMemset( bufferTwo, 0, sizeof(bufferTwo) );
prevNode = prevNode->mParent;
}
// Return the result, StringTable-ized.
return StringTable->insert( bufferOne, true );
}
//-----------------------------------------------------------------------------
void GuiTreeViewCtrl::setFilterText( const String& text )
{
mFilterText = text;
// Trigger rebuild.
mFlags.set( RebuildVisible );
}
//=============================================================================
// Console Methods.
//=============================================================================
// MARK: ---- Console Methods ----
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, findItemByName, S32, ( const char* text ),,
"Get the ID of the item whose text matches the given @a text.\n\n"
"@param text Item text to match.\n"
"@return ID of the item or -1 if no item matches the given text." )
{
return object->findItemByName( text );
}
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, findItemByValue, S32, ( const char* value ),,
"Get the ID of the item whose value matches @a value.\n\n"
"@param value Value text to match.\n"
"@return ID of the item or -1 if no item has the given value." )
{
return object->findItemByValue( value );
}
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, findChildItemByName, S32, ( S32 parentId, const char* childName ),,
"Get the child item of the given parent item whose text matches @a childName.\n\n"
"@param parentId Item ID of the parent in which to look for the child.\n"
"@param childName Text of the child item to find.\n"
"@return ID of the child item or -1 if no child in @a parentId has the given text @a childName.\n\n"
"@note This method does not recurse, i.e. it only looks for direct children." )
{
if( parentId == 0 )
{
if( !object->getRootItem() )
return 0;
GuiTreeViewCtrl::Item* root = object->getRootItem();
while( root )
{
if( dStricmp( root->getText(), childName ) == 0 )
return root->getID();
root = root->mNext;
}
return 0;
}
else
{
GuiTreeViewCtrl::Item* item = object->getItem( parentId );
if( !item )
{
Con::errorf( "GuiTreeViewCtrl.findChildItemByName - invalid parent ID '%i'", parentId );
return 0;
}
GuiTreeViewCtrl::Item* child = item->findChildByName( childName );
if( !child )
return 0;
return child->mId;
}
}
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, insertItem, S32, ( S32 parentId, const char* text, const char* value, const char* icon, S32 normalImage, S32 expandedImage ), ( "", "", 0, 0 ),
"Add a new item to the tree.\n\n"
"@param parentId Item ID of parent to which to add the item as a child. 0 is root item.\n"
"@param text Text to display on the item in the tree.\n"
"@param value Behind-the-scenes value of the item.\n"
"@param icon\n"
"@param normalImage\n"
"@param expandedImage\n"
"@return The ID of the newly added item." )
{
return object->insertItem( parentId, text, value, icon, normalImage, expandedImage );
}
DefineEngineMethod( GuiTreeViewCtrl, insertObject, S32, ( S32 parentId, SimObject* obj, bool OKToEdit ), (false), "Inserts object as a child to the given parent." )
{
return object->insertObject(parentId, obj, OKToEdit);
}
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, lockSelection, void, ( bool lock ), ( true ),
"Set whether the current selection can be changed by the user or not.\n\n"
"@param lock If true, the current selection is frozen and cannot be changed. If false, "
"the selection may be modified." )
{
object->lockSelection( lock );
}
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, hideSelection, void, ( bool state ), ( true ),
"Call SimObject::setHidden( @a state ) on all objects in the current selection.\n\n"
"@param state Visibility state to set objects in selection to." )
{
object->hideSelection( state );
}
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, toggleLockSelection, void, (),,
"Toggle the locked state of all objects in the current selection." )
{
object->toggleLockSelection();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, toggleHideSelection, void, (),,
"Toggle the hidden state of all objects in the current selection." )
{
object->toggleHideSelection();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, clearSelection, void, (),,
"Unselect all currently selected items." )
{
object->clearSelection();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, deleteSelection, void, (),,
"Delete all items/objects in the current selection." )
{
object->deleteSelection();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, addSelection, void, ( S32 id, bool isLastSelection ), ( true ),
"Add an item/object to the current selection.\n\n"
"@param id ID of item/object to add to the selection.\n"
"@param isLastSelection Whether there are more pending items/objects to be added to the selection. If false, "
"the control will defer refreshing the tree and wait until addSelection() is called with this parameter set "
"to true." )
{
object->addSelection( id, isLastSelection, isLastSelection );
}
DefineConsoleMethod(GuiTreeViewCtrl, addChildSelectionByValue, void, (S32 id, const char * tableEntry), , "addChildSelectionByValue(TreeItemId parent, value)")
{
GuiTreeViewCtrl::Item* parentItem = object->getItem(id);
GuiTreeViewCtrl::Item* child = parentItem->findChildByValue(tableEntry);
object->addSelection(child->getID());
}
DefineConsoleMethod(GuiTreeViewCtrl, removeSelection, void, (S32 id), , "(deselects an item)")
{
object->removeSelection(id);
}
DefineConsoleMethod(GuiTreeViewCtrl, removeChildSelectionByValue, void, (S32 id, const char * tableEntry), , "removeChildSelectionByValue(TreeItemId parent, value)")
{
GuiTreeViewCtrl::Item* parentItem = object->getItem(id);
if(parentItem)
{
GuiTreeViewCtrl::Item* child = parentItem->findChildByValue(tableEntry);
if(child)
{
object->removeSelection(child->getID());
}
}
}
DefineConsoleMethod(GuiTreeViewCtrl, selectItem, bool, (S32 id, bool select), (true), "(TreeItemId item, bool select=true)")
{
return object->setItemSelected(id, select);
}
DefineConsoleMethod(GuiTreeViewCtrl, expandItem, bool, (S32 id, bool expand), (true), "(TreeItemId item, bool expand=true)")
{
return(object->setItemExpanded(id, expand));
}
DefineConsoleMethod(GuiTreeViewCtrl, markItem, bool, (S32 id, bool mark), (true), "(TreeItemId item, bool mark=true)")
{
return object->markItem(id, mark);
}
// Make the given item visible.
DefineConsoleMethod(GuiTreeViewCtrl, scrollVisible, void, (S32 itemId), , "(TreeItemId item)")
{
object->scrollVisible(itemId);
}
DefineConsoleMethod(GuiTreeViewCtrl, buildIconTable, bool, (const char * icons), , "(builds an icon table)")
{
return object->buildIconTable(icons);
}
DefineConsoleMethod( GuiTreeViewCtrl, open, void, (const char * objName, bool okToEdit), (true), "(SimSet obj, bool okToEdit=true) Set the root of the tree view to the specified object, or to the root set.")
{
SimSet *treeRoot = NULL;
SimObject* target = Sim::findObject(objName);
if (target)
treeRoot = dynamic_cast<SimSet*>(target);
if (! treeRoot)
Sim::findObject(RootGroupId, treeRoot);
object->inspectObject(treeRoot,okToEdit);
}
DefineConsoleMethod( GuiTreeViewCtrl, setItemTooltip, void, ( S32 id, const char * text ), , "( int id, string text ) - Set the tooltip to show for the given item." )
{
GuiTreeViewCtrl::Item* item = object->getItem( id );
if( !item )
{
Con::errorf( "GuiTreeViewCtrl::setTooltip() - invalid item id '%i'", id );
return;
}
item->mTooltip = text;
}
DefineConsoleMethod( GuiTreeViewCtrl, setItemImages, void, ( S32 id, S8 normalImage, S8 expandedImage ), , "( int id, int normalImage, int expandedImage ) - Sets the normal and expanded images to show for the given item." )
{
GuiTreeViewCtrl::Item* item = object->getItem( id );
if( !item )
{
Con::errorf( "GuiTreeViewCtrl::setItemImages() - invalid item id '%i'", id );
return;
}
item->setNormalImage(normalImage);
item->setExpandedImage(expandedImage);
}
DefineConsoleMethod( GuiTreeViewCtrl, isParentItem, bool, ( S32 id ), , "( int id ) - Returns true if the given item contains child items." )
{
if( !id && object->getItemCount() )
return true;
GuiTreeViewCtrl::Item* item = object->getItem( id );
if( !item )
{
Con::errorf( "GuiTreeViewCtrl::isParentItem - invalid item id '%i'", id );
return false;
}
return item->isParent();
}
DefineConsoleMethod(GuiTreeViewCtrl, getItemText, const char *, (S32 index), , "(TreeItemId item)")
{
return object->getItemText(index);
}
DefineConsoleMethod(GuiTreeViewCtrl, getItemValue, const char *, (S32 itemId), , "(TreeItemId item)")
{
return object->getItemValue(itemId);
}
DefineConsoleMethod(GuiTreeViewCtrl, editItem, bool, (S32 item, const char * newText, const char * newValue), , "(TreeItemId item, string newText, string newValue)")
{
return(object->editItem(item, newText, newValue));
}
DefineConsoleMethod(GuiTreeViewCtrl, removeItem, bool, (S32 itemId), , "(TreeItemId item)")
{
return(object->removeItem(itemId));
}
DefineConsoleMethod(GuiTreeViewCtrl, removeAllChildren, void, (S32 itemId), , "removeAllChildren(TreeItemId parent)")
{
object->removeAllChildren(itemId);
}
DefineConsoleMethod(GuiTreeViewCtrl, clear, void, (), , "() - empty tree")
{
object->removeItem(0);
}
DefineConsoleMethod(GuiTreeViewCtrl, getFirstRootItem, S32, (), , "Get id for root item.")
{
return(object->getFirstRootItem());
}
DefineConsoleMethod(GuiTreeViewCtrl, getChild, S32, (S32 itemId), , "(TreeItemId item)")
{
return(object->getChildItem(itemId));
}
DefineConsoleMethod(GuiTreeViewCtrl, buildVisibleTree, void, (bool forceFullUpdate), (false), "Build the visible tree")
{
object->buildVisibleTree( forceFullUpdate );
}
//FIXME: [rene 11/09/09 - This clashes with GuiControl.getParent(); bad thing; should be getParentItem]
DefineConsoleMethod(GuiTreeViewCtrl, getParentItem, S32, (S32 itemId), , "(TreeItemId item)")
{
return(object->getParentItem(itemId));
}
DefineConsoleMethod(GuiTreeViewCtrl, getNextSibling, S32, (S32 itemId), , "(TreeItemId item)")
{
return(object->getNextSiblingItem(itemId));
}
DefineConsoleMethod(GuiTreeViewCtrl, getPrevSibling, S32, (S32 itemId), , "(TreeItemId item)")
{
return(object->getPrevSiblingItem(itemId));
}
DefineConsoleMethod(GuiTreeViewCtrl, getItemCount, S32, (), , "")
{
return(object->getItemCount());
}
DefineConsoleMethod(GuiTreeViewCtrl, getSelectedItem, S32, ( S32 index ), (0), "( int index=0 ) - Return the selected item at the given index.")
{
return ( object->getSelectedItem( index ) );
}
DefineConsoleMethod(GuiTreeViewCtrl, getSelectedObject, S32, ( S32 index ), (0), "( int index=0 ) - Return the currently selected SimObject at the given index in inspector mode or -1")
{
GuiTreeViewCtrl::Item *item = object->getItem( object->getSelectedItem( index ) );
if( item != NULL && item->isInspectorData() )
{
SimObject *obj = item->getObject();
if( obj != NULL )
return obj->getId();
}
return -1;
}
const char* GuiTreeViewCtrl::getSelectedObjectList()
{
char* buff = Con::getReturnBuffer(1024);
dSprintf(buff,1024,"");
const Vector< GuiTreeViewCtrl::Item* > selectedItems = this->getSelectedItems();
for(int i = 0; i < selectedItems.size(); i++)
{
GuiTreeViewCtrl::Item *item = selectedItems[i];
if ( item->isInspectorData() && item->getObject() )
{
S32 id = item->getObject()->getId();
//get the current length of the buffer
U32 len = dStrlen(buff);
//the start of the buffer where we want to write
char* buffPart = buff+len;
//the size of the remaining buffer (-1 cause dStrlen doesn't count the \0)
S32 size = 1024-len-1;
//write it:
if(size < 1)
{
Con::errorf("GuiTreeViewCtrl::getSelectedItemList - Not enough room to return our object list");
return buff;
}
dSprintf(buffPart,size,"%d ", id);
}
}
return buff;
}
DefineConsoleMethod(GuiTreeViewCtrl, getSelectedObjectList, const char*, (), ,
"Returns a space sperated list of all selected object ids.")
{
char* buff = Con::getReturnBuffer(1024);
dSprintf(buff,1024,"");
const Vector< GuiTreeViewCtrl::Item* > selectedItems = object->getSelectedItems();
for(int i = 0; i < selectedItems.size(); i++)
{
GuiTreeViewCtrl::Item *item = selectedItems[i];
if ( item->isInspectorData() && item->getObject() )
{
S32 id = item->getObject()->getId();
//get the current length of the buffer
U32 len = dStrlen(buff);
//the start of the buffer where we want to write
char* buffPart = buff+len;
//the size of the remaining buffer (-1 cause dStrlen doesn't count the \0)
S32 size = 1024-len-1;
//write it:
if(size < 1)
{
Con::errorf("GuiTreeViewCtrl::getSelectedItemList - Not enough room to return our object list");
return buff;
}
dSprintf(buffPart,size,"%d ", id);
}
}
return buff;
}
DefineConsoleMethod(GuiTreeViewCtrl, moveItemUp, void, (S32 index), , "(TreeItemId item)")
{
object->moveItemUp( index );
}
DefineConsoleMethod(GuiTreeViewCtrl, getSelectedItemsCount, S32, (), , "")
{
return ( object->getSelectedItemsCount() );
}
DefineConsoleMethod(GuiTreeViewCtrl, moveItemDown, void, (S32 index), , "(TreeItemId item)")
{
object->moveItemDown( index );
}
//-----------------------------------------------------------------------------
DefineConsoleMethod(GuiTreeViewCtrl, getTextToRoot, const char*, (S32 itemId, const char * delimiter), ,
"(TreeItemId item,Delimiter=none) gets the text from the current node to the root, concatenating at each branch upward, with a specified delimiter optionally")
{
if ( delimiter == "" )
{
Con::warnf("GuiTreeViewCtrl::getTextToRoot - Invalid number of arguments!");
return ("");
}
return object->getTextToRoot( itemId, delimiter );
}
DefineConsoleMethod(GuiTreeViewCtrl, getSelectedItemList,const char*, (), ,"returns a space seperated list of mulitple item ids")
{
char* buff = Con::getReturnBuffer(1024);
dSprintf(buff,1024,"");
const Vector< S32 >& selected = object->getSelected();
for(int i = 0; i < selected.size(); i++)
{
S32 id = selected[i];
//get the current length of the buffer
U32 len = dStrlen(buff);
//the start of the buffer where we want to write
char* buffPart = buff+len;
//the size of the remaining buffer (-1 cause dStrlen doesn't count the \0)
S32 size = 1024-len-1;
//write it:
if(size < 1)
{
Con::errorf("GuiTreeViewCtrl::getSelectedItemList - Not enough room to return our object list");
return buff;
}
dSprintf(buffPart,size,"%d ", id);
}
//mSelected
return buff;
}
S32 GuiTreeViewCtrl::findItemByObjectId(S32 iObjId)
{
for (S32 i = 0; i < mItems.size(); i++)
{
if ( !mItems[i] )
continue;
SimObject* pObj = mItems[i]->getObject();
if( pObj && pObj->getId() == iObjId )
return mItems[i]->mId;
}
return 0;
}
//------------------------------------------------------------------------------
DefineConsoleMethod(GuiTreeViewCtrl, findItemByObjectId, S32, ( S32 itemId ), , "(find item by object id and returns the mId)")
{
return(object->findItemByObjectId(itemId));
}
//------------------------------------------------------------------------------
bool GuiTreeViewCtrl::scrollVisibleByObjectId(S32 objID)
{
S32 itemID = findItemByObjectId(objID);
if(itemID == -1)
{
// we did not find the item in our current items
// we should try to find and show the parent of the item.
SimObject *obj = Sim::findObject(objID);
if(!obj || !obj->getGroup())
return false;
// if we can't show the parent, we fail.
if(! scrollVisibleByObjectId(obj->getGroup()->getId()) )
return false;
// get the parent. expand the parent. rebuild the tree. this ensures that
// we'll be able to find the child item we're targeting.
S32 parentID = findItemByObjectId(obj->getGroup()->getId());
AssertFatal(parentID != -1, "We were able to show the parent, but could not then find the parent. This should not happen.");
Item *parentItem = getItem(parentID);
parentItem->setExpanded(true);
buildVisibleTree();
// NOW we should be able to find the object. if not... something's wrong.
itemID = findItemByObjectId(objID);
AssertWarn(itemID != -1,"GuiTreeViewCtrl::scrollVisibleByObjectId() found the parent, but can't find it's immediate child. This should not happen.");
if(itemID == -1)
return false;
}
// ok, item found. scroll to it.
mFlags.set( RebuildVisible );
scrollVisible(itemID);
return true;
}
//------------------------------------------------------------------------------
DefineConsoleMethod(GuiTreeViewCtrl, scrollVisibleByObjectId, S32, ( S32 itemId ), , "(show item by object id. returns true if sucessful.)")
{
return(object->scrollVisibleByObjectId(itemId));
}
//------------------------------------------------------------------------------
//FIXME: this clashes with SimSet.sort()
DefineConsoleMethod( GuiTreeViewCtrl, sort, void, ( S32 parent, bool traverseHierarchy, bool parentsFirst, bool caseSensitive ), ( 0, false, false, true ),
"( int parent, bool traverseHierarchy=false, bool parentsFirst=false, bool caseSensitive=true ) - Sorts all items of the given parent (or root). With 'hierarchy', traverses hierarchy." )
{
if( !parent )
object->sortTree( caseSensitive, traverseHierarchy, parentsFirst );
else
{
GuiTreeViewCtrl::Item* item = object->getItem( parent );
if( !item )
{
Con::errorf( "GuiTreeViewCtrl::sort - no item '%i' in tree", parent );
return;
}
item->sort( caseSensitive, traverseHierarchy, parentsFirst );
}
}
void GuiTreeViewCtrl::cancelRename()
{
if ( !mRenamingItem || !mRenameCtrl )
return;
mRenamingItem = NULL;
if ( mRenameCtrl )
mRenameCtrl->clearFirstResponder();
}
void GuiTreeViewCtrl::onRenameValidate()
{
if ( !mRenamingItem || !mRenameCtrl )
return;
char data[ GuiTextCtrl::MAX_STRING_LENGTH+1 ];
mRenameCtrl->getText( data );
SimObject *obj = mRenamingItem->getObject();
mRenamingItem = NULL;
// Object could have been deleted in the interum.
if ( !obj )
return;
if( isMethod( "handleRenameObject" ) && handleRenameObject_callback( data, obj ) )
return;
if ( mRenameInternal )
obj->setInternalName( data );
else
#ifdef TORQUE_TOOLS
if ( validateObjectName( data, obj ) )
#endif
obj->assignName( data );
}
void GuiTreeViewCtrl::showItemRenameCtrl( Item* item )
{
SimObject *renameObj = item->getObject();
mRenamingItem = item;
if ( !mRenameCtrl )
{
mRenameCtrl = new GuiTextEditCtrl;
mRenameCtrl->registerObject();
addObject( mRenameCtrl );
if ( mRenameInternal )
mRenameCtrl->setText( renameObj->getInternalName() );
else
mRenameCtrl->setText( renameObj->getName() );
mRenameCtrl->setFirstResponder();
mRenameCtrl->setSinkAllKeys(true);
mRenameCtrl->selectAllText();
mRenameCtrl->setCursorPos(0);
char cmd[256];
dSprintf( cmd, 256, "%i.onRenameValidate();", getId() );
mRenameCtrl->setField( "validate", cmd );
dSprintf( cmd, 256, "%i.cancelRename();", getId() );
mRenameCtrl->setField( "escapeCommand", cmd );
}
}
DefineConsoleMethod( GuiTreeViewCtrl, cancelRename, void, (), , "For internal use." )
{
object->cancelRename();
}
DefineConsoleMethod( GuiTreeViewCtrl, onRenameValidate, void, (), , "For internal use." )
{
object->onRenameValidate();
}
DefineConsoleMethod( GuiTreeViewCtrl, showItemRenameCtrl, void, ( S32 id ), , "( TreeItemId id ) - Show the rename text field for the given item (only one at a time)." )
{
GuiTreeViewCtrl::Item* item = object->getItem( id );
if( !item )
{
Con::errorf( "GuiTreeViewCtrl::showItemRenameCtrl - invalid item id '%i'", id );
return;
}
object->showItemRenameCtrl( item );
}
DefineConsoleMethod( GuiTreeViewCtrl, setDebug, void, ( bool value ), (true), "( bool value=true ) - Enable/disable debug output." )
{
object->setDebug( value );
}
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, isItemSelected, bool, ( S32 id ),,
"Check whether the given item is currently selected in the tree.\n\n"
"@param id Item/object ID.\n"
"@return True if the given item/object is currently selected in the tree." )
{
const Vector< GuiTreeViewCtrl::Item* >& selectedItems = object->getSelectedItems();
for( S32 i = 0; i < selectedItems.size(); ++ i )
if( selectedItems[ i ]->mId == id )
return true;
return false;
}
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, getFilterText, const char*, (),,
"Get the current filter expression. Only tree items whose text matches this expression "
"are displayed. By default, the expression is empty and all items are shown.\n\n"
"@return The current filter pattern or an empty string if no filter pattern is currently active.\n\n"
"@see setFilterText\n"
"@see clearFilterText" )
{
return object->getFilterText();
}
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, setFilterText, void, ( const char* pattern ),,
"Set the pattern by which to filter items in the tree. Only items in the tree whose text "
"matches this pattern are displayed.\n\n"
"@param pattern New pattern based on which visible items in the tree should be filtered. If empty, all items become visible.\n\n"
"@see getFilterText\n"
"@see clearFilterText" )
{
object->setFilterText( pattern );
}
//-----------------------------------------------------------------------------
DefineEngineMethod( GuiTreeViewCtrl, clearFilterText, void, (),,
"Clear the current item filtering pattern.\n\n"
"@see setFilterText\n"
"@see getFilterText" )
{
object->clearFilterText();
}
//---------------DNTC AUTO-GENERATED---------------//
#include <vector>
#include <string>
#include "core/strings/stringFunctions.h"
//---------------DO NOT MODIFY CODE BELOW----------//
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_addChildSelectionByValue(char * x__object, S32 id, char * x__tableEntry)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
const char* tableEntry = (const char*)x__tableEntry;
{
GuiTreeViewCtrl::Item* parentItem = object->getItem(id);
GuiTreeViewCtrl::Item* child = parentItem->findChildByValue(tableEntry);
object->addSelection(child->getID());
}
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_buildIconTable(char * x__object, char * x__icons)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return 0;
const char* icons = (const char*)x__icons;
bool wle_returnObject;
{
{wle_returnObject =object->buildIconTable(icons);
return (S32)(wle_returnObject);}
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_buildVisibleTree(char * x__object, bool forceFullUpdate)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->buildVisibleTree( forceFullUpdate );
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_cancelRename(char * x__object)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->cancelRename();
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_clear(char * x__object)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->removeItem(0);
}
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_editItem(char * x__object, S32 item, char * x__newText, char * x__newValue)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return 0;
const char* newText = (const char*)x__newText;
const char* newValue = (const char*)x__newValue;
bool wle_returnObject;
{
{wle_returnObject =(object->editItem(item, newText, newValue));
return (S32)(wle_returnObject);}
}
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_expandItem(char * x__object, S32 id, bool expand)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return 0;
bool wle_returnObject;
{
{wle_returnObject =(object->setItemExpanded(id, expand));
return (S32)(wle_returnObject);}
}
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_findItemByObjectId(char * x__object, S32 itemId)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
{
return (S32)((object->findItemByObjectId(itemId)));
};
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_getChild(char * x__object, S32 itemId)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
{
return (S32)((object->getChildItem(itemId)));
};
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_getFirstRootItem(char * x__object)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
{
return (S32)((object->getFirstRootItem()));
};
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_getItemCount(char * x__object)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
{
return (S32)((object->getItemCount()));
};
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_getItemText(char * x__object, S32 index, char* retval)
{
dSprintf(retval,16384,"");
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
const char * wle_returnObject;
{
{wle_returnObject =object->getItemText(index);
if (!wle_returnObject)
return;
dSprintf(retval,16384,"%s",wle_returnObject);
return;
}
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_getItemValue(char * x__object, S32 itemId, char* retval)
{
dSprintf(retval,16384,"");
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
const char * wle_returnObject;
{
{wle_returnObject =object->getItemValue(itemId);
if (!wle_returnObject)
return;
dSprintf(retval,16384,"%s",wle_returnObject);
return;
}
}
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_getNextSibling(char * x__object, S32 itemId)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
{
return (S32)((object->getNextSiblingItem(itemId)));
};
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_getParentItem(char * x__object, S32 itemId)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
{
return (S32)((object->getParentItem(itemId)));
};
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_getPrevSibling(char * x__object, S32 itemId)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
{
return (S32)((object->getPrevSiblingItem(itemId)));
};
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_getSelectedItem(char * x__object, S32 index)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
{
return (S32)( ( object->getSelectedItem( index ) ));
};
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_getSelectedItemList(char * x__object, char* retval)
{
dSprintf(retval,16384,"");
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
const char* wle_returnObject;
{
char* buff = Con::getReturnBuffer(1024);
dSprintf(buff,1024,"");
const Vector< S32 >& selected = object->getSelected();
for(int i = 0; i < selected.size(); i++)
{
S32 id = selected[i];
U32 len = dStrlen(buff);
char* buffPart = buff+len;
S32 size = 1024-len-1;
if(size < 1)
{
Con::errorf("GuiTreeViewCtrl::getSelectedItemList - Not enough room to return our object list");
{wle_returnObject =buff;
if (!wle_returnObject)
return;
dSprintf(retval,16384,"%s",wle_returnObject);
return;
}
}
dSprintf(buffPart,size,"%d ", id);
}
{wle_returnObject =buff;
if (!wle_returnObject)
return;
dSprintf(retval,16384,"%s",wle_returnObject);
return;
}
}
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_getSelectedItemsCount(char * x__object)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
{
return (S32)( ( object->getSelectedItemsCount() ));
};
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_getSelectedObject(char * x__object, S32 index)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
{
GuiTreeViewCtrl::Item *item = object->getItem( object->getSelectedItem( index ) );
if( item != NULL && item->isInspectorData() )
{
SimObject *obj = item->getObject();
if( obj != NULL )
return (S32)( obj->getId());
}
return (S32)( -1);
};
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_getSelectedObjectList(char * x__object, char* retval)
{
dSprintf(retval,16384,"");
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
const char* wle_returnObject;
{
char* buff = Con::getReturnBuffer(1024);
dSprintf(buff,1024,"");
const Vector< GuiTreeViewCtrl::Item* > selectedItems = object->getSelectedItems();
for(int i = 0; i < selectedItems.size(); i++)
{
GuiTreeViewCtrl::Item *item = selectedItems[i];
if ( item->isInspectorData() && item->getObject() )
{
S32 id = item->getObject()->getId();
U32 len = dStrlen(buff);
char* buffPart = buff+len;
S32 size = 1024-len-1;
if(size < 1)
{
Con::errorf("GuiTreeViewCtrl::getSelectedItemList - Not enough room to return our object list");
{wle_returnObject =buff;
if (!wle_returnObject)
return;
dSprintf(retval,16384,"%s",wle_returnObject);
return;
}
}
dSprintf(buffPart,size,"%d ", id);
}
}
{wle_returnObject =buff;
if (!wle_returnObject)
return;
dSprintf(retval,16384,"%s",wle_returnObject);
return;
}
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_getTextToRoot(char * x__object, S32 itemId, char * x__delimiter, char* retval)
{
dSprintf(retval,16384,"");
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
const char* delimiter = (const char*)x__delimiter;
const char* wle_returnObject;
{
if ( delimiter == "" )
{
Con::warnf("GuiTreeViewCtrl::getTextToRoot - Invalid number of arguments!");
{wle_returnObject =("");
if (!wle_returnObject)
return;
dSprintf(retval,16384,"%s",wle_returnObject);
return;
}
}
{wle_returnObject =object->getTextToRoot( itemId, delimiter );
if (!wle_returnObject)
return;
dSprintf(retval,16384,"%s",wle_returnObject);
return;
}
}
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_isParentItem(char * x__object, S32 id)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return 0;
bool wle_returnObject;
{
if( !id && object->getItemCount() )
{wle_returnObject =true;
return (S32)(wle_returnObject);}
GuiTreeViewCtrl::Item* item = object->getItem( id );
if( !item )
{
Con::errorf( "GuiTreeViewCtrl::isParentItem - invalid item id '%i'", id );
{wle_returnObject =false;
return (S32)(wle_returnObject);}
}
{wle_returnObject =item->isParent();
return (S32)(wle_returnObject);}
}
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_markItem(char * x__object, S32 id, bool mark)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return 0;
bool wle_returnObject;
{
{wle_returnObject =object->markItem(id, mark);
return (S32)(wle_returnObject);}
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_moveItemDown(char * x__object, S32 index)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->moveItemDown( index );
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_moveItemUp(char * x__object, S32 index)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->moveItemUp( index );
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_onRenameValidate(char * x__object)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->onRenameValidate();
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_open(char * x__object, char * x__objName, bool okToEdit)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
const char* objName = (const char*)x__objName;
{
SimSet *treeRoot = NULL;
SimObject* target = Sim::findObject(objName);
if (target)
treeRoot = dynamic_cast<SimSet*>(target);
if (! treeRoot)
Sim::findObject(RootGroupId, treeRoot);
object->inspectObject(treeRoot,okToEdit);
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_removeAllChildren(char * x__object, S32 itemId)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->removeAllChildren(itemId);
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_removeChildSelectionByValue(char * x__object, S32 id, char * x__tableEntry)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
const char* tableEntry = (const char*)x__tableEntry;
{
GuiTreeViewCtrl::Item* parentItem = object->getItem(id);
if(parentItem)
{
GuiTreeViewCtrl::Item* child = parentItem->findChildByValue(tableEntry);
if(child)
{
object->removeSelection(child->getID());
}
}
}
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_removeItem(char * x__object, S32 itemId)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return 0;
bool wle_returnObject;
{
{wle_returnObject =(object->removeItem(itemId));
return (S32)(wle_returnObject);}
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_removeSelection(char * x__object, S32 id)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->removeSelection(id);
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_scrollVisible(char * x__object, S32 itemId)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->scrollVisible(itemId);
}
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_scrollVisibleByObjectId(char * x__object, S32 itemId)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
{
return (S32)((object->scrollVisibleByObjectId(itemId)));
};
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fn_GuiTreeViewCtrl_selectItem(char * x__object, S32 id, bool select)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return 0;
bool wle_returnObject;
{
{wle_returnObject =object->setItemSelected(id, select);
return (S32)(wle_returnObject);}
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_setDebug(char * x__object, bool value)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->setDebug( value );
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_setItemImages(char * x__object, S32 id, S8 normalImage, S8 expandedImage)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
GuiTreeViewCtrl::Item* item = object->getItem( id );
if( !item )
{
Con::errorf( "GuiTreeViewCtrl::setItemImages() - invalid item id '%i'", id );
return;
}
item->setNormalImage(normalImage);
item->setExpandedImage(expandedImage);
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_setItemTooltip(char * x__object, S32 id, char * x__text)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
const char* text = (const char*)x__text;
{
GuiTreeViewCtrl::Item* item = object->getItem( id );
if( !item )
{
Con::errorf( "GuiTreeViewCtrl::setTooltip() - invalid item id '%i'", id );
return;
}
item->mTooltip = text;
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_showItemRenameCtrl(char * x__object, S32 id)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
GuiTreeViewCtrl::Item* item = object->getItem( id );
if( !item )
{
Con::errorf( "GuiTreeViewCtrl::showItemRenameCtrl - invalid item id '%i'", id );
return;
}
object->showItemRenameCtrl( item );
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fn_GuiTreeViewCtrl_sort(char * x__object, S32 parent, bool traverseHierarchy, bool parentsFirst, bool caseSensitive)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
if( !parent )
object->sortTree( caseSensitive, traverseHierarchy, parentsFirst );
else
{
GuiTreeViewCtrl::Item* item = object->getItem( parent );
if( !item )
{
Con::errorf( "GuiTreeViewCtrl::sort - no item '%i' in tree", parent );
return;
}
item->sort( caseSensitive, traverseHierarchy, parentsFirst );
}
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fnGuiTreeViewCtrl_addSelection(char * x__object, S32 id, bool isLastSelection)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->addSelection( id, isLastSelection, isLastSelection );
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fnGuiTreeViewCtrl_clearFilterText(char * x__object)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->clearFilterText();
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fnGuiTreeViewCtrl_clearSelection(char * x__object)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->clearSelection();
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fnGuiTreeViewCtrl_deleteSelection(char * x__object)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->deleteSelection();
}
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fnGuiTreeViewCtrl_findChildItemByName(char * x__object, S32 parentId, char * x__childName)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
const char* childName = (const char*)x__childName;
{
if( parentId == 0 )
{
if( !object->getRootItem() )
return (S32)( 0);
GuiTreeViewCtrl::Item* root = object->getRootItem();
while( root )
{
if( dStricmp( root->getText(), childName ) == 0 )
return (S32)( root->getID());
root = root->mNext;
}
return (S32)( 0);
}
else
{
GuiTreeViewCtrl::Item* item = object->getItem( parentId );
if( !item )
{
Con::errorf( "GuiTreeViewCtrl.findChildItemByName - invalid parent ID '%i'", parentId );
return (S32)( 0);
}
GuiTreeViewCtrl::Item* child = item->findChildByName( childName );
if( !child )
return (S32)( 0);
return (S32)( child->mId);
}
};
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fnGuiTreeViewCtrl_findItemByName(char * x__object, char * x__text)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
const char* text = (const char*)x__text;
{
return (S32)( object->findItemByName( text ));
};
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fnGuiTreeViewCtrl_findItemByValue(char * x__object, char * x__value)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
const char* value = (const char*)x__value;
{
return (S32)( object->findItemByValue( value ));
};
}
extern "C" __declspec(dllexport) void __cdecl wle_fnGuiTreeViewCtrl_getFilterText(char * x__object, char* retval)
{
dSprintf(retval,16384,"");
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
const char* wle_returnObject;
{
{wle_returnObject =object->getFilterText();
if (!wle_returnObject)
return;
dSprintf(retval,16384,"%s",wle_returnObject);
return;
}
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fnGuiTreeViewCtrl_hideSelection(char * x__object, bool state)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->hideSelection( state );
}
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fnGuiTreeViewCtrl_insertItem(char * x__object, S32 parentId, char * x__text, char * x__value, char * x__icon, S32 normalImage, S32 expandedImage)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
const char* text = (const char*)x__text;
const char* value = (const char*)x__value;
const char* icon = (const char*)x__icon;
{
return (S32)( object->insertItem( parentId, text, value, icon, normalImage, expandedImage ));
};
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fnGuiTreeViewCtrl_insertObject(char * x__object, S32 parentId, char * x__obj, bool OKToEdit)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return (S32)( 0);
SimObject* obj; Sim::findObject(x__obj, obj );
{
return object->insertObject(parentId, obj, OKToEdit);
};
}
extern "C" __declspec(dllexport) S32 __cdecl wle_fnGuiTreeViewCtrl_isItemSelected(char * x__object, S32 id)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return 0;
bool wle_returnObject;
{
const Vector< GuiTreeViewCtrl::Item* >& selectedItems = object->getSelectedItems();
for( S32 i = 0; i < selectedItems.size(); ++ i )
if( selectedItems[ i ]->mId == id )
{wle_returnObject =true;
return (S32)(wle_returnObject);}
{wle_returnObject =false;
return (S32)(wle_returnObject);}
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fnGuiTreeViewCtrl_lockSelection(char * x__object, bool lock)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->lockSelection( lock );
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fnGuiTreeViewCtrl_setFilterText(char * x__object, char * x__pattern)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
const char* pattern = (const char*)x__pattern;
{
object->setFilterText( pattern );
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fnGuiTreeViewCtrl_toggleHideSelection(char * x__object)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->toggleHideSelection();
}
}
extern "C" __declspec(dllexport) void __cdecl wle_fnGuiTreeViewCtrl_toggleLockSelection(char * x__object)
{
GuiTreeViewCtrl* object; Sim::findObject(x__object, object );
if (!object)
return;
{
object->toggleLockSelection();
}
}
//---------------END DNTC AUTO-GENERATED-----------//
| [
"[email protected]"
] | |
7b16b1078b60352bafa50acb61162b7cb13403c8 | 897633afb50a5ddc0e9f6ec373253044041ec508 | /GrpNVMDatasetMgmtCmd/grpDefs.h | 340c91c98ab0aa22292407ececdb04841e9de176 | [
"Apache-2.0"
] | permissive | dtseng-zz/tnvme | 556791cbffa41329231a896ef40a07173ce79c13 | 3387cf70f748a46632b9824a36616fe06e1893f1 | refs/heads/master | 2021-05-29T03:51:08.857145 | 2012-05-21T16:41:21 | 2012-05-21T16:41:21 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 986 | h | /*
* Copyright (c) 2011, Intel Corporation.
*
* 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 _GRPDEFS_H_
#define _GRPDEFS_H_
namespace GrpNVMDatasetMgmtCmd {
#define ACQ_GROUP_ID "ACQ"
#define ASQ_GROUP_ID "ASQ"
#define IOCQ_GROUP_ID "IOCQ"
#define IOSQ_GROUP_ID "IOSQ"
#define IOQ_ID 1
#define DEFAULT_CMD_WAIT_ms SYSTEMWIDE_CMD_WAIT_ms
} // namespace
#endif
| [
"[email protected]"
] | |
c4786389f4e538b143b24db082f7b0719103dc3e | ca33a0ad16a8b921507bfa94621c9117d3dccb7a | /CTDL/TempDG.h | 0b81654d6f7bacdcb367b74b23d2083cbe3edd6a | [] | no_license | httuyen/Data-structures-and-algorithms-Library-management | 59b3f21976b32fdd5d5d44b02273427128cb67e2 | 4af80ad82a09fa1e1e3ae300923800337ec2d562 | refs/heads/master | 2023-06-18T04:35:29.602705 | 2021-07-17T19:32:58 | 2021-07-17T19:32:58 | 198,051,217 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,487 | h | #pragma once
#include <iostream>
#include "Macro.h"
#include "DauSach.h"
using std::string;
struct TenHo
{
string hoten;
int MADG;
};
struct TempDG
{
int index;
int MADG;
};
struct NodeTempDG
{
TempDG tl;
struct NodeTempDG * pNext;
};
struct ListTempDG
{
NodeTempDG *pHead;
NodeTempDG *pTail;
};
struct SachQuaHan
{
string maSach = "";
string tenSach = "";
Date ngayMuon;
int soNgayQuaHan = 0;
};
struct QuaHan
{
TenHo docGia;
SachQuaHan sachQuaHan;
};
struct TopSach
{
string tensach;
int sosachmuon;
};
// ..... khoi tao........
void initList_TempDG(ListTempDG &l);
//.......get node.........
NodeTempDG* GetNode_TempDG(int index, int MADG);
//...... add tail link list........
void AddTailList_TempDG(ListTempDG &l, int index, int MADG);
// Function for implementing the Binary Search on linked list
NodeTempDG * Search_TempDG(ListTempDG l, int index);
//............xoa list..................
void ClearAll_TempDG(ListTempDG &l);
void CreateList_TempDG(Tree t, ListTempDG &l, int &index);
string Get_TenHo(theDocGia dg);
void Create_ArrTenHo(Tree t, TenHo* arr, int &index);
void Swap_TenHo(TenHo &a, TenHo &b);
void QuicKsort_ARRTenHo(TenHo *th, int left, int right);
void Sort_QuaHan(QuaHan *ArrQuaHan, int left, int right);
int SoNgayMuon_Max(ListMT lMT);
SachQuaHan TimSachQuaHan(ListMT lMT, LIST_DauSach lDS);
string getTenSach(char* maSach, LIST_DauSach lDS);
int soSachMuon(LIST_DMS dms);
void Sort_Top10(TopSach *top10, int left, int right); | [
"[email protected]"
] | |
3555095302f1503f15a8b9d3f2d856089c9aa258 | e8bb3003439d41b6f5dd4d254571735c7cc380a6 | /SoftwareRenderingEngine/Matrix.cpp | 25812290fc6e3cb79407b13bb4bb28a2a657f409 | [] | no_license | bigdudu/SoftwareRenderingEngine | 0c2aa6096e157ba54e4a5e5e92d037cf6911575d | 9f237cf1f5b1ea62ba7213b8947f1082d9d2ac47 | refs/heads/master | 2021-01-18T11:05:39.072902 | 2014-02-20T13:13:40 | 2014-02-20T13:13:40 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 646 | cpp | #include "Matrix.h"
namespace JssEngine
{
template<class T>
T Matrix16<T>::operator[](int num)
{
switch(num)
{
case 0:
return this->_0_0;
case 1:
return this->_0_1;
case 2:
return this->_0_2;
case 3:
return this->_0_3;
case 4:
return this->_1_0;
case 5:
return this->_1_1;
case 6:
return this->_1_2;
case 7:
return this->_1_3;
case 8:
return this->_2_0;
case 9:
return this->_2_1;
case 10:
return this->_2_2;
case 11:
return this->_2_3;
case 12:
return this->_3_0;
case 13:
return this->_3_1;
case 14:
return this->_3_2;
case 15:
return this->_3_3;
}
}
} | [
"[email protected]"
] | |
fd885051444b87a5ead5159b3307a21ee11ffee5 | 5d83739af703fb400857cecc69aadaf02e07f8d1 | /Archive2/b9/89abd9f02f4f9d/main.cpp | 5de0a2f8817c4b83703968ca6983a2f96d56a6aa | [] | no_license | WhiZTiM/coliru | 3a6c4c0bdac566d1aa1c21818118ba70479b0f40 | 2c72c048846c082f943e6c7f9fa8d94aee76979f | refs/heads/master | 2021-01-01T05:10:33.812560 | 2015-08-24T19:09:22 | 2015-08-24T19:09:22 | 56,789,706 | 3 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 621 | cpp | #include <ctime>
#include <cstring>
#include <cstdio>
#include <iostream>
int main()
{
time_t time_1, time_2;
std::tm tm1 = {};
std::tm tm2 = {};
memset(&tm1, 0, sizeof(std::tm));
memset(&tm2, 0, sizeof(std::tm));
strptime("1 1 1900 12:43:40", "%d %m %Y %H:%M:%S", &tm1);
strptime("1 1 1900 11:33:45", "%d %m %Y %H:%M:%S", &tm2);
time_1 = mktime(&tm1);
time_2 = mktime(&tm2);
// time_1 = difftime(time_2, time_1);
std::cout << ctime(&time_1) << std::endl;
std::cout << asctime(&tm1) << std::endl;
}
| [
"francis.rammeloo@36614edc-3e3a-acb8-9062-c8ae0e4185df"
] | francis.rammeloo@36614edc-3e3a-acb8-9062-c8ae0e4185df |
557a0d99487d4857f5cf994fb9eb6b7a9008a2a7 | 9a3e81788b83f2a91ddc1cd7d22bf47afbcfc642 | /CharAR/Temp/il2cppOutput/il2cppOutput/Vuforia_UnityExtensions_Vuforia_EyewearCalibration2094571968.h | 9cd777e1bc7a6ffa7ab8e486741f251ee7e6c195 | [] | no_license | EasonTianyiZhang/CatchMeIfYouCan | 519cffd319201f947aeb535cd6f52ad244170a4e | fd2603bb06a5857b6ab20aade73c25590a38a6ae | refs/heads/master | 2021-01-18T19:48:26.536899 | 2016-09-26T23:34:20 | 2016-09-26T23:34:20 | 69,297,181 | 1 | 3 | null | 2016-09-26T23:32:20 | 2016-09-26T22:13:16 | null | UTF-8 | C++ | false | false | 612 | h | #pragma once
#include "il2cpp-config.h"
#ifndef _MSC_VER
# include <alloca.h>
#else
# include <malloc.h>
#endif
#include <stdint.h>
#include "Vuforia_UnityExtensions_Vuforia_EyewearCalibrationP846303360.h"
#ifdef __clang__
#pragma clang diagnostic push
#pragma clang diagnostic ignored "-Winvalid-offsetof"
#pragma clang diagnostic ignored "-Wunused-variable"
#endif
// Vuforia.EyewearCalibrationProfileManagerImpl
struct EyewearCalibrationProfileManagerImpl_t2094571968 : public EyewearCalibrationProfileManager_t846303360
{
public:
public:
};
#ifdef __clang__
#pragma clang diagnostic pop
#endif
| [
"[email protected]"
] | |
c2573e1681f4ad41d24cc3a3877d22562cd95a04 | 96aa78e44277fb7756efe849d5d93066b71681a3 | /src/cld.cc | 071d9586baac2ccf4a2f8e5156dfb3edf421856e | [
"Apache-2.0"
] | permissive | nsakaimbo/cld-prebuilt | c06485c469142134b2610a31e2b762d95e588aff | 3a6b917aaa17e1f8662c93fca5f9dd020980d041 | refs/heads/master | 2022-12-24T03:42:32.188903 | 2019-12-19T04:54:31 | 2019-12-19T04:54:31 | 220,342,789 | 0 | 0 | Apache-2.0 | 2022-12-10T08:34:51 | 2019-11-07T22:48:46 | C++ | UTF-8 | C++ | false | false | 6,221 | cc | #include "compact_lang_det.h"
#include "encodings.h"
#include "constants.h"
using std::terminate_handler;
using std::unexpected_handler;
#include "nan.h"
namespace NodeCld {
NAN_METHOD(Detect) {
v8::Local<v8::Object> results = Nan::New<v8::Object>();
v8::String::Utf8Value text(info[0]->ToString());
char *bytes = *text;
int numBytes = text.length();
bool isPlainText = info[1]->ToBoolean()->Value();
CLD2::CLDHints hints;
hints.tld_hint = 0;
hints.content_language_hint = 0;
hints.language_hint = CLD2::UNKNOWN_LANGUAGE;
hints.encoding_hint = CLD2::UNKNOWN_ENCODING;
v8::String::Utf8Value languageHint(info[2]->ToString());
v8::String::Utf8Value encodingHint(info[3]->ToString());
v8::String::Utf8Value tldHint(info[4]->ToString());
v8::String::Utf8Value httpHint(info[5]->ToString());
if (tldHint.length() > 0) {
hints.tld_hint = *tldHint;
}
if (httpHint.length() > 0) {
hints.content_language_hint = *httpHint;
}
if (languageHint.length() > 0) {
hints.language_hint = Constants::getInstance().getLanguageFromName(*languageHint);
}
if (encodingHint.length() > 0) {
hints.encoding_hint = Constants::getInstance().getEncodingFromName(*encodingHint);
}
CLD2::Language language3[3];
int percent3[3];
double normalized_score3[3];
CLD2::ResultChunkVector resultChunkVector;
int textBytesFound;
bool isReliable;
CLD2::ExtDetectLanguageSummary(
bytes, numBytes,
isPlainText,
&hints,
0,
language3,
percent3,
normalized_score3,
&resultChunkVector,
&textBytesFound,
&isReliable
);
unsigned int languageIdx = 0;
v8::Local<v8::Array> languages = v8::Local<v8::Array>(Nan::New<v8::Array>());
for(int resultIdx = 0; resultIdx < 3; resultIdx++) {
CLD2::Language lang = language3[resultIdx];
if (lang == CLD2::UNKNOWN_LANGUAGE) {
continue;
}
v8::Local<v8::Object> item = Nan::New<v8::Object>();
Nan::Set(item, Nan::New<v8::String>("name").ToLocalChecked(),
Nan::New<v8::String>(Constants::getInstance().getLanguageName(lang)).ToLocalChecked());
Nan::Set(item, Nan::New<v8::String>("code").ToLocalChecked(),
Nan::New<v8::String>(Constants::getInstance().getLanguageCode(lang)).ToLocalChecked());
Nan::Set(item, Nan::New<v8::String>("percent").ToLocalChecked(),
Nan::New<v8::Number>(percent3[resultIdx]));
Nan::Set(item, Nan::New<v8::String>("score").ToLocalChecked(),
Nan::New<v8::Number>(normalized_score3[resultIdx]));
Nan::Set(languages, Nan::New<v8::Integer>(languageIdx), item);
languageIdx++;
}
unsigned int chunkIdx = 0;
v8::Local<v8::Array> chunks = v8::Local<v8::Array>(Nan::New<v8::Array>());
for(unsigned int resultIdx = 0; resultIdx < resultChunkVector.size(); resultIdx++) {
CLD2::ResultChunk chunk = resultChunkVector.at(resultIdx);
CLD2::Language lang = static_cast<CLD2::Language>(chunk.lang1);
if (lang == CLD2::UNKNOWN_LANGUAGE) {
continue;
}
v8::Local<v8::Object> item = Nan::New<v8::Object>();
Nan::Set(item, Nan::New<v8::String>("name").ToLocalChecked(),
Nan::New<v8::String>(Constants::getInstance().getLanguageName(lang)).ToLocalChecked());
Nan::Set(item, Nan::New<v8::String>("code").ToLocalChecked(),
Nan::New<v8::String>(Constants::getInstance().getLanguageCode(lang)).ToLocalChecked());
Nan::Set(item, Nan::New<v8::String>("offset").ToLocalChecked(),
Nan::New<v8::Number>(chunk.offset));
Nan::Set(item, Nan::New<v8::String>("bytes").ToLocalChecked(),
Nan::New<v8::Number>(chunk.bytes));
Nan::Set(chunks, Nan::New<v8::Integer>(chunkIdx), item);
chunkIdx++;
}
Nan::Set(results, Nan::New<v8::String>("reliable").ToLocalChecked(),
Nan::New<v8::Boolean>(isReliable));
Nan::Set(results, Nan::New<v8::String>("textBytes").ToLocalChecked(),
Nan::New<v8::Number>(textBytesFound));
Nan::Set(results, Nan::New<v8::String>("languages").ToLocalChecked(),
languages);
Nan::Set(results, Nan::New<v8::String>("chunks").ToLocalChecked(),
chunks);
info.GetReturnValue().Set(results);
}
extern "C" void init (v8::Handle<v8::Object> target) {
// set detected languages
v8::Local<v8::Array> detected = Nan::New<v8::Array>();
vector<NodeCldDetected>* rawDetected = Constants::getInstance().getDetected();
for(vector<NodeCldDetected>::size_type i = 0; i < rawDetected->size(); i++) {
NodeCldDetected rawLanguage = rawDetected->at(i);
Nan::Set(detected, static_cast<uint32_t>(i),
Nan::New<v8::String>(rawLanguage.name).ToLocalChecked());
}
Nan::Set(target, Nan::New<v8::String>("DETECTED_LANGUAGES").ToLocalChecked(), detected);
// set all languages
v8::Local<v8::Object> languages = Nan::New<v8::Object>();
vector<NodeCldLanguage>* rawLanguages = Constants::getInstance().getLanguages();
for(vector<NodeCldLanguage>::size_type i = 0; i < rawLanguages->size(); i++) {
NodeCldLanguage rawLanguage = rawLanguages->at(i);
Nan::Set(languages, Nan::New<v8::String>(rawLanguage.name).ToLocalChecked(),
Nan::New<v8::String>(rawLanguage.code).ToLocalChecked());
}
Nan::Set(target, Nan::New<v8::String>("LANGUAGES").ToLocalChecked(), languages);
// set encodings
v8::Local<v8::Array> encodings = Nan::New<v8::Array>();
vector<NodeCldEncoding>* rawEncodings = Constants::getInstance().getEncodings();
for(vector<NodeCldEncoding>::size_type i = 0; i < rawEncodings->size(); i++) {
NodeCldEncoding rawEncoding = rawEncodings->at(i);
Nan::Set(encodings, static_cast<uint32_t>(i),
Nan::New<v8::String>(rawEncoding.name).ToLocalChecked());
}
Nan::Set(target, Nan::New<v8::String>("ENCODINGS").ToLocalChecked(), encodings);
Nan::SetMethod(target, "detect", Detect);
}
NODE_MODULE(cld, init);
}
| [
"[email protected]"
] | |
a7427936598b889b2cb95121089d754cc6570fd8 | e98c404b85e168093bdff45af240582d109ce642 | /src/unescape.cpp | 75ad87b4017b5cf13426fc9a9f774d7f14f98896 | [
"MIT"
] | permissive | 929496959/OrbLang | b83d50ccf470675bf9173efa586355c7eee29611 | 2e41964164e2163427d9d5ed312d3d6dad8dc9e3 | refs/heads/master | 2023-04-24T05:21:20.578545 | 2021-05-19T07:04:46 | 2021-05-19T07:04:46 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,612 | cpp | #include "unescape.h"
#include "utils.h"
using namespace std;
pair<char, bool> nextCh(const string &str, size_t &index) {
if (index >= str.size()) return {char(), false};
return {str[index++], true};
}
pair<int, bool> nextHex(const string &str, size_t &index) {
pair<char, bool> ch = nextCh(str, index);
if (ch.second == false) return {0, false};
pair<int, bool> hex;
hex.second = true;
if (between(ch.first, '0', '9')) {
hex.first = ch.first - '0';
} else if (between(ch.first, 'a', 'f')) {
hex.first = 10 + (ch.first - 'a');
} else if (between(ch.first, 'A', 'F')) {
hex.first = 10 + (ch.first - 'A');
} else {
hex.second = false;
}
return hex;
}
UnescapePayload unescape(const string &str, std::size_t indexStarting, bool isSingleQuote) {
string out;
size_t ind = indexStarting;
size_t afterLastSuccessful;
while (true) {
afterLastSuccessful = ind;
if (ind >= str.size()) return UnescapePayload(out, afterLastSuccessful, UnescapePayload::Status::SuccessUnclosed);
pair<char, bool> ch = nextCh(str, ind);
if (ch.second == false) break;
if (ch.first == '\'') {
if (isSingleQuote) {
afterLastSuccessful = ind;
return UnescapePayload(out, afterLastSuccessful);
} else {
out.push_back('\'');
}
} else if (ch.first == '\"') {
if (!isSingleQuote) {
afterLastSuccessful = ind;
return UnescapePayload(out, afterLastSuccessful);
} else {
break;
}
} else if (isspace(ch.first) && ch.first != ' ') {
break;
} else if (ch.first == '\\') {
ch = nextCh(str, ind);
if (ch.second == false) break;
if (ch.first == 'x') {
pair<int, bool> hex1 = nextHex(str, ind);
if (hex1.second == false) break;
pair<int, bool> hex2 = nextHex(str, ind);
if (hex2.second == false) break;
out.push_back(16*hex1.first+hex2.first);
} else {
switch (ch.first) {
case '\'':
out.push_back('\'');
break;
case '\"':
out.push_back('\"');
break;
case '\?':
out.push_back('\?');
break;
case '\\':
out.push_back('\\');
break;
case 'a':
out.push_back('\a');
break;
case 'b':
out.push_back('\b');
break;
case 'f':
out.push_back('\f');
break;
case 'n':
out.push_back('\n');
break;
case 'r':
out.push_back('\r');
break;
case 't':
out.push_back('\t');
break;
case 'v':
out.push_back('\v');
break;
case '0':
out.push_back('\0');
break;
default:
return UnescapePayload(afterLastSuccessful);
}
}
} else {
out.push_back(ch.first);
}
}
// failure
return UnescapePayload(afterLastSuccessful);
}
| [
"[email protected]"
] | |
191480be3a7b219100077ec79810699e398e9497 | b32e6bd41c08b7db696092b6dfd41a39ef8e0010 | /include/ScreenBuffer.h | 96bdf2b92d77f06dd28aa3da468a3699c8965f3e | [] | no_license | voidThread/color_chart | 89d571f81d1060bafb25244c6e5f1a59a5a60b3c | c78a4ff0ef43b8a04d1d903d44123222de9b0905 | refs/heads/master | 2023-03-21T14:17:14.646043 | 2021-03-16T00:01:06 | 2021-03-16T00:01:06 | 348,168,347 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 1,103 | h | #pragma once
#include "Defines.h"
#include "LinearMix.h"
#include <optional>
namespace color_chart {
namespace screen {
using BufferScreen = std::list<defines::OneLineGradient>;
struct CornersColors {
defines::RGB565 topLeftCorner{0};
defines::RGB565 topRightCorner{0};
std::optional<defines::RGB565> downLeftCorner;
std::optional<defines::RGB565> downRightCorner;
};
class IScreenBuffer {
public:
virtual void setCornerColors(screen::CornersColors colors) =0;
virtual BufferScreen getScreen() =0;
virtual ~IScreenBuffer() = default;
};
class ScreenBuffer : public IScreenBuffer {
public:
void setCornerColors(screen::CornersColors colors) override;
BufferScreen getScreen() override;
virtual ~ScreenBuffer() = default;
ScreenBuffer(int width, int height);
private:
screen::CornersColors cornersColors;
equations::LinearMix linearMix;
int screenWidth, screenHeight;
};
}
}
| [
"[email protected]"
] | |
53dfafaad615c1b6d8ad6b6f3c98550e12c52b00 | 9cf3e95a8b10ae1cb0cee6aff584ef6b08c0baf3 | /Encoder/main.cpp | 88e527ecf0808e5e7b55fefa4f7282b1bc01ee48 | [] | no_license | RastusZhang/mytools | 70685a0f26d2ea4564ee26cbcb8fe7921aa92d23 | 3add0549712588cc8285321740f903bcdc1644fc | refs/heads/master | 2022-12-18T09:41:09.957918 | 2020-09-21T02:47:05 | 2020-09-21T02:47:05 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 697 | cpp | /*
decoder(encoder(input)) == input
size(encoder(input)) < size(input) ... when possible
"12xa" => "aaaaaaaaaaaa"
"12x" => "12x"
"12a" => "12a"
"a4xbc" => "abbbbc"
"x12ab" => "x12ab"
encode(4xA) ==> 1x41xxA
*/
void encoder(const std::vector<uint8_t>& input, std::vector<uint8_t>& output) {
output.clear();
for (size_t position = 0; position < input.size();) {
auto item = input[position];
size_t count = 1;
for (; position < input.size() && input[++position] == item; count++);
if (count > 3) {
auto times = std::itoa(count);
output.append(times);
output.append('x');
output.append(item);
} else {
output.append(item);
}
}
}
| [
"[email protected]"
] | |
439d54edde8a567f7cc871408c050861fa8df91a | 84cacc658a9c9eff4cd347d8aa8f3639e6a3753e | /4 Arrays With Joey [12June]/PrintReverseArray.cpp | 228a8b16b134e39da87b981820e692a537afd6ef | [] | no_license | aadhar54/June2020 | 54727cee49bcda9cfe46cf7b4ac57306535da16a | 5a1732781ffc8b1819eb600213d0ad27e24be350 | refs/heads/master | 2022-11-15T18:30:49.532679 | 2020-07-16T15:53:39 | 2020-07-16T15:53:39 | 268,724,454 | 16 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 218 | cpp | #include<iostream>
using namespace std;
//Program to read 10 numbers and reverse them.
int main(){
int a[10];
for(int i=0;i<10;i++){
cin>>a[i];
}
for(int i=9;i>=0;i--){
cout<<a[i]<<endl;
}
return 0;
} | [
"[email protected]"
] | |
85c05ecab8e27d64bc1431107c93ae2eeabc8ec3 | b8564eafb6c65fbe0cd7cadbcb299bc9e86ad2eb | /codeforces/365-A/365-A-9905589.cpp | 56a747e7385a423af5896208402c74252371f95b | [] | no_license | Mohamed-Hossam/Problem-Solving | 3051db03cc25d2f76fab6b43b2fd89d2ea373f83 | 8b6145679cc17481c1f625b1044d006580fdd870 | refs/heads/master | 2021-09-18T23:42:21.013810 | 2018-07-21T19:05:23 | 2018-07-21T19:05:23 | 90,371,332 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 817 | cpp | #include<iostream>
#include<string>
#include<cmath>
#include<algorithm>
#include<functional>
#include<sstream>
#include<stack>
#include<queue>
#include<bitset>
#include<iomanip>
#include<vector>
#include<map>
#include<set>
#include<list>
#include<stdio.h>
#include<fstream>
using namespace std;
#define PI 3.14159265358979323846
#define ll long long
bool test(string s, int k)
{
for (int i = 0; i <= k; i++)
{
bool test = true;
for (int j = 0; j < s.length(); j++)
{
int x = s[j] - 48;
if (x == i){ test = false; }
}
if (test)return false;
}
return true;
}
int main()
{
int n, k, sum = 0; cin >> n >> k; string x;
for (int i = 0; i < n; i++)
{
cin >> x;
if (test(x, k))sum++;
}
cout << sum << endl;
} | [
"[email protected]"
] | |
9b7ed0ab61f6d02ae63b0a9de59e3a2d036275f0 | 5167f77d96d1dc5412a8a0a91c95e3086acd05dc | /src/test/util/script.h | bde0220da284051bdaec3cb6e30654dc0efe7b6b | [
"MIT"
] | permissive | ocvcoin/ocvcoin | 04fb0cea7c11bf52e07ea06ddf9df89631eced5f | 79c3803e330f32ed50c02ae657ff9aded6297b9d | refs/heads/master | 2023-04-30T10:42:05.457630 | 2023-04-15T11:49:40 | 2023-04-15T11:49:40 | 406,011,904 | 3 | 2 | null | null | null | null | UTF-8 | C++ | false | false | 821 | h | // Copyright (c) 2021 The Ocvcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#ifndef OCVCOIN_TEST_UTIL_SCRIPT_H
#define OCVCOIN_TEST_UTIL_SCRIPT_H
#include <crypto/sha256.h>
#include <script/script.h>
static const std::vector<uint8_t> WITNESS_STACK_ELEM_OP_TRUE{uint8_t{OP_TRUE}};
static const CScript P2WSH_OP_TRUE{
CScript{}
<< OP_0
<< ToByteVector([] {
uint256 hash;
CSHA256().Write(WITNESS_STACK_ELEM_OP_TRUE.data(), WITNESS_STACK_ELEM_OP_TRUE.size()).Finalize(hash.begin());
return hash;
}())};
/** Flags that are not forbidden by an assert in script validation */
bool IsValidFlagCombination(unsigned flags);
#endif // OCVCOIN_TEST_UTIL_SCRIPT_H
| [
"[email protected]"
] | |
19d73d4e3fd4715b2c730e93c281488ba047ab81 | e1230a4aba63635e6bc2371e97f1d9a2ac069921 | /Game/SrcLang/jts.cpp | 226f83b206757f5099f704c4633c7bf6d3e58a4e | [] | no_license | tobiasquinteiro/HonorPT | d900c80c2a92e0af792a1ea77e54f6bcd737d941 | 4845c7a03b12157f9de0040443a91e45b38e8ca0 | refs/heads/master | 2021-12-09T08:14:33.777333 | 2016-05-04T03:32:23 | 2016-05-04T03:32:23 | null | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 21,665 | cpp | #include "jts.h"
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명 : GetTXT
설명 : txt파일에서 문자열을 읽어옴
파라미터 : SaveFile은 텍스트 파일을 읽어 들여서 저장할 변수
FileName은 읽어올 파일이름
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
int GetTXT(char* FileName,char* SaveFile)
{
FILE* rFile = NULL;
int nStrlen = 0;
fopen_s(&rFile,FileName,"r");
if(!rFile)
{
return -1;
}
if(SaveFile[0] !=0)
{
memset(SaveFile,0,sizeof(SaveFile));
}
fread(SaveFile,MAXTXTFILE,1,rFile);
fclose(rFile);
nStrlen = strlen(SaveFile);
if(nStrlen > MAXTXTFILE)
{
return 0;
}
return 1;
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명 : CheckJTS
설명 : 일본어는 2byte또는 1byte로 처리하는 2가지 경우가 있다.
TXT파일에서 파일에서 읽어 문자열들을 그 각각의 값을 비교하여서 2byte,1byte로 처리할치 검사한다.
10진주 129~159,224~239 16진수0x81~0x9f,0xe0~0xef사이의 값일 경우 2byte문자의 1byt로 처리하고
이어서 10진수 64~126, 128~252 16진수0x40~0x7e,0x80~0xfc일 경우 나머지 1byte를 처리면서 리턴값을 2로처리한다.
영어,숫자(ASCII, 0x21-0x7E)나 반각,가나의 0xA1-0xDF일 경우 1byte로 처리하면서 리턴값 1로처리한다.
나머지 일경우 리턴값 -1로 처리한다.
파라미터 : SaveFile은 텍스트 파일을 읽어 들여서 저장한 변수가 위치
num 원하는 위치
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
/*
int CheckJTS(char* SaveFile,int num)
{
if(((*(SaveFile + num) >= 129) && (*(SaveFile + num) <= 159)) || ((*(SaveFile + num) >= 224) && (*(SaveFile + num) <= 239)) || ((*(SaveFile + num) >= 0xFFFFFF81) && (*(SaveFile + num) <= 0xFFFFFF9F)) || ((*(SaveFile + num) >= 0XFFFFFFE0) && (*(SaveFile + num) <= 0XFFFFFFEF)))
{
if(((*(SaveFile + num + 1) >= 0xFFFFFF40) && (*(SaveFile + num + 1) <= 0xFFFFFF7E)) || ((*(SaveFile + num + 1) >= 0xFFFFFF80)&& (*(SaveFile + num + 1) <= 0xFFFFFFFC)) || ((*(SaveFile + num + 1) >= 64)&& (*(SaveFile + num + 1) <= 126)) || ((*(SaveFile + num + 1) >= 128)&& (*(SaveFile + num + 1) <= 252)))
{
return 2;
}
}
if(((*(SaveFile + num) >= 0xFFFFFF21) && (*(SaveFile + num) <= 0xFFFFFF7E)) || ((*(SaveFile + num) >= 0xFFFFFFA1) && (*(SaveFile + num) <= 0xFFFFFFDF)))
{
return 1;
}
return -1;
}*/
int CheckJTS(char* SaveFile,int num)
{
if((((*(SaveFile + num)&0xff) >= 129) && ((*(SaveFile + num)&0xff) <= 159)) || (((*(SaveFile + num)*0xff) >= 224) && ((*(SaveFile + num)&0xff) <= 239)))
{
if((((*(SaveFile + num + 1)&0xff) >= 64)&& ((*(SaveFile + num + 1)&0xff) <= 126)) || (((*(SaveFile + num + 1)&0xff) >= 128)&& ((*(SaveFile + num + 1)&0xff) <= 252)))
{
return 2;
}
}
if((((*(SaveFile + num)&0xff) >= 0x21) && ((*(SaveFile + num)&0xff) <= 0x7E)) || ((*(SaveFile + num) >= 0xFFFFFFA1) && ((*(SaveFile + num)&0xff) <= 0xDF)))
{
return 1;
}
return -1;
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명 : GetCharacterJTS
설명 : txt파일에서 읽어온 문자열을 문자로 출력하는 함수.
CheckJTS함수를 사용하여 일본어의 문자처리를 파싱했다.
파라미터 : SaveFile은 텍스트 파일을 읽어 들여서 저장한 변수가 위치
SaveCh 읽어온 문자를 저장할 변수가 위치
num 원하는 위치
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
char* GetCharacterJTS(char* SaveFile, char* SaveCh, int num)
{
int nCheck = 0;
int nNum = 0;
int nCount = 0;
while(1)
{
if(nCount+1 == num)
{
break;
}
nCheck = CheckJTS(SaveFile,nNum);
if(nCheck == 2)
{
nNum+=2;
}
else//(nCheck == 1)
{
nNum+=1;
}
//else return FALSE;
nCount++;
}
nCheck = CheckJTS(SaveFile,nNum);
if(SaveCh[0] !=0)
{
memset(SaveCh,0,sizeof(SaveCh));
}
if(nCheck == 2)
{
SaveCh[0] = SaveFile[nNum];
SaveCh[1] = SaveFile[nNum+1];
}
else
{
SaveCh[0] = SaveFile[nNum];
}
return SaveCh;
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명 : CheckJTS_ptr
설명 : num에 위치한 문자 메모리 주소를 처리하기 위한 함수
리턴값 1 : 1byte로 처리될 경우
리턴값 2 : 2byte로 처리되므로 그 전 메모리를 위치시킴
리턴값 3 : 2byte로 처리되나 마지막 1byte로 처리되기 때문에 그 메모리 주소를 리턴
리턴값 4 : 0x0D 일경우
리턴값 5 : 0x0A 일경우
파라미터 : pos 원하는 위치
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
int CheckJTS_ptr(char* SaveFile,int pos)
{
if((((*(SaveFile + pos)&0xff) >= 0x21) && ((*(SaveFile + pos)&0xff) <= 0x7E)) //ascii 영푳E 숫자
|| (((*(SaveFile + pos)&0xff) >= 0xA1) && ((*(SaveFile + pos)&0xff) <= 0xDF))) //1BYTE 가나 (반각 가나)
{
return 1;
}
if(((*(SaveFile + pos) >= 129) && (*(SaveFile + pos) <= 159)) || ((*(SaveFile + pos) >= 224) && (*(SaveFile + pos) <= 239)) || ((*(SaveFile + pos) >= 0xFFFFFF81) && (*(SaveFile + pos) <= 0xFFFFFF9F)) || ((*(SaveFile + pos) >= 0XFFFFFFE0) && (*(SaveFile + pos) <= 0XFFFFFFEF)))
{
return 2;
}
if(((*(SaveFile + pos -1) >= 129) && (*(SaveFile + pos -1) <= 159)) || ((*(SaveFile + pos -1) >= 224) && (*(SaveFile + pos -1) <= 239)) || ((*(SaveFile + pos -1) >= 0xFFFFFF81) && (*(SaveFile + pos -1) <= 0xFFFFFF9F)) || ((*(SaveFile + pos -1) >= 0XFFFFFFE0) && (*(SaveFile + pos -1) <= 0XFFFFFFEF)))
{
return 3;
}
if(*(SaveFile + pos) == 0x0D)
{
return 4;
}
if(*(SaveFile + pos) == 0x0A)
{
return 5;
}
return -1;
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명 : CheckTHAI_ptr
설명 : num에 위치한 문자 메모리 주소를 처리하기 위한 함수
리턴값 1 : 1byte로 처리될 경우
리턴값 2 : 2byte로 처리되므로 그 전 메모리를 위치시킴
리턴값 4 : 0x0D 일경우
리턴값 5 : 0x0A 일경우
파라미터 : pos 원하는 위치
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
int CheckTHAI_ptr(char* SaveFile,int pos)
{
if(((*(SaveFile + pos)&0xff) >= 0x21) && ((*(SaveFile + pos)&0xff) <= 0x7E)) //ascii 영푳E 숫자
{
return 1;
}
/*
if( ( SaveFile[pos] >= 0x21 ) && ( SaveFile[pos] <= 0x7e ) ) // 영문 ascii 코드임
{
return 1;
}
*/
if(((((*(SaveFile + pos+1)&0xff) >= 0xd4) && ((*(SaveFile + pos+1)&0xff) <= 0xff))
|| (((*(SaveFile + pos+1)&0xff) >= 0) && ((*(SaveFile + pos+1)&0xff) <= 0x4a)))
&& ((*(SaveFile + pos) == 1) && (*(SaveFile + pos) == 2)))
{
return 2;
}
/*
if( ( ( SaveFile[pos+1] >= 0xd4 ) && ( SaveFile[pos+1] <= 0xff ) ) ||
( ( SaveFile[pos+1] >= 0xd4 ) &&
*/
if(*(SaveFile + pos) == 0x0D)
{
return 4;
}
if(*(SaveFile + pos) == 0x0A)
{
return 5;
}
return -1;
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명 : GetCharacter_ptr
설명 : pos에 위치한 문자 메모리 주소를 처리하기 위한 함수
case 1 : 1byte로 처리될 경우
case 2 : 2byte로 처리되므로 그 전 메모리를 위치시킴
case 3 : 2byte로 처리되나 마지막 1byte로 처리되기 때문에 그 메모리 주소를 리턴
case 4 : 0x0D일 경우 그전 메모리 주소를 리턴
csse 5 : 0x0A일 경우 그 전전 메모리 준소를 리턴
파라미터 : pos 원하는 위치
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
char* GetCharacter_ptr(char* SaveFile,int pos)
{
int nReturnValue = 0;
nReturnValue = CheckJTS_ptr(SaveFile,pos);
switch(nReturnValue)
{
case 1:
return (SaveFile + pos);
case 2:
return (SaveFile + pos -1);
case 3:
return (SaveFile + pos);
case 4:
return (SaveFile + pos - 1);
case 5:
return (SaveFile + pos - 2);
case -1:
return 0;
}
return 0;
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명 : GetPointerPos
설명 : pos에 위치한 위치 처리 함수
case 1 : 1byte로 처리될 경우
case 2 : 2byte로 처리되므로 그 전 위치를 체크
case 3 : 2byte로 처리되나 마지막 1byte로 처리되기 때문에 그 전 위치를 리턴
case 4 : 0x0D일 경우 그 전 위치를 리턴
csse 5 : 0x0A일 경우 그 전전 위치를 리턴
파라미터 : pos 원하는 위치
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
int GetPointerPos(char* SaveFile,int pos)
{
int nPos;
int nReturnValue = 0;
nReturnValue = CheckJTS_ptr(SaveFile,pos);
switch(nReturnValue)
{
case 1:
nPos = pos;
break;
case 2:
nPos = pos -1;
break;
case 3:
nPos = pos;
break;
case 4:
nPos = pos -1;
break;
case 5:
nPos = pos -2;
case -1:
return 0;
}
return nPos;
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명: IsJTS
설명 : 일본어인지체크한다
파라미터 : SaveFile은 텍스트 파일을 읽어들여서 저장할 변수
리턴값 : 일본어 이면 TRUE, 일본어가 아니면 FALSE
예외 발생 : ㄱ의 16진수값은 ffffffa1이므로 1byte가나(반각 가나 범위 0xA1~0xDF) 값과 동일하다.
만약 일본어와 한글 자음과 모음이 썩어서 들어오면 일본어로(TRUE) 처리가된다.
그러나 한글조합와(예 : 가나다)일본어가 썩어서 들어오면 일본어가 아니라고(FALSE) 제대로 처리가 된다.
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
int IsJTS(char* SaveFile)
{
int nCount = 0;
int nStrlen = 0;
int nReturnValue = -1;
BOOL bJTS = FALSE;
nStrlen = strlen(SaveFile);
while(1)
{
if(SaveFile[nCount] == 0)
{
if(nStrlen == nCount)
{
bJTS = TRUE;
nReturnValue = -1;
break;
}
}
if((((*(SaveFile + nCount)&0xff) >= 0x21) && ((*(SaveFile + nCount)&0xff) <= 0x7E)) //ascii 영푳E 숫자
|| (((*(SaveFile + nCount)&0xff) >= 0xA1) && ((*(SaveFile + nCount)&0xff) <= 0xDF))) //1BYTE 가나 (반각 가나)
{
nCount+=1;
}
else if((((*(SaveFile + nCount)&0xff) >= 0x81) && ((*(SaveFile + nCount)&0xff) <= 0x9F))
|| (((*(SaveFile + nCount)&0xff) >= 0xE0) && ((*(SaveFile + nCount)&0xff) <= 0xEF)))
{
if((((*(SaveFile + nCount)&0xff) >= 0x40) && ((*(SaveFile + nCount)&0xff) <= 0x7E))
|| (((*(SaveFile + nCount)&0xff) >= 0x80) && ((*(SaveFile + nCount)&0xff) <= 0xFC)))
{
nCount+=2;
}
else
{
bJTS = FALSE;
nReturnValue = nCount;
break;
}
}
else
{
bJTS = FALSE;
nReturnValue = nCount;
break;
}
}
if(!bJTS)
{
return nReturnValue;
}
return nReturnValue;
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명: IsTHAI
설명 : 태국어인지체크한다
파라미터 : SaveFile은 텍스트 파일을 읽어들여서 저장할 변수
리턴값 : 태국어 이면 TRUE, 태국어 아니면 FALSE
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
int IsENG(char* SaveFile)
{
int nCount = 0;
int nStrlen = 0;
int nReturnValue = -1;
BOOL bJTS = FALSE;
nStrlen = strlen(SaveFile);
while(1)
{
if(SaveFile[nCount] == 0)
{
if(nStrlen == nCount)
{
bJTS = TRUE;
nReturnValue = -1;
break;
}
}
if((((*(SaveFile + nCount)&0xff) >= 0x30) && ((*(SaveFile + nCount)&0xff) <= 0x39))||
(((*(SaveFile + nCount)&0xff) >= 0x41) && ((*(SaveFile + nCount)&0xff) <= 0x5a))||
(((*(SaveFile + nCount)&0xff) >= 0x61) && ((*(SaveFile + nCount)&0xff) <= 0x7a))||
((*(SaveFile + nCount)&0xff) == 0x28) ||
((*(SaveFile + nCount)&0xff) == 0x29) ||
((*(SaveFile + nCount)&0xff) == 0x5b) ||
((*(SaveFile + nCount)&0xff) == 0x5d) ||
((*(SaveFile + nCount)&0xff) == 0x5f) ||
((*(SaveFile + nCount)&0xff) == 0x2d))
{
nCount+=1;
}
else
{
bJTS = FALSE;
nReturnValue = nCount;
break;
}
}
if(!bJTS)
{
return nReturnValue;
}
return nReturnValue;
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명: IsTHAI
설명 : 태국어인지체크한다
파라미터 : SaveFile은 텍스트 파일을 읽어들여서 저장할 변수
리턴값 : 태국어 이면 TRUE, 태국어 아니면 FALSE
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
int IsTHAI(char* SaveFile)
{
int nCount = 0;
int nStrlen = 0;
int nReturnValue = -1;
BOOL bJTS = FALSE;
nStrlen = strlen(SaveFile);
if(SaveFile[0] == 0) return -1;
while(1)
{
/*if(SaveFile[nCount] == 0)
{
if(nStrlen == nCount)
{
bJTS = TRUE;
nReturnValue = -1;
break;
}
}*/
if((((*(SaveFile + nCount)&0xff) >= 0x30) &&((*(SaveFile + nCount)&0xff) >= 0x39))|| //문제있어보임 _ignore_ //해외
(((*(SaveFile + nCount)&0xff) >= 0x41)&&((*(SaveFile + nCount)&0xff) <= 0x5a))||
(((*(SaveFile + nCount)&0xff) >= 0x61)&&((*(SaveFile + nCount)&0xff) <= 0x7a))) //ascii 영푳E 숫자
{
nCount+=1;
}
else if((((*(SaveFile + nCount)&0xff) == 0x01) || ((*(SaveFile + nCount)&0xff) == 0x02)))
{
if(((((*(SaveFile + nCount+1)&0xff) >= 0xd4) && ((*(SaveFile + nCount+1)&0xff) <= 0xff))
|| (((*(SaveFile + nCount+1)&0xff) >= 0) && ((*(SaveFile + nCount+1)&0xff) <= 0x4a))))
{
nCount+=2;
}
else
{
bJTS = FALSE;
nReturnValue = nCount;
break;
}
}
else
{
bJTS = FALSE;
nReturnValue = nCount;
break;
}
}
if(!bJTS)
{
return -1;
}
return nReturnValue;
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명 : Check_T
설명 : 대만어 1byte처리할 경우와 2byte처리할 경우를 체크한다.
대만어는 덱시멀 128(hex : 0x80)이하 일경우 1byte처리하고, 그 이상일 경우 2byte에서 첫바이트
범위는 0xa1~f9 에 속하면 두번재 바이트 0x40~0x7e, 0xa1~0xfe이다.
파라미터 : saveFile,대만어를 저장한 변수, 체크할 대만어 위치
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
int Check_T(char* SaveFile,int num)
{
if(((*(SaveFile + num)&0xff) < 0x80))
{
return 1;
}
else
{
if((((*(SaveFile + num)&0xff) >= 0xA1) && ((*(SaveFile + num)&0xff) <= 0xF9)))
{
if((((*(SaveFile + num + 1)&0xff) >= 0x40)&& ((*(SaveFile + num + 1)&0xff) <= 0x7E)) || (((*(SaveFile + num + 1)&0xff) >= 0xA1)&& ((*(SaveFile + num + 1)&0xff) <= 0xFE)))
{
return 2;
}
}
}
return -1;
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명 : GetCharacter_T
설명 : 원하는 위치의 대만어를 출력한다.
파라미터 : SaveFile은 텍스트 파일을 읽어 들여서 저장한 변수가 위치
SaveCh 읽어온 문자를 저장할 변수가 위치
num 원하는 위치
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
void GetCharacter_T(char* SaveFile, char* SaveCh, int num)
{
int nCheck = 0;
int nNum = 0;
int nCount = 0;
while(1)
{
if(nCount+1 == num)
{
break;
}
nCheck = Check_T(SaveFile,nNum);
if(nCheck == 2)
{
nNum+=2;
}
else if((nCheck == 1))
{
nNum+=1;
}
nCount++;
}
nCheck = Check_T(SaveFile,nNum);
if(SaveCh[0] !=0)
{
memset(SaveCh,0,sizeof(SaveCh));
}
if(nCheck == 2)
{
SaveCh[0] = SaveFile[nNum];
SaveCh[1] = SaveFile[nNum+1];
}
else if((nCheck == 1))
{
SaveCh[0] = SaveFile[nNum];
}
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명 :Check_ptr_T
설명 : 원하는 위치의 원바이트인지, 투바이트인지 체크한다.
파라미터 : pos 원하는 위치
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
int Check_ptr_T(char* SaveFile,int pos)
{
if(((*(SaveFile + pos)&0xff) < 0x80))
{
return 1;
}
if((((*(SaveFile + pos)&0xff) >= 0xA1) && ((*(SaveFile + pos)&0xff) <= 0xF9)))
{
return 2;
}
if((((*(SaveFile + pos - 1)&0xff) >= 0xA1) && ((*(SaveFile + pos - 1)&0xff) <= 0xF9)))
{
return 3;
}
if(*(SaveFile + pos) == 0x0D)
{
return 4;
}
if(*(SaveFile + pos) == 0x0A)
{
return 5;
}
return -1;
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명 : GetCharacter_ptr_T
설명 : pos에 위치한 문자 메모리 주소를 처리하기 위한 함수
case 1 : 1byte로 처리될 경우
case 2 : 2byte로 처리되므로 그 전 메모리를 위치시킴
case 3 : 2byte로 처리되나 마지막 1byte로 처리되기 때문에 그 메모리 주소를 리턴
case 4 : 0x0D일 경우 그전 메모리 주소를 리턴
csse 5 : 0x0A일 경우 그 전전 메모리 준소를 리턴
파라미터 : pos 원하는 위치
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
char* GetCharacter_ptr_T(char* SaveFile,int pos)
{
int nReturnValue = 0;
nReturnValue = CheckJTS_ptr(SaveFile,pos);
switch(nReturnValue)
{
case 1:
return (SaveFile + pos);
case 2:
return (SaveFile + pos -1);
case 3:
return (SaveFile + pos);
case 4:
return (SaveFile + pos - 1);
case 5:
return (SaveFile + pos - 2);
case -1:
return 0;
}
return 0;
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명 : GetPointerPos_T
설명 : pos에 위치한 위치 처리 함수
case 1 : 1byte로 처리될 경우
case 2 : 2byte로 처리되므로 그 전 위치를 체크
case 3 : 2byte로 처리되나 마지막 1byte로 처리되기 때문에 그 전 위치를 리턴
case 4 : 0x0D일 경우 그 전 위치를 리턴
csse 5 : 0x0A일 경우 그 전전 위치를 리턴
파라미터 : pos 원하는 위치
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
int GetPointerPos_T(char* SaveFile,int pos)
{
int nPos;
int nReturnValue = 0;
nReturnValue = CheckJTS_ptr(SaveFile,pos);
switch(nReturnValue)
{
case 1:
nPos = pos;
break;
case 2:
nPos = pos -1;
break;
case 3:
nPos = pos;
break;
case 4:
nPos = pos -1;
break;
case 5:
nPos = pos -2;
case -1:
return 0;
}
return nPos;
}
/*////////////////////////////////////////////////////////////////////////////////////////////////////////
함수명: IsTaiwan
설명 : 대만어인지 체크한다.
파라미터 : SaveFile은 텍스트 파일을 읽어들여서 저장할 변수
리턴값 : -1이면 대만어이고 그렇이 않으면 대만어가 아니부분의 위치를 넘겨준다.
예외 발생 : 대만어의 헥사값과 한글의 값 범위와 거진 같기때문에 이 함수는 거진 필요하지 않다.
////////////////////////////////////////////////////////////////////////////////////////////////////////*/
int IsTaiwan(char* SaveFile)
{
int nCount = 0;
int nStrlen = 0;
int nReturnValue = -1;
BOOL bTaiwan = FALSE;
nStrlen = strlen(SaveFile);
while(1)
{
if(SaveFile[nCount] == 0)
{
if(nStrlen == nCount)
{
bTaiwan = TRUE;
nReturnValue = -1;
break;
}
else
{
bTaiwan = FALSE;
break;
}
}
if(((*(SaveFile + nCount)&0xff) < 0x80))
{
nCount+=1;
}
else if((((*(SaveFile + nCount)&0xff) >= 0xA1) && ((*(SaveFile + nCount)&0xff) <= 0xF9)))
{
if((((*(SaveFile + nCount + 1)&0xff) >= 0x40)&& ((*(SaveFile + nCount + 1)&0xff) <= 0x7E))
|| (((*(SaveFile + nCount + 1)&0xff) >= 0xA1)&& ((*(SaveFile + nCount + 1)&0xff) <= 0xFE)))
{
nCount+=2;
}
else
{
bTaiwan = FALSE;
nReturnValue = nCount;
break;
}
}
else
{
bTaiwan = FALSE;
nReturnValue = nCount;
break;
}
}
if(!bTaiwan)
{
return nReturnValue;
}
return nReturnValue;
}
| [
"[email protected]"
] | |
45f492b795c28cbb7e34960e25c51cfe4838d31b | 35435d96d2e72a37fd9bed618d12f6682031264d | /Linux/SRC/SessionTypeExtractor/tools/SessionTypeExtractor/SessionTypeExtractor.cpp | ad1bbbc5d2fbb300a997d59b2965ea763d6faf3e | [] | no_license | sessionc/mpi-pabble-extractor | 5ce00acafd295d207c617f1fc5745234631a8663 | cca907ceed011dbf775a8c496fd1fa6f637d8ceb | refs/heads/master | 2016-09-06T09:57:58.542806 | 2014-09-01T22:51:15 | 2014-09-01T22:51:15 | 12,655,467 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 7,664 | cpp | // SessionTypeExtractor.cpp : Defines the entry point for the console application.
//
/********************************************************
*
*****************************************************************************/
/******************************************************************************
*
*****************************************************************************/
#include "MPITypeCheckingConsumer.h"
using namespace std;
using namespace clang;
using namespace llvm;
const string LIB_FILE_PATH="LIB_SEARCH_PATH.txt";
bool STRICT=true;
vector<string> srcFilesPaths;
vector<string> searchPaths;
//windows specific.
string getFileName(string path, bool withExtension){
/////////////////////////////////////////
char *resolvedPath;
char buf[PATH_MAX + 1];
char *ret=realpath(path.c_str(), buf);
if (ret) {
char *baseName=basename(buf);
string name(baseName);
if(!withExtension){
unsigned found = name.find_last_of(".");
if (found!=string::npos)
return name.substr(0,found);
else return name;
}
else
return name;
} else {
cerr << "Not resolvable path!" <<endl;
exit(EXIT_FAILURE);
}
}
void parseArgs(int argc, char *argv[]){
if (argc % 2 != 1) {
cout<<"Not enough args."<<endl;
} else {
std::cout << argv[0];
for (int i = 1; i < argc; i+=2) {
if (i + 1 != argc) {// Check that we haven't finished parsing already
if (string(argv[i]) == "-n") {
N = atoi(argv[i + 1]);
} else if (string(argv[i]) == "-lib"){
string singleLibPath;
stringstream stream(argv[i+1]);
while( getline(stream, singleLibPath, ';') ){
searchPaths.push_back(singleLibPath);
}
} else if (string(argv[i]) == "-strict") {
string ans = argv[i + 1];
transform(ans.begin(), ans.end(), ans.begin(), ::tolower);
if (ans=="true" || ans=="y" || ans=="yes")
STRICT=true;
else
STRICT=false;
} else if(string(argv[i]) == "-src"){
string srcFileListStr=argv[i + 1];
cout <<"\n"<< srcFileListStr <<endl;
string singlePath;
stringstream stream(srcFileListStr);
while( getline(stream, singlePath, ';') ){
srcFilesPaths.push_back(singlePath);
}
}
else {
std::cout << "\nNot enough or invalid arguments, please try again.\n";
throw exception();
}
}
}
}
}
void readConfig(){
ifstream libFile(LIB_FILE_PATH, fstream::binary);
string singleLibPath;
while( getline(libFile, singleLibPath, ';') ){
searchPaths.push_back(singleLibPath);
}
}
int main(int argc, char *argv[])
{
clock_t initT, finalT;
initT=clock();
readConfig();//read args from config file
parseArgs(argc,argv);//the command line args can overwrite the config args
try{
if (srcFilesPaths.size()==0)
throw MPI_TypeChecking_Error("No MPI src code provided!");
ofstream outputFile("Protocol.txt");
outputFile.clear();
outputFile.close();
ofstream debugFile("Debug.txt");
debugFile.clear();
debugFile.close();
///////////////////////////////////////////////////////////////////////////
CompilerInstance ci;
DiagnosticOptions *diagnosticOptions=new DiagnosticOptions();
TextDiagnosticPrinter *pTextDiagnosticPrinter =
new TextDiagnosticPrinter(
llvm::outs(),
diagnosticOptions,
true);
string clangArgs1= "-w";
// Arguments to pass to the clang frontend
vector<const char *> args4Clang;
args4Clang.push_back(clangArgs1.c_str());
// The compiler invocation needs a DiagnosticsEngine so it can report problems
llvm::IntrusiveRefCntPtr<clang::DiagnosticIDs> DiagID(new clang::DiagnosticIDs());
clang::DiagnosticsEngine Diags(DiagID,diagnosticOptions);
llvm::OwningPtr<clang::CompilerInvocation> CI(new clang::CompilerInvocation);
clang::CompilerInvocation::CreateFromArgs(*CI, &args4Clang[0],
&args4Clang[0] + args4Clang.size(), Diags);
///////////////////////////////////////////////////////////////////////////
ci.setInvocation(CI.take());
ci.createDiagnostics(pTextDiagnosticPrinter,false);
llvm::IntrusiveRefCntPtr<TargetOptions> pto( new TargetOptions());
pto->Triple = llvm::sys::getDefaultTargetTriple();
TargetInfo *pti = TargetInfo::CreateTargetInfo(ci.getDiagnostics(), pto.getPtr());
ci.setTarget(pti);
ci.createFileManager();
ci.createSourceManager(ci.getFileManager());
ci.createPreprocessor();
ci.getPreprocessorOpts().UsePredefines = true;
IntrusiveRefCntPtr<clang::HeaderSearchOptions> hso( new clang::HeaderSearchOptions());
HeaderSearch headerSearch( hso,
ci.getFileManager(),
ci.getDiagnostics(),
ci.getLangOpts(),
pti);
/******************************************************************************************
Platform specific code start
****************************************************************************************/
if (searchPaths.size()==0)
throw new MPI_TypeChecking_Error("No lib search path is provided!!!");
for (int i = 0; i < searchPaths.size(); i++)
{
hso->AddPath(searchPaths.at(i),
clang::frontend::Angled,
false,
false);
}
/******************************************************************************************
Platform specific code end
****************************************************************************************/
InitializePreprocessor(ci.getPreprocessor(),
ci.getPreprocessorOpts(),
*hso,
ci.getFrontendOpts());
MPITypeCheckingConsumer *astConsumer;
if(N!=0){
astConsumer= new MPITypeCheckingConsumer(&ci,N);
}
else{
astConsumer= new MPITypeCheckingConsumer(&ci);
}
ci.setASTConsumer(astConsumer);
ci.createASTContext();
ci.createSema(clang::TU_Complete, NULL);
string filePath=srcFilesPaths.at(0);
MPI_FILE_NAME=getFileName(filePath,false);
string updatedMainFilePath=filePath+"_ExplictIncluding";
//create a bakup modifiable file on which we perform the analysis
ifstream inputFileStream (filePath, fstream::binary);
ofstream outputFileStream (updatedMainFilePath, fstream::trunc|fstream::binary);
if(!inputFileStream)
throw new MPI_TypeChecking_Error("Cannot find MPI source file!");
outputFileStream<<"\n/*explict including the import list*/\n";
//the first is main file and the others are following.
for (int i = 1; i < srcFilesPaths.size(); i++)
{
outputFileStream << "#include \""<< srcFilesPaths.at(i) << "\"\n";
}
outputFileStream <<"\n/*End of importing the other src files*/\n\n";
outputFileStream << inputFileStream.rdbuf ();
outputFileStream.close();
//read from the mpi src file
const FileEntry *pFile = ci.getFileManager().getFile(updatedMainFilePath);
ci.getSourceManager().createMainFileID(pFile);
/////////////////////////////////////////
ci.getDiagnosticClient().BeginSourceFile(ci.getLangOpts(),
&ci.getPreprocessor());
clang::ParseAST(ci.getSema());
ci.getDiagnosticClient().EndSourceFile();
}
catch(MPI_TypeChecking_Error* funcErr){
funcErr->printErrInfo();
writeToFile(funcErr->errInfo);
}
catch(...){cout<<"There exists compile time error or unknown runtime error, please fix the error(s) first.";}
///////////////////////////////////////////////////////////////////////////
finalT=clock()-initT;
double timePassed=(double)finalT / ((double)CLOCKS_PER_SEC);
string timeStr="\nThe program used "+convertDoubleToStr(timePassed)
+" seconds to generate the protocol.\n";
writeToFile(timeStr);
cout<<timeStr<<endl;
/**********************************************************************************
*Delete the unused resources: start.
***********************************************************************************/
return 0;
}
| [
"[email protected]"
] | |
9cbfa9b6b92c1cf8a340bb5e83aec04c1047ad10 | e0ad2cb9b546969a638dd6c24dd0cd0bea8f7fd6 | /Source/TestRPG/TestRPGGameModeBase.h | 9b16e7a882ee0462fb6683ce956f641d9abcd8cf | [] | no_license | RickyCarrera/TestRPG | 8b25b4506dec57882032a0d646ff53bcbd9cc1ad | fc4e0d7caa83995fb703a1dc1c73a070e800fee3 | refs/heads/master | 2022-11-25T01:24:36.514553 | 2020-08-06T02:44:46 | 2020-08-06T02:44:46 | 285,456,187 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 283 | h | // Copyright Epic Games, Inc. All Rights Reserved.
#pragma once
#include "CoreMinimal.h"
#include "GameFramework/GameModeBase.h"
#include "TestRPGGameModeBase.generated.h"
/**
*
*/
UCLASS()
class TESTRPG_API ATestRPGGameModeBase : public AGameModeBase
{
GENERATED_BODY()
};
| [
"[email protected]"
] | |
9c6f5b94d38700f6b5883119061d89323c4d6c87 | 5afdbdb09571a3d423c10da8b86e7227f66864c8 | /src/controller.cpp | 3d3b89ab874f282376219019baa44632b505d697 | [
"MIT"
] | permissive | oraad/drachtio-server-1 | 6a1d78d37b32d4c4ab6f74296975e98a6fec58b4 | 0004a185cff1bd000660299d7540e8bf32c1469b | refs/heads/main | 2023-03-21T02:30:20.648705 | 2021-03-10T20:57:25 | 2021-03-10T20:57:25 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 97,515 | cpp | /*
Copyright (c) 2013, David C Horton
Permission is hereby granted, free of charge, to any person obtaining a copy
of this software and associated documentation files (the "Software"), to deal
in the Software without restriction, including without limitation the rights
to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
copies of the Software, and to permit persons to whom the Software is
furnished to do so, subject to the following conditions:
The above copyright notice and this permission notice shall be included in
all copies or substantial portions of the Software.
THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
THE SOFTWARE.
*/
#include <iostream>
#include <fstream>
#include <getopt.h>
#include <assert.h>
#include <pwd.h>
#include <algorithm>
#include <functional>
#include <regex>
#include <cstdlib>
#include <prometheus/exposer.h>
#include <prometheus/registry.h>
#include <boost/property_tree/xml_parser.hpp>
#include <boost/property_tree/ptree.hpp>
#include <boost/algorithm/string.hpp>
#include <boost/algorithm/string/split.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/log/support/date_time.hpp>
#include <boost/log/core.hpp>
#include <boost/log/attributes.hpp>
#include <boost/log/sources/severity_logger.hpp>
#include <boost/log/sources/severity_channel_logger.hpp>
#include <boost/log/sources/record_ostream.hpp>
#include <boost/log/sinks/sync_frontend.hpp>
#include <boost/log/sinks/text_ostream_backend.hpp>
#include <boost/log/attributes/scoped_attribute.hpp>
#include <boost/log/utility/setup/common_attributes.hpp>
#include <boost/core/null_deleter.hpp>
#include <boost/assign/list_of.hpp>
#include <boost/lambda/lambda.hpp>
#include <boost/date_time/posix_time/posix_time.hpp>
#include <boost/log/trivial.hpp>
#include <boost/log/common.hpp>
#include <boost/log/expressions.hpp>
#include <boost/log/attributes.hpp>
#include <boost/log/sinks.hpp>
#include <boost/log/sources/logger.hpp>
#include <boost/algorithm/string/replace.hpp>
#include <jansson.h>
#include <sofia-sip/msg_addr.h>
#include <sofia-sip/sip_util.h>
#define DEFAULT_CONFIG_FILENAME "/etc/drachtio.conf.xml"
#define DEFAULT_HOMER_PORT (9060)
#define MAXLOGLEN (8192)
/* from sofia */
#define MSG_SEPARATOR \
"------------------------------------------------------------------------\n"
namespace drachtio {
class DrachtioController ;
}
#define SU_ROOT_MAGIC_T drachtio::DrachtioController
#define NTA_AGENT_MAGIC_T drachtio::DrachtioController
#define NTA_LEG_MAGIC_T drachtio::DrachtioController
#include "cdr.hpp"
#include "controller.hpp"
/* clone static functions, used to post a message into the main su event loop from the worker client controller thread */
namespace {
void my_formatter(logging::record_view const& rec, logging::formatting_ostream& strm) {
typedef boost::log::formatter formatter;
formatter f = expr::stream << expr::format_date_time<boost::posix_time::ptime>(
"TimeStamp", "%Y-%m-%d %H:%M:%S.%f") << " " <<
expr::smessage ;
f(rec, strm);
}
int clone_init( su_root_t* root, drachtio::DrachtioController* pController ) {
return 0 ;
}
void clone_destroy( su_root_t* root, drachtio::DrachtioController* pController ) {
return ;
}
void watchdogTimerHandler(su_root_magic_t *p, su_timer_t *timer, su_timer_arg_t *arg) {
theOneAndOnlyController->processWatchdogTimer() ;
}
/* sofia logging is redirected to this function */
static void __sofiasip_logger_func(void *logarg, char const *fmt, va_list ap) {
static bool loggingSipMsg = false ;
static std::shared_ptr<drachtio::StackMsg> msg ;
char output[MAXLOGLEN+1] ;
vsnprintf( output, MAXLOGLEN, fmt, ap ) ;
va_end(ap) ;
if( loggingSipMsg ) {
loggingSipMsg = NULL == ::strstr( fmt, MSG_SEPARATOR) ;
msg->appendLine( output, !loggingSipMsg ) ;
if( !loggingSipMsg ) {
//DR_LOG(drachtio::log_debug) << "Completed logging sip message" ;
DR_LOG( drachtio::log_info ) << msg->getFirstLine() << msg->getSipMessage() << " " ;
msg->isIncoming()
? theOneAndOnlyController->setLastRecvStackMessage( msg )
: theOneAndOnlyController->setLastSentStackMessage( msg ) ;
}
}
else if( ::strstr( output, "recv ") == output || ::strstr( output, "send ") == output ) {
//DR_LOG(drachtio::log_debug) << "started logging sip message: " << output ;
loggingSipMsg = true ;
char* szStartSeparator = strstr( output, " " MSG_SEPARATOR ) ;
if( NULL != szStartSeparator ) *szStartSeparator = '\0' ;
msg = std::make_shared<drachtio::StackMsg>( output ) ;
}
else {
int len = strlen(output) ;
output[len-1] = '\0' ;
DR_LOG(drachtio::log_info) << output ;
}
} ;
int legCallback( nta_leg_magic_t* controller,
nta_leg_t* leg,
nta_incoming_t* irq,
sip_t const *sip) {
STATS_COUNTER_INCREMENT(STATS_COUNTER_SIP_REQUESTS_IN, {{"method", sip->sip_request->rq_method_name}})
return controller->processRequestInsideDialog( leg, irq, sip ) ;
}
int stateless_callback(nta_agent_magic_t *controller,
nta_agent_t *agent,
msg_t *msg,
sip_t *sip) {
if( sip && sip->sip_request ) STATS_COUNTER_INCREMENT(STATS_COUNTER_SIP_REQUESTS_IN, {{"method", sip->sip_request->rq_method_name}})
return controller->processMessageStatelessly( msg, sip ) ;
}
static std::unordered_map<unsigned int, std::string> responseReasons({
{100, "Trying"},
{180, "Ringing"},
{181, "Call is Being Forwarded"},
{182, "Queued"},
{183, "Session in Progress"},
{199, "Early Dialog Terminated"},
{200, "OK"},
{202, "Accepted"},
{204, "No Notification"},
{300, "Multiple Choices"},
{301, "Moved Permanently"},
{302, "Moved Temporarily"},
{305, "Use Proxy"},
{380, "Alternative Service"},
{400, "Bad Request"},
{401, "Unauthorized"},
{402, "Payment Required"},
{403, "Forbidden"},
{404, "Not Found"},
{405, "Method Not Allowed"},
{406, "Not Acceptable"},
{407, "Proxy Authentication Required"},
{408, "Request Timeout"},
{409, "Conflict"},
{410, "Gone"},
{411, "Length Required"},
{412, "Conditional Request Failed"},
{413, "Request Entity Too Large"},
{414, "Request-URI Too Long"},
{415, "Unsupported Media Type"},
{416, "Unsupported URI Scheme"},
{417, "Unknown Resource-Priority"},
{420, "Bad Extension"},
{421, "Extension Required"},
{422, "Session Interval Too Small"},
{423, "Interval Too Brief"},
{424, "Bad Location Information"},
{428, "Use Identity Header"},
{429, "Provide Referrer Identity"},
{430, "Flow Failed"},
{433, "Anonymity Disallowed"},
{436, "Bad Identity-Info"},
{437, "Unsupported Certificate"},
{438, "Invalid Identity Header"},
{439, "First Hop Lacks Outbound Support"},
{470, "Consent Needed"},
{480, "Temporarily Unavailable"},
{481, "Call Leg/Transaction Does Not Exist"},
{482, "Loop Detected"},
{483, "Too Many Hops"},
{484, "Address Incomplete"},
{485, "Ambiguous"},
{486, "Busy Here"},
{487, "Request Terminated"},
{488, "Not Acceptable Here"},
{489, "Bad Event"},
{491, "Request Pending"},
{493, "Undecipherable"},
{494, "Security Agreement Required"},
{500, "Server Internal Error"},
{501, "Not Implemented"},
{502, "Bad Gateway"},
{503, "Service Unavailable"},
{504, "Server Timeout"},
{505, "Version Not Supported"},
{513, "Message Too Large"},
{580, "Precondition Failure"},
{600, "Busy Everywhere"},
{603, "Decline"},
{604, "Does Not Exist Anywhere"},
{606, "Not Acceptable"}
});
};
namespace drachtio {
StackMsg::StackMsg( const char *szLine ) : m_firstLine( szLine ), m_meta( szLine ), m_os(""), m_bIncoming(::strstr( szLine, "recv ") == szLine) {
}
void StackMsg::appendLine( char *szLine, bool complete ) {
if( complete ) {
m_os.flush() ;
m_sipMessage = m_os.str() ;
m_sipMessage.resize( m_sipMessage.length() - 1) ;
boost::replace_all(m_sipMessage, "\n", DR_CRLF);
}
else if( 0 == strcmp(szLine, "\n") ) {
m_os << endl ;
}
else {
int i = 0 ;
while( ' ' == szLine[i] && '\0' != szLine[i]) i++ ;
m_os << ( szLine + i ) ;
}
}
DrachtioController::DrachtioController( int argc, char* argv[] ) : m_bDaemonize(false), m_bLoggingInitialized(false),
m_configFilename(DEFAULT_CONFIG_FILENAME), m_adminTcpPort(0), m_adminTlsPort(0), m_bNoConfig(false),
m_current_severity_threshold(log_none), m_nSofiaLoglevel(-1), m_bIsOutbound(false), m_bConsoleLogging(false),
m_nHomerPort(0), m_nHomerId(0), m_mtu(0), m_bAggressiveNatDetection(false), m_bMemoryDebug(false),
m_nPrometheusPort(0), m_strPrometheusAddress("0.0.0.0"), m_tcpKeepaliveSecs(UINT16_MAX), m_bDumpMemory(false),
m_minTlsVersion(0), m_bDisableNatDetection(false) {
getEnv();
// command line arguments, if provided, override env vars
if( !parseCmdArgs( argc, argv ) ) {
usage() ;
exit(-1) ;
}
logging::add_common_attributes();
m_Config = std::make_shared<DrachtioConfig>( m_configFilename.c_str(), m_bDaemonize ) ;
if( !m_Config->isValid() ) {
exit(-1) ;
}
this->installConfig() ;
}
DrachtioController::~DrachtioController() {
}
bool DrachtioController::installConfig() {
if( m_ConfigNew ) {
m_Config = m_ConfigNew ;
m_ConfigNew.reset();
}
if( log_none == m_current_severity_threshold ) {
m_current_severity_threshold = m_Config->getLoglevel() ;
}
if( 0 == m_requestRouter.getCountOfRoutes() ) {
m_Config->getRequestRouter( m_requestRouter ) ;
}
return true ;
}
void DrachtioController::logConfig() {
DR_LOG(log_notice) << "Starting drachtio version " << DRACHTIO_VERSION;
DR_LOG(log_notice) << "Logging threshold: " << (int) m_current_severity_threshold ;
vector<string> routes ;
m_requestRouter.getAllRoutes( routes ) ;
BOOST_FOREACH(string &r, routes) {
DR_LOG(log_notice) << "Route for outbound connection: " << r;
}
}
void DrachtioController::handleSigPipe( int signal ) {
DR_LOG(log_notice) << "Received SIGPIPE; ignoring.." ;
}
void DrachtioController::handleSigTerm( int signal ) {
DR_LOG(log_notice) << "Received SIGTERM; exiting after dumping stats.." ;
this->printStats(m_bMemoryDebug || m_bDumpMemory) ;
m_pDialogController->logStorageCount() ;
m_pClientController->logStorageCount() ;
m_pPendingRequestController->logStorageCount() ;
m_pProxyController->logStorageCount() ;
nta_agent_destroy(m_nta);
exit(0);
}
void DrachtioController::handleSigHup( int signal ) {
m_bDumpMemory = true;
DR_LOG(log_notice) << "SIGHUP handled - next storage printout will include detailed logging" ;
if( !m_ConfigNew ) {
DR_LOG(log_notice) << "Re-reading configuration file" ;
m_ConfigNew.reset( new DrachtioConfig( m_configFilename.c_str() ) ) ;
if( !m_ConfigNew->isValid() ) {
DR_LOG(log_error) << "Error reading configuration file; no changes will be made. Please correct the configuration file and try to reload again" ;
m_ConfigNew.reset() ;
}
}
else {
DR_LOG(log_error) << "Ignoring signal; already have a new configuration file to install" ;
}
}
bool DrachtioController::parseCmdArgs( int argc, char* argv[] ) {
int c ;
string port ;
string publicAddress ;
string localNet ;
string contact ;
vector<string> vecDnsNames;
string httpMethod = "GET";
string httpUrl ;
string method;
while (1)
{
static struct option long_options[] =
{
/* These options set a flag. */
{"daemon", no_argument, &m_bDaemonize, true},
{"noconfig", no_argument, &m_bNoConfig, true},
/* These options don't set a flag.
We distinguish them by their indices. */
{"file", required_argument, 0, 'f'},
{"help", no_argument, 0, 'h'},
{"user", required_argument, 0, 'u'},
{"port", required_argument, 0, 'p'},
{"contact", required_argument, 0, 'c'},
{"external-ip", required_argument, 0, 'x'},
{"local-net", required_argument, 0, 'n'},
{"dns-name", required_argument, 0, 'd'},
{"http-handler", required_argument, 0, 'a'},
{"http-method", required_argument, 0, 'm'},
{"loglevel", required_argument, 0, 'l'},
{"sofia-loglevel", required_argument, 0, 's'},
{"stdout", no_argument, 0, 'b'},
{"homer", required_argument, 0, 'y'},
{"homer-id", required_argument, 0, 'z'},
{"key-file", required_argument, 0, 'A'},
{"cert-file", required_argument, 0, 'B'},
{"chain-file", required_argument, 0, 'C'},
{"mtu", required_argument, 0, 'D'},
{"address", required_argument, 0, 'E'},
{"secret", required_argument, 0, 'F'},
{"dh-param", required_argument, 0, 'G'},
{"tls-port", required_argument, 0, 'H'},
{"aggressive-nat-detection", no_argument, 0, 'I'},
{"prometheus-scrape-port", required_argument, 0, 'J'},
{"memory-debug", no_argument, 0, 'K'},
{"tcp-keepalive-interval", required_argument, 0, 'L'},
{"min-tls-version", required_argument, 0, 'M'},
{"disable-nat-detection", no_argument, 0, 'N'},
{"version", no_argument, 0, 'v'},
{0, 0, 0, 0}
};
/* getopt_long stores the option index here. */
int option_index = 0;
c = getopt_long (argc, argv, "a:c:f:hi:l:m:p:n:u:vx:y:z:A:B:C:D:E:F:G:I",
long_options, &option_index);
/* Detect the end of the options. */
if (c == -1)
break;
switch (c)
{
case 0:
/* If this option set a flag, do nothing else now. */
if (long_options[option_index].flag != 0)
break;
cout << "option " << long_options[option_index].name ;
if (optarg)
cout << " with arg " << optarg;
cout << endl ;
break;
case 'A':
m_tlsKeyFile = optarg;
break;
case 'B':
m_tlsCertFile = optarg;
break;
case 'C':
m_tlsChainFile = optarg;
break;
case 'D':
m_mtu = ::atoi(optarg);
break;
case 'E':
m_adminAddress = optarg;
break;
case 'F':
m_secret = optarg;
break;
case 'G':
m_dhParam = optarg;
break;
case 'a':
httpUrl = optarg ;
break;
case 'b':
m_bConsoleLogging = true ;
break;
case 'd':
vecDnsNames.push_back(optarg);
break;
case 'f':
m_configFilename = optarg ;
break;
case 'h':
usage() ;
exit(0);
case 'l':
if( 0 == strcmp(optarg, "notice") ) m_current_severity_threshold = log_notice ;
else if( 0 == strcmp(optarg,"error") ) m_current_severity_threshold = log_error ;
else if( 0 == strcmp(optarg,"warning") ) m_current_severity_threshold = log_warning ;
else if( 0 == strcmp(optarg,"info") ) m_current_severity_threshold = log_info ;
else if( 0 == strcmp(optarg,"debug") ) m_current_severity_threshold = log_debug ;
else {
cerr << "Invalid loglevel '" << optarg << "': valid choices are notice, error, warning, info, debug" << endl ;
return false ;
}
break;
case 'm':
method = optarg ;
if( boost::iequals(method, "POST")) {
httpMethod = "POST";
}
break;
case 's':
m_nSofiaLoglevel = atoi( optarg ) ;
if( m_nSofiaLoglevel < 0 || m_nSofiaLoglevel > 9 ) {
cerr << "Invalid sofia-loglevel '" << optarg << "': valid choices 0-9 inclusive" << endl ;
return false ;
}
break;
case 'u':
m_user = optarg ;
break;
case 'c':
if( !contact.empty() ) {
m_vecTransports.push_back( std::make_shared<SipTransport>(contact, localNet, publicAddress )) ;
contact.clear() ;
publicAddress.clear() ;
localNet.clear() ;
}
contact = optarg ;
break;
case 'x':
if( contact.empty() ) {
cerr << "'public-ip' argument must follow a 'contact'" << endl ;
return false ;
}
if (!publicAddress.empty() ) {
cerr << "multiple 'public-ip' arguments provided for a single contact" << endl ;
return false ;
}
publicAddress = optarg ;
break ;
case 'n':
if( contact.empty() ) {
cerr << "'local-net' argument must follow a 'contact'" << endl ;
return false ;
}
if (!localNet.empty() ) {
cerr << "multiple 'local-net' arguments provided for a single contact" << endl ;
return false ;
}
localNet = optarg ;
break ;
case 'p':
port = optarg ;
m_adminTcpPort = ::atoi( port.c_str() ) ;
break;
case 'H':
port = optarg ;
m_adminTlsPort = ::atoi( port.c_str() ) ;
break;
case 'y':
{
m_nHomerPort = DEFAULT_HOMER_PORT;
vector<string>strs;
boost::split(strs, optarg, boost::is_any_of(":"));
if(strs.size() > 2) {
cerr << "invalid homer address: " << optarg << endl ;
return false ;
}
m_strHomerAddress = strs[0];
if( 2 == strs.size()) m_nHomerPort = boost::lexical_cast<uint32_t>(strs[1]);
}
break;
case 'z':
try {
m_nHomerId = boost::lexical_cast<uint32_t>(optarg);
} catch(boost::bad_lexical_cast& err) {
cerr << "--homer-id must be a positive 32-bit integer" << endl;
return false;
}
if(0 == m_nHomerId) {
cerr << "--homer-id must be a positive 32-bit integer" << endl;
return false;
}
break;
case 'I':
m_bAggressiveNatDetection = true;
break;
case 'J':
{
vector<string>strs;
boost::split(strs, optarg, boost::is_any_of(":"));
if(strs.size() == 2) {
m_strPrometheusAddress = strs[0];
m_nPrometheusPort = boost::lexical_cast<uint32_t>(strs[1]);
}
else {
m_nPrometheusPort = boost::lexical_cast<uint32_t>(optarg);
}
}
break;
case 'K':
m_bMemoryDebug = true;
break;
case 'L':
m_tcpKeepaliveSecs = ::atoi(optarg);
break;
case 'M':
m_minTlsVersion = ::atof(optarg);
break;
case 'N':
m_bDisableNatDetection = true;
break;
case 'v':
cout << DRACHTIO_VERSION << endl ;
exit(0) ;
case '?':
/* getopt_long already printed an error message. */
break;
default:
abort ();
}
}
if(!m_strHomerAddress.empty() && 0 == m_nHomerId) {
cerr << "--homer-id is required to specify an agent id when using --homer" << endl;
return false;
}
if( !contact.empty() ) {
std::shared_ptr<SipTransport> p = std::make_shared<SipTransport>(contact, localNet, publicAddress);
for( std::vector<string>::const_iterator it = vecDnsNames.begin(); it != vecDnsNames.end(); ++it) {
p->addDnsName(*it);
}
m_vecTransports.push_back(p) ;
}
if( !httpUrl.empty() ) {
m_requestRouter.addRoute("*", httpMethod, httpUrl, true);
}
/* Print any remaining command line arguments (not options). */
if (optind < argc)
{
cout << "non-option ARGV-elements: ";
while (optind < argc)
cout << argv[optind++] ;
}
return true ;
}
void DrachtioController::usage() {
cerr << endl ;
cerr << "Usage: drachtio [OPTIONS]" << endl ;
cerr << endl << "Start drachtio sip engine" << endl << endl ;
cerr << "Options:" << endl << endl ;
cerr << " --address Bind to the specified address for application connections (default: 0.0.0.0)" << endl ;
cerr << " --aggressive-nat-detection take presence of 'nat=yes' in Record-Route or Contact hdr as an indicator a remote server is behind a NAT" << endl ;
cerr << " --daemon Run the process as a daemon background process" << endl ;
cerr << " --cert-file TLS certificate file" << endl ;
cerr << " --chain-file TLS certificate chain file" << endl ;
cerr << "-c, --contact Sip contact url to bind to (see /etc/drachtio.conf.xml for examples)" << endl ;
cerr << " --dh-param file containing Diffie-Helman parameters, required when using encrypted TLS admin connections" << endl ;
cerr << " --dns-name specifies a DNS name that resolves to the local host, if any" << endl ;
cerr << "-f, --file Path to configuration file (default /etc/drachtio.conf.xml)" << endl ;
cerr << " --homer ip:port of homer/sipcapture agent" << endl ;
cerr << " --homer-id homer agent id to use in HEP messages to identify this server" << endl ;
cerr << " --http-handler http(s) URL to optionally send routing request to for new incoming sip request" << endl ;
cerr << " --http-method method to use with http-handler: GET (default) or POST" << endl ;
cerr << " --key-file TLS key file" << endl ;
cerr << "-l --loglevel Log level (choices: notice, error, warning, info, debug)" << endl ;
cerr << " --local-net CIDR for local subnet (e.g. \"10.132.0.0/20\")" << endl ;
cerr << " --memory-debug enable verbose debugging of memory allocations (do not turn on in production)" << endl ;
cerr << " --mtu max packet size for UDP (default: system-defined mtu)" << endl ;
cerr << "-p, --port TCP port to listen on for application connections (default 9022)" << endl ;
cerr << " --prometheus-scrape-port The port (or host:port) to listen on for Prometheus.io metrics scrapes" << endl ;
cerr << " --secret The shared secret to use for authenticating application connections" << endl ;
cerr << " --sofia-loglevel Log level of internal sip stack (choices: 0-9)" << endl ;
cerr << " --external-ip External IP address to use in SIP messaging" << endl ;
cerr << " --stdout Log to standard output as well as any configured log destinations" << endl ;
cerr << " --tcp-keepalive-interval tcp keepalive in seconds (0=no keepalive)" << endl ;
cerr << " --min-tls-version minimum allowed TLS version for connecting clients (default: 1.0)" << endl ;
cerr << "-v --version Print version and exit" << endl ;
}
void DrachtioController::getEnv(void) {
const char* p = std::getenv("DRACHTIO_ADMIN_ADDRESS");
if (p) m_adminAddress = p;
p = std::getenv("DRACHTIO_ADMIN_TCP_PORT");
if (p && ::atoi(p) > 0) m_adminTcpPort = ::atoi(p);
p = std::getenv("DRACHTIO_ADMIN_TLS_PORT");
if (p && ::atoi(p) > 0) m_adminTlsPort = ::atoi(p);
p = std::getenv("DRACHTIO_AGRESSIVE_NAT_DETECTION");
if (p && ::atoi(p) == 1) m_bAggressiveNatDetection = true;
p = std::getenv("DRACHTIO_MEMORY_DEBUG");
if (p && ::atoi(p) == 1) m_bMemoryDebug = true;
p = std::getenv("DRACHTIO_TLS_CERT_FILE");
if (p) m_tlsCertFile = p;
p = std::getenv("DRACHTIO_TLS_CHAIN_FILE");
if (p) m_tlsChainFile = p;
p = std::getenv("DRACHTIO_TLS_KEY_FILE");
if (p) m_tlsKeyFile = p;
p = std::getenv("DRACHTIO_TLS_DH_PARAM_FILE");
if (p) m_dhParam = p;
p = std::getenv("DRACHTIO_CONFIG_FILE_PATH");
if (p) m_configFilename = p;
p = std::getenv("DRACHTIO_HOMER_ADDRESS");
if (p) m_strHomerAddress = p;
p = std::getenv("DRACHTIO_HOMER_PORT");
if (p && ::atoi(p) > 0) m_nHomerPort = ::atoi(p);
p = std::getenv("DRACHTIO_HOMER_ID");
if (p && ::atoi(p) > 0) m_nHomerId = ::atoi(p);
p = std::getenv("DRACHTIO_HTTP_HANDLER_URI");
if (p) {
m_requestRouter.clearRoutes();
m_requestRouter.addRoute("*", "GET", p, true);
}
p = std::getenv("DRACHTIO_LOGLEVEL");
if (p) {
if( 0 == strcmp(p, "notice") ) m_current_severity_threshold = log_notice ;
else if( 0 == strcmp(p,"error") ) m_current_severity_threshold = log_error ;
else if( 0 == strcmp(p,"warning") ) m_current_severity_threshold = log_warning ;
else if( 0 == strcmp(p,"info") ) m_current_severity_threshold = log_info ;
else if( 0 == strcmp(p,"debug") ) m_current_severity_threshold = log_debug ;
}
p = std::getenv("DRACHTIO_SOFIA_LOGLEVEL");
if (p && ::atoi(p) > 0 && ::atoi(p) <= 9) m_nSofiaLoglevel = ::atoi(p);
p = std::getenv("DRACHTIO_UDP_MTU");
if (p && ::atoi(p) > 0) m_mtu = ::atoi(p);
p = std::getenv("DRACHTIO_TCP_KEEPALIVE_INTERVAL");
if (p && ::atoi(p) >= 0) m_tcpKeepaliveSecs = ::atoi(p);
p = std::getenv("DRACHTIO_SECRET");
if (p) m_secret = p;
p = std::getenv("DRACHTIO_CONSOLE_LOGGING");
if (p && ::atoi(p) == 1) m_bConsoleLogging = true;
p = std::getenv("DRACHTIO_PROMETHEUS_SCRAPE_PORT");
if (p){
vector<string>strs;
boost::split(strs, p, boost::is_any_of(":"));
if(strs.size() == 2) {
m_strPrometheusAddress = strs[0];
m_nPrometheusPort = boost::lexical_cast<uint32_t>(strs[1]);
}
else {
m_nPrometheusPort = boost::lexical_cast<uint32_t>(p);
}
}
p = std::getenv("DRACHTIO_MIN_TLS_VERSION");
if (p) {
float min = ::atof(p);
if (min >= 1.0 && min <= 1.3) m_minTlsVersion = min;
}
}
void DrachtioController::daemonize() {
/* Our process ID and Session ID */
pid_t pid, sid;
/* Fork off the parent process */
pid = fork();
if (pid < 0) {
exit(EXIT_FAILURE);
}
/* If we got a good PID, then
we can exit the parent process. */
if (pid > 0) {
cout << pid ;
exit(EXIT_SUCCESS);
}
if( !m_user.empty() ) {
struct passwd *pw = getpwnam( m_user.c_str() );
if( pw ) {
int rc = setuid( pw->pw_uid ) ;
if( 0 != rc ) {
cerr << "Error setting userid to user " << m_user << ": " << errno ;
}
}
}
/* Change the file mode mask */
umask(0);
/* Create a new SID for the child process */
sid = setsid();
if (sid < 0) {
/* Log the failure */
exit(EXIT_FAILURE);
}
/* Change the current working directory */
if ((chdir("/tmp")) < 0) {
/* Log the failure */
exit(EXIT_FAILURE);
}
/* Close out the standard file descriptors */
close(STDIN_FILENO);
close(STDOUT_FILENO);
close(STDERR_FILENO);
}
src::severity_logger_mt< severity_levels >* DrachtioController::createLogger() {
if( !m_bLoggingInitialized ) this->initializeLogging() ;
return new src::severity_logger_mt< severity_levels >(keywords::severity = log_info);
}
void DrachtioController::deinitializeLogging() {
if( m_sinkSysLog ) {
logging::core::get()->remove_sink( m_sinkSysLog ) ;
m_sinkSysLog.reset() ;
}
if( m_sinkTextFile ) {
logging::core::get()->remove_sink( m_sinkTextFile ) ;
m_sinkTextFile.reset() ;
}
if( m_sinkConsole ) {
logging::core::get()->remove_sink( m_sinkConsole ) ;
m_sinkConsole.reset() ;
}
}
void DrachtioController::initializeLogging() {
try {
if( m_bNoConfig || m_Config->getConsoleLogTarget() || m_bConsoleLogging ) {
m_sinkConsole.reset(
new sinks::synchronous_sink< sinks::text_ostream_backend >()
);
m_sinkConsole->locked_backend()->add_stream( boost::shared_ptr<std::ostream>(&std::clog, boost::null_deleter()));
// flush
m_sinkConsole->locked_backend()->auto_flush(true);
m_sinkConsole->set_formatter( &my_formatter ) ;
logging::core::get()->add_sink(m_sinkConsole);
logging::core::get()->set_filter(
expr::attr<severity_levels>("Severity") <= m_current_severity_threshold
) ;
}
if( !m_bNoConfig ) {
// Create a syslog sink
sinks::syslog::facility facility ;
string syslogAddress ;
unsigned short syslogPort;
// initalize syslog sink, if configuredd
if( m_Config->getSyslogTarget( syslogAddress, syslogPort ) ) {
m_Config->getSyslogFacility( facility ) ;
m_sinkSysLog.reset(
new sinks::synchronous_sink< sinks::syslog_backend >(
keywords::use_impl = sinks::syslog::udp_socket_based
, keywords::facility = facility
)
);
// We'll have to map our custom levels to the syslog levels
sinks::syslog::custom_severity_mapping< severity_levels > mapping("Severity");
mapping[log_debug] = sinks::syslog::debug;
mapping[log_notice] = sinks::syslog::notice;
mapping[log_info] = sinks::syslog::info;
mapping[log_warning] = sinks::syslog::warning;
mapping[log_error] = sinks::syslog::critical;
m_sinkSysLog->locked_backend()->set_severity_mapper(mapping);
// Set the remote address to sent syslog messages to
m_sinkSysLog->locked_backend()->set_target_address( syslogAddress.c_str(), syslogPort );
logging::core::get()->add_global_attribute("RecordID", attrs::counter< unsigned int >());
// Add the sink to the core
logging::core::get()->add_sink(m_sinkSysLog);
}
//initialize text file sink, of configured
string name, archiveDirectory ;
unsigned int rotationSize, maxSize, minSize, maxFiles ;
bool autoFlush ;
if( m_Config->getFileLogTarget( name, archiveDirectory, rotationSize, autoFlush, maxSize, minSize, maxFiles ) ) {
m_sinkTextFile.reset(
new sinks::synchronous_sink< sinks::text_file_backend >(
keywords::file_name = name,
keywords::rotation_size = rotationSize * 1024 * 1024,
keywords::auto_flush = autoFlush,
keywords::time_based_rotation = sinks::file::rotation_at_time_point(0, 0, 0),
keywords::open_mode = (std::ios::out | std::ios::app),
keywords::format =
(
expr::stream
<< expr::attr< unsigned int >("RecordID")
<< ": "
<< expr::format_date_time< boost::posix_time::ptime >("TimeStamp", "%Y-%m-%d %H:%M:%S")
<< "> " << expr::smessage
)
)
);
m_sinkTextFile->set_formatter( &my_formatter ) ;
m_sinkTextFile->locked_backend()->set_file_collector(sinks::file::make_collector(
keywords::target = archiveDirectory,
keywords::max_size = maxSize * 1024 * 1024,
keywords::min_free_space = minSize * 1024 * 1024,
keywords::max_files = maxFiles
));
logging::core::get()->add_sink(m_sinkTextFile);
}
logging::core::get()->set_filter(
expr::attr<severity_levels>("Severity") <= m_current_severity_threshold
) ;
}
m_bLoggingInitialized = true ;
}
catch (std::exception& e) {
std::cout << "FAILURE creating logger: " << e.what() << std::endl;
throw e;
}
}
void DrachtioController::run() {
if( m_bDaemonize ) {
daemonize() ;
}
/* now we can initialize logging */
m_logger.reset( this->createLogger() );
this->logConfig() ;
DR_LOG(log_debug) << "DrachtioController::run: Main thread id: " << std::this_thread::get_id() ;
if (m_bMemoryDebug) DR_LOG(log_notice) << "DrachtioController::run: memory debugging is ON...only use for non-production configurations" ;
/* open admin connection */
string adminAddress ;
m_Config->getAdminAddress(adminAddress);
unsigned int adminTcpPort = m_Config->getAdminTcpPort() ;
unsigned int adminTlsPort = m_Config->getAdminTlsPort() ;
if (!m_adminAddress.empty()) adminAddress = m_adminAddress;
if( 0 != m_adminTcpPort ) adminTcpPort = m_adminTcpPort ;
if( 0 != m_adminTlsPort ) adminTlsPort = m_adminTlsPort ;
if( 0 == m_vecTransports.size() ) {
m_Config->getTransports( m_vecTransports ) ;
}
if( 0 == m_vecTransports.size() ) {
DR_LOG(log_notice) << "DrachtioController::run: no sip contacts provided, will listen on 5060 for udp and tcp " ;
m_vecTransports.push_back( std::make_shared<SipTransport>("sip:*;transport=udp,tcp"));
}
string outboundProxy ;
if( m_Config->getSipOutboundProxy(outboundProxy) ) {
DR_LOG(log_notice) << "DrachtioController::run: outbound proxy " << outboundProxy ;
}
if (!m_bAggressiveNatDetection) {
m_bAggressiveNatDetection = m_Config->isAggressiveNatEnabled();
}
// tls files
string tlsKeyFile, tlsCertFile, tlsChainFile, dhParam ;
int tlsVersionTagValue = TPTLS_VERSION_TLSv1 | TPTLS_VERSION_TLSv1_1 | TPTLS_VERSION_TLSv1_2;
bool hasTlsFiles = m_Config->getTlsFiles( tlsKeyFile, tlsCertFile, tlsChainFile, dhParam ) ;
if (!m_tlsKeyFile.empty()) tlsKeyFile = m_tlsKeyFile;
if (!m_tlsCertFile.empty()) tlsCertFile = m_tlsCertFile;
if (!m_tlsChainFile.empty()) tlsChainFile = m_tlsChainFile;
if (!m_dhParam.empty()) dhParam = m_dhParam;
if (!hasTlsFiles && !tlsKeyFile.empty() && !tlsCertFile.empty()) hasTlsFiles = true;
if (m_minTlsVersion >= 1.0 || (m_Config->getMinTlsVersion(m_minTlsVersion) && m_minTlsVersion > 1.0)) {
if (m_minTlsVersion >= 1.2) {
DR_LOG(log_notice) << "DrachtioController::run: minTls version 1.2";
tlsVersionTagValue = TPTLS_VERSION_TLSv1_2;
}
else if (m_minTlsVersion >= 1.1) {
DR_LOG(log_notice) << "DrachtioController::run: minTls version 1.1" ;
tlsVersionTagValue = TPTLS_VERSION_TLSv1_1 | TPTLS_VERSION_TLSv1_2;
}
}
if (hasTlsFiles) {
DR_LOG(log_notice) << "DrachtioController::run tls key file: " << tlsKeyFile;
DR_LOG(log_notice) << "DrachtioController::run tls certificate file: " << tlsCertFile;
if (!tlsChainFile.empty()) DR_LOG(log_notice) << "DrachtioController::run tls chain file: " << tlsChainFile;
}
if (adminTlsPort) {
if ((tlsChainFile.empty() && tlsCertFile.empty()) || tlsKeyFile.empty() || dhParam.empty()) {
DR_LOG(log_notice) << "DrachtioController::run tls was requested on admin connection but either chain file/cert file, private key, or dhParams were not provided";
throw runtime_error("missing tls settings");
}
}
if (m_adminTcpPort && !m_adminTlsPort) {
DR_LOG(log_notice) << "DrachtioController::run listening for applications on tcp port " << adminTcpPort << " only";
m_pClientController.reset(new ClientController(this, adminAddress, adminTcpPort));
}
else if (!m_adminTcpPort && m_adminTlsPort) {
DR_LOG(log_notice) << "DrachtioController::run listening for applications on tls port " << adminTlsPort << " only";
m_pClientController.reset(new ClientController(this, adminAddress, adminTlsPort, tlsChainFile, tlsCertFile, tlsKeyFile, dhParam));
}
else {
DR_LOG(log_notice) << "DrachtioController::run listening for applications on tcp port " << adminTcpPort << " and tls port " << adminTlsPort ;
m_pClientController.reset(new ClientController(this, adminAddress, adminTcpPort, adminTlsPort, tlsChainFile, tlsCertFile, tlsKeyFile, dhParam));
}
m_pClientController->start();
// mtu
if (!m_mtu) m_mtu = m_Config->getMtu();
if (m_mtu > 0 && m_mtu < 1000) {
DR_LOG(log_notice) << "DrachtioController::run invalid mtu size provided, must be > 1000: " << m_mtu;
throw runtime_error("invalid mtu setting");
}
else if (m_mtu > 0) {
DR_LOG(log_notice) << "DrachtioController::run mtu size for udp packets: " << m_mtu;
}
string captureServer;
string captureString;
uint32_t captureId ;
unsigned int hepVersion;
unsigned int capturePort ;
if (!m_strHomerAddress.empty()) {
captureString = "udp:" + m_strHomerAddress + ":" + boost::lexical_cast<std::string>(m_nHomerPort) +
";hep=3;capture_id=" + boost::lexical_cast<std::string>(m_nHomerId);
DR_LOG(log_notice) << "DrachtioController::run - sipcapture/Homer enabled: " << captureString;
}
else if (m_Config->getCaptureServer(captureServer, capturePort, captureId, hepVersion)) {
if (hepVersion < 1 || hepVersion > 3) {
DR_LOG(log_error) << "DrachtioController::run invalid hep-version " << hepVersion <<
"; must be between 1 and 3 inclusive";
}
else {
captureString = "udp:" + captureServer + ":" + boost::lexical_cast<std::string>(capturePort) +
";hep=" + boost::lexical_cast<std::string>(hepVersion) +
";capture_id=" + boost::lexical_cast<std::string>(captureId);
DR_LOG(log_notice) << "DrachtioController::run - sipcapture/Homer enabled: " << captureString;
}
}
// monitoring
if (m_nPrometheusPort == 0) m_Config->getPrometheusAddress( m_strPrometheusAddress, m_nPrometheusPort ) ;
if (m_nPrometheusPort != 0) {
string hostport = m_strPrometheusAddress + ":" + boost::lexical_cast<std::string>(m_nPrometheusPort);
DR_LOG(log_notice) << "responding to Prometheus on " << hostport;
m_statsCollector.enablePrometheus(hostport.c_str());
}
else {
DR_LOG(log_notice) << "Prometheus support disabled";
}
initStats();
// tcp keepalive
if (UINT16_MAX == m_tcpKeepaliveSecs) {
m_tcpKeepaliveSecs = m_Config->getTcpKeepalive();
}
if (0 == m_tcpKeepaliveSecs) {
DR_LOG(log_notice) << "tcp keep alives have been disabled ";
}
else {
DR_LOG(log_notice) << "tcp keep alives will be sent to clients every " << m_tcpKeepaliveSecs << " seconds";
}
int rv = su_init() ;
if( rv < 0 ) {
DR_LOG(log_error) << "Error calling su_init: " << rv ;
return ;
}
::atexit(su_deinit);
if (sip_update_default_mclass(sip_extend_mclass(NULL)) < 0) {
DR_LOG(log_error) << "DrachtioController::run: Error calling sip_update_default_mclass" ;
return ;
}
m_root = su_root_create( NULL ) ;
if( NULL == m_root ) {
DR_LOG(log_error) << "DrachtioController::run: Error calling su_root_create: " ;
return ;
}
m_home = su_home_create() ;
if( NULL == m_home ) {
DR_LOG(log_error) << "DrachtioController::run: Error calling su_home_create" ;
}
su_log_redirect(NULL, __sofiasip_logger_func, NULL);
/* for now set logging to full debug */
su_log_set_level(NULL, m_nSofiaLoglevel >= 0 ? (unsigned int) m_nSofiaLoglevel : m_Config->getSofiaLogLevel() ) ;
setenv("TPORT_LOG", "1", 1) ;
/* this causes su_clone_start to start a new thread */
su_root_threading( m_root, 0 ) ;
rv = su_clone_start( m_root, m_clone, this, clone_init, clone_destroy ) ;
if( rv < 0 ) {
DR_LOG(log_error) << "DrachtioController::run: Error calling su_clone_start" ;
return ;
}
if( m_vecTransports[0]->hasExternalIp() ) {
DR_LOG(log_notice) << "DrachtioController::run: starting sip stack on local address " << m_vecTransports[0]->getContact() <<
" (external address: " << m_vecTransports[0]->getExternalIp() << ")";
}
else {
DR_LOG(log_notice) << "DrachtioController::run: starting sip stack on " << m_vecTransports[0]->getContact() ;
}
string newUrl;
m_vecTransports[0]->getBindableContactUri(newUrl) ;
/* create our agent */
bool tlsTransport = string::npos != m_vecTransports[0]->getContact().find("sips") || string::npos != m_vecTransports[0]->getContact().find("tls") ;
m_nta = nta_agent_create( m_root,
URL_STRING_MAKE(newUrl.c_str()), /* our contact address */
stateless_callback, /* no callback function */
this, /* therefore no context */
TAG_IF( !captureString.empty(), TPTAG_CAPT(captureString.c_str())),
TAG_IF( tlsTransport && hasTlsFiles, TPTAG_TLS_CERTIFICATE_KEY_FILE(tlsKeyFile.c_str())),
TAG_IF( tlsTransport && hasTlsFiles, TPTAG_TLS_CERTIFICATE_FILE(tlsCertFile.c_str())),
TAG_IF( tlsTransport && hasTlsFiles && tlsChainFile.length() > 0, TPTAG_TLS_CERTIFICATE_CHAIN_FILE(tlsChainFile.c_str())),
TAG_IF( tlsTransport &&hasTlsFiles,
TPTAG_TLS_VERSION( tlsVersionTagValue )),
NTATAG_SERVER_RPORT(2), //force rport even when client does not provide
NTATAG_CLIENT_RPORT(true), //add rport on Via headers for requests we send
TAG_NULL(),
TAG_END() ) ;
if( NULL == m_nta ) {
DR_LOG(log_error) << "DrachtioController::run: Error calling nta_agent_create" ;
return ;
}
SipTransport::addTransports(m_vecTransports[0], m_mtu) ;
for( std::vector< std::shared_ptr<SipTransport> >::iterator it = m_vecTransports.begin() + 1; it != m_vecTransports.end(); it++ ) {
string contact = (*it)->getContact() ;
string externalIp = (*it)->getExternalIp() ;
string newUrl ;
tlsTransport = string::npos != contact.find("sips") || string::npos != contact.find("tls") ;
if( externalIp.length() ) {
DR_LOG(log_info) << "DrachtioController::run: adding additional internal sip address " << contact << " (external address: " << externalIp << ")" ;
}
else {
DR_LOG(log_info) << "DrachtioController::run: adding additional sip address " << contact ;
}
(*it)->getBindableContactUri(newUrl) ;
rv = nta_agent_add_tport(m_nta, URL_STRING_MAKE(newUrl.c_str()),
TAG_IF( !captureString.empty(), TPTAG_CAPT(captureString.c_str())),
TAG_IF( tlsTransport && hasTlsFiles, TPTAG_TLS_CERTIFICATE_KEY_FILE(tlsKeyFile.c_str())),
TAG_IF( tlsTransport && hasTlsFiles, TPTAG_TLS_CERTIFICATE_FILE(tlsCertFile.c_str())),
TAG_IF( tlsTransport && hasTlsFiles && !tlsChainFile.empty(), TPTAG_TLS_CERTIFICATE_CHAIN_FILE(tlsChainFile.c_str())),
TAG_IF( tlsTransport &&hasTlsFiles,
TPTAG_TLS_VERSION( tlsVersionTagValue )),
TAG_NULL(),
TAG_END() ) ;
if( rv < 0 ) {
DR_LOG(log_error) << "DrachtioController::run: Error adding additional transport" ;
return ;
}
SipTransport::addTransports(*it, m_mtu) ;
}
SipTransport::logTransports() ;
m_pDialogController = std::make_shared<SipDialogController>( this, &m_clone ) ;
m_pProxyController = std::make_shared<SipProxyController>( this, &m_clone ) ;
m_pPendingRequestController = std::make_shared<PendingRequestController>( this ) ;
// set sip timers
unsigned int t1, t2, t4, t1x64 ;
m_Config->getTimers( t1, t2, t4, t1x64 );
DR_LOG(log_debug) << "DrachtioController::run - sip timers: T1: " << std::dec << t1 << "ms, T2: " << t2 << "ms, T4: " << t4 << "ms, T1X64: " << t1x64 << "ms";
nta_agent_set_params(m_nta,
NTATAG_SIP_T1(t1),
NTATAG_SIP_T2(t2),
NTATAG_SIP_T4(t4),
NTATAG_SIP_T1X64(t1x64),
TAG_END()
) ;
/* sofia event loop */
DR_LOG(log_notice) << "Starting sofia event loop in main thread: " << std::this_thread::get_id() ;
/* start a timer */
m_timer = su_timer_create( su_root_task(m_root), 30000) ;
su_timer_set_for_ever(m_timer, watchdogTimerHandler, this) ;
su_root_run( m_root ) ;
DR_LOG(log_notice) << "Sofia event loop ended" ;
su_root_destroy( m_root ) ;
m_root = NULL ;
su_home_unref( m_home ) ;
su_deinit() ;
m_Config.reset();
this->deinitializeLogging() ;
}
int DrachtioController::processMessageStatelessly( msg_t* msg, sip_t* sip ) {
int rc = 0 ;
DR_LOG(log_debug) << "processMessageStatelessly - incoming message with call-id " << sip->sip_call_id->i_id <<
" does not match an existing call leg, processed in thread " << std::this_thread::get_id() ;
if( sip->sip_request ) {
// sofia sanity check on message format
if( sip_sanity_check(sip) < 0 ) {
DR_LOG(log_error) << "DrachtioController::processMessageStatelessly: invalid incoming request message; discarding call-id " << sip->sip_call_id->i_id ;
STATS_COUNTER_INCREMENT(STATS_COUNTER_SIP_RESPONSES_OUT, {{"method", sip->sip_request->rq_method_name},{"code", "400"}})
nta_msg_treply( m_nta, msg, 400, NULL, TAG_END() ) ;
return -1 ;
}
tport_t* tp_incoming = nta_incoming_transport(m_nta, NULL, msg );
tport_t* tp = tport_parent( tp_incoming ) ;
const tp_name_t* tpn = tport_name( tp );
// spammer check
string action, tcpAction ;
DrachtioConfig::mapHeader2Values& mapSpammers = m_Config->getSpammers( action, tcpAction );
if( mapSpammers.size() > 0 ) {
if( 0 == strcmp( tpn->tpn_proto, "tcp") || 0 == strcmp( tpn->tpn_proto, "ws") || 0 == strcmp( tpn->tpn_proto, "wss") ) {
if( tcpAction.length() > 0 ) {
action = tcpAction ;
}
}
try {
for( DrachtioConfig::mapHeader2Values::iterator it = mapSpammers.begin(); mapSpammers.end() != it; ++it ) {
string hdrName = it->first ;
vector<string> vecValue = it->second ;
// currently limited to looking at User-Agent, From, and To
if( 0 == hdrName.compare("user-agent") && sip->sip_user_agent && sip->sip_user_agent->g_string ) {
for( std::vector<string>::iterator it = vecValue.begin(); it != vecValue.end(); ++it ) {
if( NULL != strstr( sip->sip_user_agent->g_string, (*it).c_str() ) ) {
throw runtime_error(sip->sip_user_agent->g_string) ;
}
}
}
if( 0 == hdrName.compare("to") && sip->sip_to && sip->sip_to->a_url->url_user ) {
for( std::vector<string>::iterator it = vecValue.begin(); it != vecValue.end(); ++it ) {
if( NULL != strstr( sip->sip_to->a_url->url_user, (*it).c_str() ) ) {
throw runtime_error(sip->sip_to->a_url->url_user) ;
}
}
}
if( 0 == hdrName.compare("from") && sip->sip_from && sip->sip_from->a_url->url_user ) {
for( std::vector<string>::iterator it = vecValue.begin(); it != vecValue.end(); ++it ) {
if( NULL != strstr( sip->sip_from->a_url->url_user, (*it).c_str() ) ) {
throw runtime_error(sip->sip_from->a_url->url_user) ;
}
}
}
}
} catch( runtime_error& err ) {
nta_incoming_t* irq = nta_incoming_create( m_nta, NULL, msg, sip, NTATAG_TPORT(tp), TAG_END() ) ;
if (sip->sip_request->rq_method != sip_method_ack) {
const char* remote_host = nta_incoming_remote_host(irq);
const char *remote_port = nta_incoming_remote_port(irq);
const char* what = err.what();
if (remote_host && remote_port && what) {
DR_LOG(log_notice) << "DrachtioController::processMessageStatelessly: detected potential spammer from " <<
nta_incoming_remote_host(irq) << ":" << nta_incoming_remote_port(irq) <<
" due to header value: " << err.what() ;
}
STATS_COUNTER_INCREMENT(STATS_COUNTER_SIP_RESPONSES_OUT, {{"method", sip->sip_request->rq_method_name},{"code", "603"}})
nta_incoming_treply( irq, 603, "Decline", TAG_END() ) ;
nta_incoming_destroy(irq) ;
/*
if( 0 == action.compare("reject") ) {
nta_msg_treply( m_nta, msg, 603, NULL, TAG_END() ) ;
}
*/
return -1 ;
}
}
}
if( sip->sip_route && sip->sip_to->a_tag != NULL && url_has_param(sip->sip_route->r_url, "lr") ) {
//check if we are in the first Route header, and the request-uri is not us; if so proxy accordingly
bool hostMatch =
(0 == strcmp( tpn->tpn_host, sip->sip_route->r_url->url_host ) ||
(tpn->tpn_canon && 0 == strcmp( tpn->tpn_canon, sip->sip_route->r_url->url_host )));
bool portMatch =
(tpn->tpn_port && sip->sip_route->r_url->url_port && 0 == strcmp(tpn->tpn_port,sip->sip_route->r_url->url_port)) ||
(!tpn->tpn_port && !sip->sip_route->r_url->url_port) ||
(!tpn->tpn_port && 0 == strcmp(sip->sip_route->r_url->url_port, "5060")) ||
(!sip->sip_route->r_url->url_port && 0 == strcmp(tpn->tpn_port, "5060")) ;
tport_unref( tp_incoming ) ;
if( /*hostMatch && portMatch && */ SipTransport::isLocalAddress(sip->sip_route->r_url->url_host)) {
//request within an established dialog in which we are a stateful proxy
if( !m_pProxyController->processRequestWithRouteHeader( msg, sip ) ) {
nta_msg_discard( m_nta, msg ) ;
}
return 0 ;
}
DR_LOG(log_warning) << "DrachtioController::processMessageStatelessly: discarding incoming message with Route header as we do not match the first route";
}
if( m_pProxyController->isProxyingRequest( msg, sip ) ) {
//CANCEL or other request within a proxy transaction
m_pProxyController->processRequestWithoutRouteHeader( msg, sip ) ;
}
else {
switch (sip->sip_request->rq_method ) {
case sip_method_invite:
case sip_method_register:
case sip_method_message:
case sip_method_options:
case sip_method_info:
case sip_method_notify:
case sip_method_subscribe:
case sip_method_publish:
{
if( m_pPendingRequestController->isRetransmission( sip ) ||
m_pProxyController->isRetransmission( sip ) ) {
DR_LOG(log_info) << "discarding retransmitted request: " << sip->sip_call_id->i_id ;
int ret = sip_method_invite == sip->sip_request->rq_method ? 100 : -1 ;
nta_msg_discard(m_nta, msg) ;
return ret ;
}
if( sip_method_invite == sip->sip_request->rq_method ) {
nta_msg_treply( m_nta, msg_ref_create( msg ), 100, NULL, TAG_END() ) ;
}
string transactionId ;
int status = m_pPendingRequestController->processNewRequest( msg, sip, tp_incoming, transactionId ) ;
//write attempt record
if( status >= 0 && sip->sip_request->rq_method == sip_method_invite ) {
Cdr::postCdr( std::make_shared<CdrAttempt>( msg, "network" ) );
}
//reject message if necessary, write stop record
if( status > 0 ) {
msg_t* reply = nta_msg_create(m_nta, 0) ;
msg_ref_create(reply) ;
nta_msg_mreply( m_nta, reply, sip_object(reply), status, NULL, msg, TAG_END() ) ;
if( sip->sip_request->rq_method == sip_method_invite ) {
Cdr::postCdr( std::make_shared<CdrStop>( reply, "application", Cdr::call_rejected ) );
}
msg_destroy(reply) ;
return 0;
}
}
break ;
case sip_method_prack:
assert(0) ;//should not get here
break ;
case sip_method_cancel:
{
std::shared_ptr<PendingRequest_t> p = m_pPendingRequestController->findInviteByCallId( sip->sip_call_id->i_id ) ;
if( p ) {
DR_LOG(log_info) << "received quick cancel for invite that is out to client for disposition: " << sip->sip_call_id->i_id ;
string encodedMessage ;
EncodeStackMessage( sip, encodedMessage ) ;
SipMsgData_t meta( msg ) ;
client_ptr client = m_pClientController->findClientForNetTransaction(p->getTransactionId());
if(client) {
void (BaseClient::*fn)(const string&, const string&, const SipMsgData_t&) = &BaseClient::sendSipMessageToClient;
m_pClientController->getIOService().post( std::bind(fn, client, p->getTransactionId(), encodedMessage, meta)) ;
}
STATS_COUNTER_INCREMENT(STATS_COUNTER_SIP_RESPONSES_OUT, {{"method", sip->sip_request->rq_method_name},{"code", "200"}})
nta_msg_treply( m_nta, msg, 200, NULL, TAG_END() ) ;
p->cancel() ;
STATS_COUNTER_INCREMENT(STATS_COUNTER_SIP_RESPONSES_OUT, {{"method", "INVITE"},{"code", "487"}})
nta_msg_treply( m_nta, msg_dup(p->getMsg()), 487, NULL, TAG_END() ) ;
}
else {
STATS_COUNTER_INCREMENT(STATS_COUNTER_SIP_RESPONSES_OUT, {{"method", sip->sip_request->rq_method_name},{"code", "481"}})
nta_msg_treply( m_nta, msg, 481, NULL, TAG_END() ) ;
}
}
break ;
case sip_method_bye:
STATS_COUNTER_INCREMENT(STATS_COUNTER_SIP_RESPONSES_OUT, {{"method", sip->sip_request->rq_method_name},{"code", "481"}})
nta_msg_treply( m_nta, msg, 481, NULL, TAG_END() ) ;
break;
default:
nta_msg_discard( m_nta, msg ) ;
break ;
}
}
}
else {
if( !m_pProxyController->processResponse( msg, sip ) ) {
if( sip->sip_via->v_next ) {
DR_LOG(log_error) << "processMessageStatelessly - forwarding response upstream" ;
nta_msg_tsend( m_nta, msg, NULL, TAG_END() ) ;
}
else {
DR_LOG(log_error) << "processMessageStatelessly - unknown response (possibly late arriving?) - discarding" ;
nta_msg_discard( m_nta, msg ) ;
}
}
}
return rc ;
}
bool DrachtioController::setupLegForIncomingRequest( const string& transactionId, const string& tag ) {
//DR_LOG(log_debug) << "DrachtioController::setupLegForIncomingRequest - entering" ;
std::shared_ptr<PendingRequest_t> p = m_pPendingRequestController->findAndRemove( transactionId ) ;
if( !p ) {
return false ;
}
if (p->isCanceled()) {
DR_LOG(log_notice) << "DrachtioController::setupLegForIncomingRequest - app provided a response but INVITE has already been canceled" ;
return false;
}
sip_t* sip = p->getSipObject() ;
msg_t* msg = p->getMsg() ;
tport_t* tp = p->getTport() ;
if( sip_method_invite == sip->sip_request->rq_method || sip_method_subscribe == sip->sip_request->rq_method ) {
nta_incoming_t* irq = nta_incoming_create( m_nta, NULL, msg, sip, NTATAG_TPORT(tp), TAG_END() ) ;
if( NULL == irq ) {
DR_LOG(log_error) << "DrachtioController::setupLegForIncomingRequest - Error creating a transaction for new incoming invite" ;
return false ;
}
nta_leg_t* leg = nta_leg_tcreate(m_nta, legCallback, this,
SIPTAG_CALL_ID(sip->sip_call_id),
SIPTAG_CSEQ(sip->sip_cseq),
SIPTAG_TO(sip->sip_from),
SIPTAG_FROM(sip->sip_to),
TAG_END());
if( NULL == leg ) {
DR_LOG(log_error) << "DrachtioController::setupLegForIncomingRequest - Error creating a leg for new incoming invite" ;
return false ;
}
DR_LOG(log_debug) << "DrachtioController::setupLegForIncomingRequest - created leg: " << hex << leg << ", irq: " << irq <<
", for transactionId: " << transactionId << ", tag: " << tag;
std::shared_ptr<SipDialog> dlg = std::make_shared<SipDialog>( leg, irq, sip, msg ) ;
dlg->setTransactionId( transactionId ) ;
string contactStr ;
nta_leg_server_route( leg, sip->sip_record_route, sip->sip_contact ) ;
m_pDialogController->addIncomingInviteTransaction( leg, irq, sip, transactionId, dlg, tag ) ;
}
else {
nta_incoming_t* irq = nta_incoming_create( m_nta, NULL, msg, sip, NTATAG_TPORT(tp), TAG_END() ) ;
if( NULL == irq ) {
DR_LOG(log_error) << "DrachtioController::setupLegForIncomingRequest - Error creating a transaction for new incoming invite or subscribe" ;
return false ;
}
m_pDialogController->addIncomingRequestTransaction( irq, transactionId ) ;
}
msg_ref_create( msg ) ; // we need to add a reference to the original request message
return true ;
}
int DrachtioController::processRequestInsideDialog( nta_leg_t* leg, nta_incoming_t* irq, sip_t const *sip) {
DR_LOG(log_debug) << "DrachtioController::processRequestInsideDialog" ;
int rc = validateSipMessage( sip ) ;
if( 0 != rc ) {
return rc ;
}
std::shared_ptr<SipDialog> dlg ;
if( m_pDialogController->findDialogByLeg( leg, dlg ) ) {
if( sip->sip_request->rq_method == sip_method_invite && !sip->sip_to->a_tag && dlg->getSipStatus() >= 200 ) {
DR_LOG(log_info) << "DrachtioController::processRequestInsideDialog - received INVITE out of order (still waiting ACK from prev transaction)" ;
return 491;
//return this->processMessageStatelessly( nta_incoming_getrequest( irq ), (sip_t *) sip ) ;
}
return m_pDialogController->processRequestInsideDialog( leg, irq, sip ) ;
}
assert(false) ;
return 0 ;
}
sip_time_t DrachtioController::getTransactionTime( nta_incoming_t* irq ) {
return nta_incoming_received( irq, NULL ) ;
}
void DrachtioController::getTransactionSender( nta_incoming_t* irq, string& host, unsigned int& port ) {
msg_t* msg = nta_incoming_getrequest( irq ) ; //adds a reference
tport_t* tp = nta_incoming_transport( m_nta, irq, msg);
msg_destroy(msg); //releases reference
const tp_name_t* tpn = tport_name( tp );
host = tpn->tpn_host ;
port = ::atoi( tpn->tpn_port ) ;
}
const tport_t* DrachtioController::getTportForProtocol( const string& remoteHost, const char* proto ) {
std::shared_ptr<SipTransport> p = SipTransport::findAppropriateTransport(remoteHost.c_str(), proto) ;
return p->getTport() ;
}
int DrachtioController::validateSipMessage( sip_t const *sip ) {
if( sip_method_invite == sip->sip_request->rq_method && (!sip->sip_contact || !sip->sip_contact->m_url[0].url_host ) ) {
DR_LOG(log_error) << "Invalid or missing contact header" ;
return 400 ;
}
if( !sip->sip_call_id || !sip->sip_call_id->i_id ) {
DR_LOG(log_error) << "Invalid or missing call-id header" ;
return 400 ;
}
if( sip_method_invite == sip->sip_request->rq_method && !sip->sip_to ) {
DR_LOG(log_error) << "Invalid or missing to header" ;
return 400 ;
}
if( sip_method_invite == sip->sip_request->rq_method && (!sip->sip_from || !sip->sip_from->a_tag ) ) {
DR_LOG(log_error) << "Missing tag on From header on invite" ;
return 400 ;
}
return 0 ;
}
void DrachtioController::getMyHostports( vector<string>& vec ) {
return SipTransport::getAllHostports( vec ) ;
}
bool DrachtioController::getMySipAddress( const char* proto, string& host, string& port, bool ipv6 ) {
string desc, p ;
const tport_t* tp = getTportForProtocol(host, proto) ;
if( !tp ) {
DR_LOG(log_error) << "DrachtioController::getMySipAddress - invalid or non-configured protocol: " << proto ;
assert( 0 ) ;
return false;
}
getTransportDescription( tp, desc ) ;
return parseTransportDescription( desc, p, host, port ) ;
}
void DrachtioController::cacheTportForSubscription( const char* user, const char* host, int expires, tport_t* tp ) {
string uri ;
std::shared_ptr<UaInvalidData> pUa = std::make_shared<UaInvalidData>(user, host, expires, tp) ;
pUa->getUri( uri ) ;
std::pair<mapUri2InvalidData::iterator, bool> ret = m_mapUri2InvalidData.insert( mapUri2InvalidData::value_type( uri, pUa) );
if( ret.second == false ) {
mapUri2InvalidData::iterator it = ret.first ;
pUa = it->second;
//*(it->second) = *pUa ;
pUa->extendExpires(expires);
pUa->setTport(tp);
DR_LOG(log_debug) << "DrachtioController::cacheTportForSubscription updated " << uri << ", expires: " << expires <<
" tport: " << (void*) tp << ", count is now: " << m_mapUri2InvalidData.size();
}
else {
std::shared_ptr<UaInvalidData> p = (ret.first)->second ;
DR_LOG(log_debug) << "DrachtioController::cacheTportForSubscription added " << uri << ", expires: " << expires << ", count is now: " << m_mapUri2InvalidData.size();
}
}
void DrachtioController::flushTportForSubscription( const char* user, const char* host ) {
string uri = "" ;
if (user) {
uri.append(user) ;
uri.append("@") ;
}
uri.append(host) ;
mapUri2InvalidData::iterator it = m_mapUri2InvalidData.find( uri ) ;
if( m_mapUri2InvalidData.end() != it ) {
m_mapUri2InvalidData.erase( it ) ;
}
DR_LOG(log_debug) << "DrachtioController::flushTportForSubscription " << uri << ", count is now: " << m_mapUri2InvalidData.size();
}
std::shared_ptr<UaInvalidData> DrachtioController::findTportForSubscription( const char* user, const char* host ) {
std::shared_ptr<UaInvalidData> p ;
string uri = "" ;
if (user) {
uri.append(user) ;
uri.append("@") ;
}
uri.append(host) ;
mapUri2InvalidData::iterator it = m_mapUri2InvalidData.find( uri ) ;
if( m_mapUri2InvalidData.end() != it ) {
p = it->second ;
DR_LOG(log_debug) << "DrachtioController::findTportForSubscription: found transport for " << uri ;
}
else {
DR_LOG(log_debug) << "DrachtioController::findTportForSubscription: no transport found for " << uri ;
}
return p ;
}
void DrachtioController::makeOutboundConnection(const string& transactionId, const string& uri) {
string host ;
string port = "9021";
string transport = "tcp";
try {
std::regex re("^(.*):(\\d+)(;transport=(tcp|tls))?");
std::smatch mr;
if (std::regex_search(uri, mr, re) && mr.size() > 1) {
host = mr[1] ;
port = mr[2] ;
if (mr.size() > 4) {
transport = mr[4];
}
}
else {
DR_LOG(log_warning) << "DrachtioController::makeOutboundConnection - invalid uri: " << uri;
//TODO: send 480, remove pending connection
return ;
}
} catch (std::regex_error& e) {
DR_LOG(log_warning) << "DrachtioController::makeOutboundConnection - regex error: " << e.what();
return;
}
DR_LOG(log_warning) << "DrachtioController::makeOutboundConnection - attempting connection to " <<
host << ":" << port << " with transport " << transport;
m_pClientController->makeOutboundConnection(transactionId, host, port, transport) ;
}
void DrachtioController::selectInboundConnectionForTag(const string& transactionId, const string& tag) {
m_pClientController->selectClientForTag(transactionId, tag);
}
// handling responses from http route lookups
// N.B.: these execute in the http thread, not the main thread
void DrachtioController::httpCallRoutingComplete(const string& transactionId, long response_code,
const string& body) {
std::ostringstream msg ;
json_t *root;
json_error_t error;
root = json_loads(body.c_str(), 0, &error);
DR_LOG(log_debug) << "DrachtioController::httpCallRoutingComplete thread id " << std::this_thread::get_id() <<
" transaction id " << transactionId << " response: (" << response_code << ") " << body ;
try {
if( !root ) {
msg << "error parsing body as JSON on line " << error.line << ": " << error.text ;
return throw std::runtime_error(msg.str()) ;
}
if(!json_is_object(root)) {
throw std::runtime_error("expected JSON object but got something else") ;
}
json_t* action = json_object_get( root, "action") ;
json_t* data = json_object_get(root, "data") ;
if( !json_is_string(action) ) {
throw std::runtime_error("missing or invalid 'action' attribute") ;
}
if( !json_is_object(data) ) {
throw std::runtime_error("missing 'data' object") ;
}
const char* actionText = json_string_value(action) ;
if( 0 == strcmp("reject", actionText)) {
json_t* status = json_object_get(data, "status") ;
json_t* reason = json_object_get(data, "reason") ;
if( !status || !json_is_number(status) ) {
throw std::runtime_error("'status' is missing or is not a number") ;
}
processRejectInstruction(transactionId, json_integer_value(status), json_string_value(reason));
}
else if( 0 == strcmp("proxy", actionText)) {
bool recordRoute = false ;
bool followRedirects = true ;
bool simultaneous = false ;
string provisionalTimeout = "5s";
string finalTimeout = "60s";
vector<string> vecDestination ;
json_t* rr = json_object_get(data, "recordRoute") ;
if( rr && json_is_boolean(rr) ) {
recordRoute = json_boolean_value(rr) ;
}
json_t* follow = json_object_get(data, "followRedirects") ;
if( follow && json_is_boolean(follow) ) {
followRedirects = json_boolean_value(follow) ;
}
json_t* sim = json_object_get(data, "simultaneous") ;
if( sim && json_is_boolean(sim) ) {
simultaneous = json_boolean_value(sim) ;
}
json_t* pTimeout = json_object_get(data, "provisionalTimeout") ;
if( pTimeout && json_is_string(pTimeout) ) {
provisionalTimeout = json_string_value(pTimeout) ;
}
json_t* fTimeout = json_object_get(data, "finalTimeout") ;
if( fTimeout && json_is_string(fTimeout) ) {
finalTimeout = json_string_value(fTimeout) ;
}
json_t* destination = json_object_get(data, "destination") ;
if( json_is_string(destination) ) {
vecDestination.push_back( json_string_value(destination) ) ;
}
else if( json_is_array(destination) ) {
size_t size = json_array_size(destination);
for( unsigned int i = 0; i < size; i++ ) {
json_t* aDest = json_array_get(destination, i);
if( !json_is_string(aDest) ) {
throw std::runtime_error("DrachtioController::processRoutingInstructions - invalid 'contact' array: must contain strings") ;
}
vecDestination.push_back( json_string_value(aDest) );
}
}
processProxyInstruction(transactionId, recordRoute, followRedirects,
simultaneous, provisionalTimeout, finalTimeout, vecDestination) ;
}
else if( 0 == strcmp("redirect", actionText)) {
json_t* contact = json_object_get(data, "contact") ;
vector<string> vecContact ;
if( json_is_string(contact) ) {
vecContact.push_back( json_string_value(contact) ) ;
}
else if( json_is_array(contact) ) {
size_t size = json_array_size(contact);
for( unsigned int i = 0; i < size; i++ ) {
json_t* aContact = json_array_get(contact, i);
if( !json_is_string(aContact) ) {
throw std::runtime_error("DrachtioController::processRoutingInstructions - invalid 'contact' array: must contain strings") ;
}
vecContact.push_back( json_string_value(aContact) );
}
}
else {
throw std::runtime_error("DrachtioController::processRoutingInstructions - invalid 'contact' attribute in redirect action: must be string or array") ;
}
processRedirectInstruction(transactionId, vecContact);
}
else if( 0 == strcmp("route", actionText)) {
json_t* uri = json_object_get(data, "uri") ;
json_t* tag = json_object_get(data, "tag") ;
if(uri && json_is_string(uri)) {
processOutboundConnectionInstruction(transactionId, json_string_value(uri));
}
else if(tag && json_is_string(tag)) {
processTaggedConnectionInstruction(transactionId, json_string_value(tag));
}
else {
throw std::runtime_error("'uri' is missing or is not a string") ;
}
}
else {
msg << "DrachtioController::processRoutingInstructions - invalid 'action' attribute value '" << actionText <<
"': valid values are 'reject', 'proxy', 'redirect', and 'route'" ;
return throw std::runtime_error(msg.str()) ;
}
json_decref(root) ;
} catch( std::runtime_error& err ) {
DR_LOG(log_error) << "DrachtioController::processRoutingInstructions " << err.what();
DR_LOG(log_error) << body ;
processRejectInstruction(transactionId, 500) ;
if( root ) {
json_decref(root) ;
}
}
// clean up needed? not in reject scenarios, nor redirect nor route (proxy?)
//m_pController->getPendingRequestController()->findAndRemove( transactionId ) ;
}
void DrachtioController::processRejectInstruction(const string& transactionId, unsigned int status,
const char* reason) {
string headers;
string body ;
std::ostringstream statusLine ;
statusLine << "SIP/2.0 " << status << " " ;
if( reason ) {
statusLine << reason ;
}
else {
std::unordered_map<unsigned int, std::string>::const_iterator it = responseReasons.find(status) ;
if( it != responseReasons.end() ) {
statusLine << it->second ;
}
}
if(( !this->getDialogController()->respondToSipRequest("", transactionId, statusLine.str(), headers, body) )) {
DR_LOG(log_error) << "DrachtioController::processRejectInstruction - error sending rejection with status " << status ;
}
}
void DrachtioController::processRedirectInstruction(const string& transactionId, vector<string>& vecContact) {
string headers;
string body ;
int i = 0 ;
BOOST_FOREACH(string& c, vecContact) {
if( i++ > 0 ) {
headers.append("\n");
}
headers.append("Contact: ") ;
headers.append(c) ;
}
if(( !this->getDialogController()->respondToSipRequest( "", transactionId, "SIP/2.0 302 Moved", headers, body) )) {
DR_LOG(log_error) << "DrachtioController::processRedirectInstruction - error sending redirect" ;
}
}
void DrachtioController::processProxyInstruction(const string& transactionId, bool recordRoute, bool followRedirects,
bool simultaneous, const string& provisionalTimeout, const string& finalTimeout, vector<string>& vecDestination) {
string headers;
string body ;
this->getProxyController()->proxyRequest( "", transactionId, recordRoute, false, followRedirects,
simultaneous, provisionalTimeout, finalTimeout, vecDestination, headers ) ;
}
void DrachtioController::processOutboundConnectionInstruction(const string& transactionId, const char* uri) {
string val = uri ;
makeOutboundConnection(transactionId, val);
}
void DrachtioController::processTaggedConnectionInstruction(const string& transactionId, const char* tag) {
string val = tag ;
selectInboundConnectionForTag(transactionId, val);
}
void DrachtioController::printStats(bool bDetail) {
usize_t irq_hash = -1, orq_hash = -1, leg_hash = -1;
usize_t irq_used = -1, orq_used = -1, leg_used = -1 ;
usize_t recv_msg = -1, sent_msg = -1;
usize_t recv_request = -1, recv_response = -1;
usize_t bad_message = -1, bad_request = -1, bad_response = -1;
usize_t drop_request = -1, drop_response = -1;
usize_t client_tr = -1, server_tr = -1, dialog_tr = -1;
usize_t acked_tr = -1, canceled_tr = -1;
usize_t trless_request = -1, trless_to_tr = -1, trless_response = -1;
usize_t trless_200 = -1, merged_request = -1;
usize_t sent_request = -1, sent_response = -1;
usize_t retry_request = -1, retry_response = -1, recv_retry = -1;
usize_t tout_request = -1, tout_response = -1;
sip_time_t now = sip_now();
nta_agent_get_stats(m_nta,
NTATAG_S_IRQ_HASH_REF(irq_hash),
NTATAG_S_ORQ_HASH_REF(orq_hash),
NTATAG_S_LEG_HASH_REF(leg_hash),
NTATAG_S_IRQ_HASH_USED_REF(irq_used),
NTATAG_S_ORQ_HASH_USED_REF(orq_used),
NTATAG_S_LEG_HASH_USED_REF(leg_used),
NTATAG_S_RECV_MSG_REF(recv_msg),
NTATAG_S_SENT_MSG_REF(sent_msg),
NTATAG_S_RECV_REQUEST_REF(recv_request),
NTATAG_S_RECV_RESPONSE_REF(recv_response),
NTATAG_S_BAD_MESSAGE_REF(bad_message),
NTATAG_S_BAD_REQUEST_REF(bad_request),
NTATAG_S_BAD_RESPONSE_REF(bad_response),
NTATAG_S_DROP_REQUEST_REF(drop_request),
NTATAG_S_DROP_RESPONSE_REF(drop_response),
NTATAG_S_CLIENT_TR_REF(client_tr),
NTATAG_S_SERVER_TR_REF(server_tr),
NTATAG_S_DIALOG_TR_REF(dialog_tr),
NTATAG_S_ACKED_TR_REF(acked_tr),
NTATAG_S_CANCELED_TR_REF(canceled_tr),
NTATAG_S_TRLESS_REQUEST_REF(trless_request),
NTATAG_S_TRLESS_TO_TR_REF(trless_to_tr),
NTATAG_S_TRLESS_RESPONSE_REF(trless_response),
NTATAG_S_TRLESS_200_REF(trless_200),
NTATAG_S_MERGED_REQUEST_REF(merged_request),
NTATAG_S_SENT_REQUEST_REF(sent_request),
NTATAG_S_SENT_RESPONSE_REF(sent_response),
NTATAG_S_RETRY_REQUEST_REF(retry_request),
NTATAG_S_RETRY_RESPONSE_REF(retry_response),
NTATAG_S_RECV_RETRY_REF(recv_retry),
NTATAG_S_TOUT_REQUEST_REF(tout_request),
NTATAG_S_TOUT_RESPONSE_REF(tout_response),
TAG_END()) ;
DR_LOG(log_debug) << "size of hash table for server-side transactions " << dec << irq_hash ;
DR_LOG(log_debug) << "size of hash table for client-side transactions " << orq_hash ;
DR_LOG(log_info) << "size of hash table for dialogs " << leg_hash ;
DR_LOG(log_info) << "number of server-side transactions in the hash table " << irq_used ;
if (bDetail && irq_used > 0) {
nta_incoming_t* irq = NULL;
std::deque<nta_incoming_t*> aged;
do {
irq = nta_get_next_server_txn_from_hash(m_nta, irq);
if (irq) {
const char* method = nta_incoming_method_name(irq);
const char* tag = nta_incoming_gettag(irq);
uint32_t seq = nta_incoming_cseq(irq);
sip_time_t secsSinceReceived = now - nta_incoming_received(irq, NULL);
if (secsSinceReceived > 3600) aged.push_back(irq);
DR_LOG(log_info) << " nta_incoming_t*: " << std::hex << (void *) irq <<
" " << method << " " << std::dec << seq << " remote tag: " << tag <<
" alive " << secsSinceReceived << " secs";
}
} while (irq) ;
/*
std::for_each(aged.begin(), aged.end(), [](nta_incoming_t* irq) {
DR_LOG(log_info) << " destroying very old nta_incoming_t*: " << std::hex << (void *) irq ;
nta_incoming_destroy(irq);
});
*/
}
DR_LOG(log_info) << "number of client-side transactions in the hash table " << orq_used ;
if (bDetail && orq_used > 0) {
nta_outgoing_t* orq = NULL;
do {
orq = nta_get_next_client_txn_from_hash(m_nta, orq);
if (orq) {
const char* method = nta_outgoing_method_name(orq);
const char* callId = nta_outgoing_call_id(orq);
uint32_t seq = nta_outgoing_cseq(orq);
DR_LOG(log_info) << " nta_outgoing_t*: " << std::hex << (void *) orq <<
" " << method << " " << callId << std::dec << " CSeq: " << seq;
}
} while (orq) ;
}
DR_LOG(log_info) << "number of dialogs in the hash table " << leg_used ;
if (bDetail && leg_used > 0) {
nta_leg_t* leg = NULL;
do {
leg = nta_get_next_dialog_from_hash(m_nta, leg);
if (leg) {
const char* localTag = nta_leg_get_tag(leg);
DR_LOG(log_info) << " nta_leg_t*: " << std::hex << (void *) leg <<
" local tag: " << localTag ;
}
} while (leg) ;
}
DR_LOG(log_info) << "number of sip messages received " << recv_msg ;
DR_LOG(log_info) << "number of sip messages sent " << sent_msg ;
DR_LOG(log_info) << "number of sip requests received " << recv_request ;
DR_LOG(log_info) << "number of sip requests sent " << sent_request ;
DR_LOG(log_debug) << "number of bad sip messages received " << bad_message ;
DR_LOG(log_debug) << "number of bad sip requests received " << bad_request ;
DR_LOG(log_debug) << "number of bad sip requests dropped " << drop_request ;
DR_LOG(log_debug) << "number of bad sip reponses dropped " << drop_response ;
DR_LOG(log_debug) << "number of client transactions created " << client_tr ;
DR_LOG(log_debug) << "number of server transactions created " << server_tr ;
DR_LOG(log_info) << "number of in-dialog server transactions created " << dialog_tr ;
DR_LOG(log_debug) << "number of server transactions that have received ack " << acked_tr ;
DR_LOG(log_debug) << "number of server transactions that have received cancel " << canceled_tr ;
DR_LOG(log_debug) << "number of requests that were processed stateless " << trless_request ;
DR_LOG(log_debug) << "number of requests converted to transactions by message callback " << trless_to_tr ;
DR_LOG(log_debug) << "number of responses without matching request " << trless_response ;
DR_LOG(log_debug) << "number of successful responses missing INVITE client transaction " << trless_200 ;
DR_LOG(log_debug) << "number of requests merged by UAS " << merged_request ;
DR_LOG(log_info) << "number of SIP responses sent by stack " << sent_response ;
DR_LOG(log_info) << "number of SIP requests retransmitted by stack " << retry_request ;
DR_LOG(log_info) << "number of SIP responses retransmitted by stack " << retry_response ;
DR_LOG(log_info) << "number of retransmitted SIP requests received by stack " << recv_retry ;
DR_LOG(log_debug) << "number of SIP client transactions that has timeout " << tout_request ;
DR_LOG(log_debug) << "number of SIP server transactions that has timeout " << tout_response ;
STATS_GAUGE_SET(STATS_GAUGE_SOFIA_SERVER_HASH_SIZE, irq_hash)
STATS_GAUGE_SET(STATS_GAUGE_SOFIA_CLIENT_HASH_SIZE, orq_hash)
STATS_GAUGE_SET(STATS_GAUGE_SOFIA_DIALOG_HASH_SIZE, leg_hash)
STATS_GAUGE_SET(STATS_GAUGE_SOFIA_NUM_SERVER_TXNS, irq_used)
STATS_GAUGE_SET(STATS_GAUGE_SOFIA_NUM_CLIENT_TXNS, orq_used)
STATS_GAUGE_SET(STATS_GAUGE_SOFIA_NUM_DIALOGS, leg_used)
STATS_GAUGE_SET(STATS_GAUGE_SOFIA_MSG_RECV, recv_msg)
STATS_GAUGE_SET(STATS_GAUGE_SOFIA_MSG_SENT, sent_msg)
STATS_GAUGE_SET(STATS_GAUGE_SOFIA_REQ_RECV, recv_request)
STATS_GAUGE_SET(STATS_GAUGE_SOFIA_REQ_SENT, sent_request)
STATS_GAUGE_SET(STATS_GAUGE_SOFIA_BAD_MSGS, bad_message)
STATS_GAUGE_SET(STATS_GAUGE_SOFIA_BAD_REQS, bad_request)
STATS_GAUGE_SET(STATS_GAUGE_SOFIA_RETRANS_REQ, retry_request)
STATS_GAUGE_SET(STATS_GAUGE_SOFIA_RETRANS_RES, retry_response)
STATS_GAUGE_SET(STATS_GAUGE_REGISTERED_ENDPOINTS, m_mapUri2InvalidData.size());
}
void DrachtioController::processWatchdogTimer() {
DR_LOG(log_debug) << "DrachtioController::processWatchdogTimer" ;
// expire any UaInvalidData
for( mapUri2InvalidData::iterator it = m_mapUri2InvalidData.begin(); it != m_mapUri2InvalidData.end(); ) {
std::shared_ptr<UaInvalidData> p = it->second ;
if( p->isExpired() ) {
string uri ;
p->getUri(uri) ;
DR_LOG(log_debug) << "DrachtioController::processWatchdogTimer expiring transport for webrtc client: " << uri << " " << (void *) p->getTport() ;
m_mapUri2InvalidData.erase(it++) ;
}
else {
++it ;
}
}
bool bMemoryDebug = m_bMemoryDebug || m_bDumpMemory;
this->printStats(bMemoryDebug) ;
m_pDialogController->logStorageCount(bMemoryDebug) ;
m_pClientController->logStorageCount(bMemoryDebug) ;
m_pPendingRequestController->logStorageCount(bMemoryDebug) ;
m_pProxyController->logStorageCount(bMemoryDebug) ;
m_bDumpMemory = false;
DR_LOG(log_info) << "m_mapUri2InvalidData size: " << m_mapUri2InvalidData.size() ;
#ifdef SOFIA_MSG_DEBUG_TRACE
DR_LOG(log_debug) << "number allocated msg_t " << sofia_msg_count() ;
#endif
}
void DrachtioController::initStats() {
STATS_COUNTER_CREATE(STATS_COUNTER_SIP_REQUESTS_IN, "count of sip requests received")
STATS_COUNTER_CREATE(STATS_COUNTER_SIP_REQUESTS_OUT, "count of sip requests sent")
STATS_COUNTER_CREATE(STATS_COUNTER_SIP_RESPONSES_IN, "count of sip responses received")
STATS_COUNTER_CREATE(STATS_COUNTER_SIP_RESPONSES_OUT, "count of sip responses sent")
STATS_COUNTER_CREATE(STATS_COUNTER_BUILD_INFO, "drachtio version running")
STATS_GAUGE_CREATE(STATS_GAUGE_START_TIME, "drachtio start time")
STATS_GAUGE_CREATE(STATS_GAUGE_STABLE_DIALOGS, "count of SIP dialogs in progress")
STATS_GAUGE_CREATE(STATS_GAUGE_PROXY, "count of proxied call setups in progress")
STATS_GAUGE_CREATE(STATS_GAUGE_REGISTERED_ENDPOINTS, "count of registered endpoints")
STATS_GAUGE_CREATE(STATS_GAUGE_CLIENT_APP_CONNECTIONS, "count of connections to drachtio applications")
//sofia stats
STATS_GAUGE_CREATE(STATS_GAUGE_SOFIA_CLIENT_HASH_SIZE, "current size of sofia hash table for client transactions")
STATS_GAUGE_CREATE(STATS_GAUGE_SOFIA_SERVER_HASH_SIZE, "current size of sofia hash table for server transactions")
STATS_GAUGE_CREATE(STATS_GAUGE_SOFIA_DIALOG_HASH_SIZE, "current size of sofia hash table for dialogs")
STATS_GAUGE_CREATE(STATS_GAUGE_SOFIA_NUM_SERVER_TXNS, "count of sofia server-side transactions")
STATS_GAUGE_CREATE(STATS_GAUGE_SOFIA_NUM_CLIENT_TXNS, "count of sofia client-side transactions")
STATS_GAUGE_CREATE(STATS_GAUGE_SOFIA_NUM_DIALOGS, "count of sofia dialogs")
STATS_GAUGE_CREATE(STATS_GAUGE_SOFIA_MSG_RECV, "count of sip messages received by sofia sip stack")
STATS_GAUGE_CREATE(STATS_GAUGE_SOFIA_MSG_SENT, "count of sip messages sent by sofia sip stack")
STATS_GAUGE_CREATE(STATS_GAUGE_SOFIA_REQ_RECV, "count of sip requests received by sofia sip stack")
STATS_GAUGE_CREATE(STATS_GAUGE_SOFIA_REQ_SENT, "count of sip requests sent by sofia sip stack")
STATS_GAUGE_CREATE(STATS_GAUGE_SOFIA_BAD_MSGS, "count of invalid sip messages received by sofia sip stack")
STATS_GAUGE_CREATE(STATS_GAUGE_SOFIA_BAD_REQS, "count of invalid sip requests received by sofia sip stack")
STATS_GAUGE_CREATE(STATS_GAUGE_SOFIA_RETRANS_REQ, "count of sip requests retransmitted by sofia sip stack")
STATS_GAUGE_CREATE(STATS_GAUGE_SOFIA_RETRANS_RES, "count of sip responses retransmitted by sofia sip stack")
STATS_HISTOGRAM_CREATE(STATS_HISTOGRAM_INVITE_RESPONSE_TIME_IN, "call answer time in seconds for calls received",
{1.0, 3.0, 6.0, 10.0, 15.0, 20.0, 30.0, 60.0})
STATS_HISTOGRAM_CREATE(STATS_HISTOGRAM_INVITE_RESPONSE_TIME_OUT, "call answer time in seconds for calls sent",
{1.0, 3.0, 6.0, 10.0, 15.0, 20.0, 30.0, 60.0})
STATS_HISTOGRAM_CREATE(STATS_HISTOGRAM_INVITE_PDD_IN, "call post-dial delay seconds for calls received",
{1.0, 2.0, 3.0, 5.0, 7.0, 10.0, 15.0, 20.0})
STATS_HISTOGRAM_CREATE(STATS_HISTOGRAM_INVITE_PDD_OUT, "call post-dial delay seconds for calls received",
{1.0, 2.0, 3.0, 5.0, 7.0, 10.0, 15.0, 20.0})
STATS_COUNTER_INCREMENT(STATS_COUNTER_BUILD_INFO, {{"version", DRACHTIO_VERSION}})
STATS_GAUGE_SET_TO_CURRENT_TIME(STATS_GAUGE_START_TIME)
}
}
| [
"[email protected]"
] | |
e60dd3f724c1a229039be6c3dde3bb46630023d4 | f5d3f15095860bd6b56e22dc1e692b4a6cee084e | /src/test/policyestimator_tests.cpp | 2f95aacf387fff94094b33888b47a5e3dac49630 | [
"MIT"
] | permissive | modcrypto/brofist | 052d23c20692ea49d0236470b59d549a2d0133f5 | 6019a1d6a9753071b73de4509943fcc605b698ee | refs/heads/master | 2020-03-08T03:17:12.693725 | 2018-08-31T14:25:46 | 2018-08-31T14:25:46 | 127,886,344 | 2 | 2 | MIT | 2018-07-24T11:47:01 | 2018-04-03T09:44:37 | C++ | UTF-8 | C++ | false | false | 9,844 | cpp | // Copyright (c) 2011-2015 The Bitcoin Core developers
// Distributed under the MIT software license, see the accompanying
// file COPYING or http://www.opensource.org/licenses/mit-license.php.
#include "policy/fees.h"
#include "txmempool.h"
#include "uint256.h"
#include "util.h"
#include "test/test_brofist.h"
#include <boost/test/unit_test.hpp>
BOOST_FIXTURE_TEST_SUITE(policyestimator_tests, BasicTestingSetup)
BOOST_AUTO_TEST_CASE(BlockPolicyEstimates)
{
CTxMemPool mpool(CFeeRate(10000)); // we have 10x higher fee
TestMemPoolEntryHelper entry;
CAmount basefee(20000); // we have 10x higher fee
double basepri = 1e6;
CAmount deltaFee(1000); // we have 10x higher fee
double deltaPri=5e5;
std::vector<CAmount> feeV[2];
std::vector<double> priV[2];
// Populate vectors of increasing fees or priorities
for (int j = 0; j < 10; j++) {
//V[0] is for fee transactions
feeV[0].push_back(basefee * (j+1));
priV[0].push_back(0);
//V[1] is for priority transactions
feeV[1].push_back(CAmount(0));
priV[1].push_back(basepri * pow(10, j+1));
}
// Store the hashes of transactions that have been
// added to the mempool by their associate fee/pri
// txHashes[j] is populated with transactions either of
// fee = basefee * (j+1) OR pri = 10^6 * 10^(j+1)
std::vector<uint256> txHashes[10];
// Create a transaction template
CScript garbage;
for (unsigned int i = 0; i < 128; i++)
garbage.push_back('X');
CMutableTransaction tx;
std::list<CTransaction> dummyConflicted;
tx.vin.resize(1);
tx.vin[0].scriptSig = garbage;
tx.vout.resize(1);
tx.vout[0].nValue=0LL;
CFeeRate baseRate(basefee, ::GetSerializeSize(tx, SER_NETWORK, PROTOCOL_VERSION));
// Create a fake block
std::vector<CTransaction> block;
int blocknum = 0;
// Loop through 200 blocks
// At a decay .998 and 4 fee transactions per block
// This makes the tx count about 1.33 per bucket, above the 1 threshold
while (blocknum < 200) {
for (int j = 0; j < 10; j++) { // For each fee/pri multiple
for (int k = 0; k < 5; k++) { // add 4 fee txs for every priority tx
tx.vin[0].prevout.n = 10000*blocknum+100*j+k; // make transaction unique
uint256 hash = tx.GetHash();
mpool.addUnchecked(hash, entry.Fee(feeV[k/4][j]).Time(GetTime()).Priority(priV[k/4][j]).Height(blocknum).FromTx(tx, &mpool));
txHashes[j].push_back(hash);
}
}
//Create blocks where higher fee/pri txs are included more often
for (int h = 0; h <= blocknum%10; h++) {
// 10/10 blocks add highest fee/pri transactions
// 9/10 blocks add 2nd highest and so on until ...
// 1/10 blocks add lowest fee/pri transactions
while (txHashes[9-h].size()) {
CTransaction btx;
if (mpool.lookup(txHashes[9-h].back(), btx))
block.push_back(btx);
txHashes[9-h].pop_back();
}
}
mpool.removeForBlock(block, ++blocknum, dummyConflicted);
block.clear();
if (blocknum == 30) {
// At this point we should need to combine 5 buckets to get enough data points
// So estimateFee(1,2,3) should fail and estimateFee(4) should return somewhere around
// 8*baserate. estimateFee(4) %'s are 100,100,100,100,90 = average 98%
BOOST_CHECK(mpool.estimateFee(1) == CFeeRate(0));
BOOST_CHECK(mpool.estimateFee(2) == CFeeRate(0));
BOOST_CHECK(mpool.estimateFee(3) == CFeeRate(0));
BOOST_CHECK(mpool.estimateFee(4).GetFeePerK() < 8*baseRate.GetFeePerK() + deltaFee);
BOOST_CHECK(mpool.estimateFee(4).GetFeePerK() > 8*baseRate.GetFeePerK() - deltaFee);
int answerFound;
BOOST_CHECK(mpool.estimateSmartFee(1, &answerFound) == mpool.estimateFee(4) && answerFound == 4);
BOOST_CHECK(mpool.estimateSmartFee(3, &answerFound) == mpool.estimateFee(4) && answerFound == 4);
BOOST_CHECK(mpool.estimateSmartFee(4, &answerFound) == mpool.estimateFee(4) && answerFound == 4);
BOOST_CHECK(mpool.estimateSmartFee(8, &answerFound) == mpool.estimateFee(8) && answerFound == 8);
}
}
std::vector<CAmount> origFeeEst;
std::vector<double> origPriEst;
// Highest feerate is 10*baseRate and gets in all blocks,
// second highest feerate is 9*baseRate and gets in 9/10 blocks = 90%,
// third highest feerate is 8*base rate, and gets in 8/10 blocks = 80%,
// so estimateFee(1) should return 10*baseRate.
// Second highest feerate has 100% chance of being included by 2 blocks,
// so estimateFee(2) should return 9*baseRate etc...
for (int i = 1; i < 10;i++) {
origFeeEst.push_back(mpool.estimateFee(i).GetFeePerK());
origPriEst.push_back(mpool.estimatePriority(i));
if (i > 1) { // Fee estimates should be monotonically decreasing
BOOST_CHECK(origFeeEst[i-1] <= origFeeEst[i-2]);
BOOST_CHECK(origPriEst[i-1] <= origPriEst[i-2]);
}
int mult = 11-i;
BOOST_CHECK(origFeeEst[i-1] < mult*baseRate.GetFeePerK() + deltaFee);
BOOST_CHECK(origFeeEst[i-1] > mult*baseRate.GetFeePerK() - deltaFee);
BOOST_CHECK(origPriEst[i-1] < pow(10,mult) * basepri + deltaPri);
BOOST_CHECK(origPriEst[i-1] > pow(10,mult) * basepri - deltaPri);
}
// Mine 50 more blocks with no transactions happening, estimates shouldn't change
// We haven't decayed the moving average enough so we still have enough data points in every bucket
while (blocknum < 250)
mpool.removeForBlock(block, ++blocknum, dummyConflicted);
for (int i = 1; i < 10;i++) {
BOOST_CHECK(mpool.estimateFee(i).GetFeePerK() < origFeeEst[i-1] + deltaFee);
BOOST_CHECK(mpool.estimateFee(i).GetFeePerK() > origFeeEst[i-1] - deltaFee);
BOOST_CHECK(mpool.estimatePriority(i) < origPriEst[i-1] + deltaPri);
BOOST_CHECK(mpool.estimatePriority(i) > origPriEst[i-1] - deltaPri);
}
// Mine 15 more blocks with lots of transactions happening and not getting mined
// Estimates should go up
while (blocknum < 265) {
for (int j = 0; j < 10; j++) { // For each fee/pri multiple
for (int k = 0; k < 5; k++) { // add 4 fee txs for every priority tx
tx.vin[0].prevout.n = 10000*blocknum+100*j+k;
uint256 hash = tx.GetHash();
mpool.addUnchecked(hash, entry.Fee(feeV[k/4][j]).Time(GetTime()).Priority(priV[k/4][j]).Height(blocknum).FromTx(tx, &mpool));
txHashes[j].push_back(hash);
}
}
mpool.removeForBlock(block, ++blocknum, dummyConflicted);
}
int answerFound;
for (int i = 1; i < 10;i++) {
BOOST_CHECK(mpool.estimateFee(i) == CFeeRate(0) || mpool.estimateFee(i).GetFeePerK() > origFeeEst[i-1] - deltaFee);
BOOST_CHECK(mpool.estimateSmartFee(i, &answerFound).GetFeePerK() > origFeeEst[answerFound-1] - deltaFee);
BOOST_CHECK(mpool.estimatePriority(i) == -1 || mpool.estimatePriority(i) > origPriEst[i-1] - deltaPri);
BOOST_CHECK(mpool.estimateSmartPriority(i, &answerFound) > origPriEst[answerFound-1] - deltaPri);
}
// Mine all those transactions
// Estimates should still not be below original
for (int j = 0; j < 10; j++) {
while(txHashes[j].size()) {
CTransaction btx;
if (mpool.lookup(txHashes[j].back(), btx))
block.push_back(btx);
txHashes[j].pop_back();
}
}
mpool.removeForBlock(block, 265, dummyConflicted);
block.clear();
for (int i = 1; i < 10;i++) {
BOOST_CHECK(mpool.estimateFee(i).GetFeePerK() > origFeeEst[i-1] - deltaFee);
BOOST_CHECK(mpool.estimatePriority(i) > origPriEst[i-1] - deltaPri);
}
// Mine 200 more blocks where everything is mined every block
// Estimates should be below original estimates
while (blocknum < 465) {
for (int j = 0; j < 10; j++) { // For each fee/pri multiple
for (int k = 0; k < 5; k++) { // add 4 fee txs for every priority tx
tx.vin[0].prevout.n = 10000*blocknum+100*j+k;
uint256 hash = tx.GetHash();
mpool.addUnchecked(hash, entry.Fee(feeV[k/4][j]).Time(GetTime()).Priority(priV[k/4][j]).Height(blocknum).FromTx(tx, &mpool));
CTransaction btx;
if (mpool.lookup(hash, btx))
block.push_back(btx);
}
}
mpool.removeForBlock(block, ++blocknum, dummyConflicted);
block.clear();
}
for (int i = 1; i < 10; i++) {
BOOST_CHECK(mpool.estimateFee(i).GetFeePerK() < origFeeEst[i-1] - deltaFee);
BOOST_CHECK(mpool.estimatePriority(i) < origPriEst[i-1] - deltaPri);
}
// Test that if the mempool is limited, estimateSmartFee won't return a value below the mempool min fee
// and that estimateSmartPriority returns essentially an infinite value
mpool.addUnchecked(tx.GetHash(), entry.Fee(feeV[0][5]).Time(GetTime()).Priority(priV[1][5]).Height(blocknum).FromTx(tx, &mpool));
// evict that transaction which should set a mempool min fee of minRelayTxFee + feeV[0][5]
mpool.TrimToSize(1);
BOOST_CHECK(mpool.GetMinFee(1).GetFeePerK() > feeV[0][5]);
for (int i = 1; i < 10; i++) {
BOOST_CHECK(mpool.estimateSmartFee(i).GetFeePerK() >= mpool.estimateFee(i).GetFeePerK());
BOOST_CHECK(mpool.estimateSmartFee(i).GetFeePerK() >= mpool.GetMinFee(1).GetFeePerK());
BOOST_CHECK(mpool.estimateSmartPriority(i) == INF_PRIORITY);
}
}
BOOST_AUTO_TEST_SUITE_END()
| [
"[email protected]"
] | |
12048c557ee5609a652ea48907b2cc0ef43252b7 | 9f058d00b81cafa23119f4668665776bc0b6763e | /ros_workspace/src/vision_opencv/cv_bridge/include/cv_bridge/cv_bridge.h | e1d89c04f706fecb5fb04a75cc6b728ba4e462c6 | [] | no_license | contradict/SampleReturn | 4f24ecdd4e75d604d21f33239ee644b9705571f0 | f07bb0313d6aa83eea7b70e97ddcc58a41be4f66 | refs/heads/master | 2021-01-19T01:57:06.882336 | 2017-02-20T21:16:57 | 2017-02-20T21:16:57 | 2,648,781 | 3 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 15,549 | h | /*********************************************************************
* Software License Agreement (BSD License)
*
* Copyright (c) 2011, Willow Garage, Inc,
* Copyright (c) 2015, Tal Regev.
* 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 Willow Garage nor the names of its
* contributors may be used to endorse or promote products derived
* from this software without specific prior written permission.
*
* THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS
* "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT
* LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS
* FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE
* COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
* INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING,
* BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
* LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER
* CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT
* LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
* ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
* POSSIBILITY OF SUCH DAMAGE.
*********************************************************************/
#ifndef CV_BRIDGE_CV_BRIDGE_H
#define CV_BRIDGE_CV_BRIDGE_H
#include <sensor_msgs/Image.h>
#include <sensor_msgs/CompressedImage.h>
#include <sensor_msgs/image_encodings.h>
#include <ros/static_assert.h>
#include <opencv2/core/core.hpp>
#include <opencv2/imgproc/imgproc.hpp>
#include <opencv2/imgproc/types_c.h>
#include <stdexcept>
namespace cv_bridge {
class Exception : public std::runtime_error
{
public:
Exception(const std::string& description) : std::runtime_error(description) {}
};
class CvImage;
typedef boost::shared_ptr<CvImage> CvImagePtr;
typedef boost::shared_ptr<CvImage const> CvImageConstPtr;
//from: http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#Mat imread(const string& filename, int flags)
typedef enum {
BMP, DIP,
JPG, JPEG, JPE,
JP2,
PNG,
PBM, PGM, PPM,
SR, RAS,
TIFF, TIF,
} Format;
/**
* \brief Image message class that is interoperable with sensor_msgs/Image but uses a
* more convenient cv::Mat representation for the image data.
*/
class CvImage
{
public:
std_msgs::Header header; //!< ROS header
std::string encoding; //!< Image encoding ("mono8", "bgr8", etc.)
cv::Mat image; //!< Image data for use with OpenCV
/**
* \brief Empty constructor.
*/
CvImage() {}
/**
* \brief Constructor.
*/
CvImage(const std_msgs::Header& header, const std::string& encoding,
const cv::Mat& image = cv::Mat())
: header(header), encoding(encoding), image(image)
{
}
/**
* \brief Convert this message to a ROS sensor_msgs::Image message.
*
* The returned sensor_msgs::Image message contains a copy of the image data.
*/
sensor_msgs::ImagePtr toImageMsg() const;
/**
* dst_format is compress the image to desire format.
* Default value is empty string that will convert to jpg format.
* can be: jpg, jp2, bmp, png, tif at the moment
* support this format from opencv:
* http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#Mat imread(const string& filename, int flags)
*/
sensor_msgs::CompressedImagePtr toCompressedImageMsg(const Format dst_format = JPG) const;
/**
* \brief Copy the message data to a ROS sensor_msgs::Image message.
*
* This overload is intended mainly for aggregate messages such as stereo_msgs::DisparityImage,
* which contains a sensor_msgs::Image as a data member.
*/
void toImageMsg(sensor_msgs::Image& ros_image) const;
/**
* dst_format is compress the image to desire format.
* Default value is empty string that will convert to jpg format.
* can be: jpg, jp2, bmp, png, tif at the moment
* support this format from opencv:
* http://docs.opencv.org/modules/highgui/doc/reading_and_writing_images_and_video.html#Mat imread(const string& filename, int flags)
*/
void toCompressedImageMsg(sensor_msgs::CompressedImage& ros_image, const Format dst_format = JPG) const;
typedef boost::shared_ptr<CvImage> Ptr;
typedef boost::shared_ptr<CvImage const> ConstPtr;
protected:
boost::shared_ptr<void const> tracked_object_; // for sharing ownership
/// @cond DOXYGEN_IGNORE
friend
CvImageConstPtr toCvShare(const sensor_msgs::Image& source,
const boost::shared_ptr<void const>& tracked_object,
const std::string& encoding);
/// @endcond
};
/**
* \brief Convert a sensor_msgs::Image message to an OpenCV-compatible CvImage, copying the
* image data.
*
* \param source A shared_ptr to a sensor_msgs::Image message
* \param encoding The desired encoding of the image data, one of the following strings:
* - \c "mono8"
* - \c "bgr8"
* - \c "bgra8"
* - \c "rgb8"
* - \c "rgba8"
* - \c "mono16"
*
* If \a encoding is the empty string (the default), the returned CvImage has the same encoding
* as \a source.
*/
CvImagePtr toCvCopy(const sensor_msgs::ImageConstPtr& source,
const std::string& encoding = std::string());
CvImagePtr toCvCopy(const sensor_msgs::CompressedImageConstPtr& source,
const std::string& encoding = std::string());
/**
* \brief Convert a sensor_msgs::Image message to an OpenCV-compatible CvImage, copying the
* image data.
*
* \param source A sensor_msgs::Image message
* \param encoding The desired encoding of the image data, one of the following strings:
* - \c "mono8"
* - \c "bgr8"
* - \c "bgra8"
* - \c "rgb8"
* - \c "rgba8"
* - \c "mono16"
*
* If \a encoding is the empty string (the default), the returned CvImage has the same encoding
* as \a source.
* If the source is 8bit and the encoding 16 or vice-versa, a scaling is applied (65535/255 and
* 255/65535 respectively). Otherwise, no scaling is applied and the rules from the convertTo OpenCV
* function are applied (capping): http://docs.opencv.org/modules/core/doc/basic_structures.html#mat-convertto
*/
CvImagePtr toCvCopy(const sensor_msgs::Image& source,
const std::string& encoding = std::string());
CvImagePtr toCvCopy(const sensor_msgs::CompressedImage& source,
const std::string& encoding = std::string());
/**
* \brief Convert an immutable sensor_msgs::Image message to an OpenCV-compatible CvImage, sharing
* the image data if possible.
*
* If the source encoding and desired encoding are the same, the returned CvImage will share
* the image data with \a source without copying it. The returned CvImage cannot be modified, as that
* could modify the \a source data.
*
* \param source A shared_ptr to a sensor_msgs::Image message
* \param encoding The desired encoding of the image data, one of the following strings:
* - \c "mono8"
* - \c "bgr8"
* - \c "bgra8"
* - \c "rgb8"
* - \c "rgba8"
* - \c "mono16"
*
* If \a encoding is the empty string (the default), the returned CvImage has the same encoding
* as \a source.
*/
CvImageConstPtr toCvShare(const sensor_msgs::ImageConstPtr& source,
const std::string& encoding = std::string());
/**
* \brief Convert an immutable sensor_msgs::Image message to an OpenCV-compatible CvImage, sharing
* the image data if possible.
*
* If the source encoding and desired encoding are the same, the returned CvImage will share
* the image data with \a source without copying it. The returned CvImage cannot be modified, as that
* could modify the \a source data.
*
* This overload is useful when you have a shared_ptr to a message that contains a
* sensor_msgs::Image, and wish to share ownership with the containing message.
*
* \param source The sensor_msgs::Image message
* \param tracked_object A shared_ptr to an object owning the sensor_msgs::Image
* \param encoding The desired encoding of the image data, one of the following strings:
* - \c "mono8"
* - \c "bgr8"
* - \c "bgra8"
* - \c "rgb8"
* - \c "rgba8"
* - \c "mono16"
*
* If \a encoding is the empty string (the default), the returned CvImage has the same encoding
* as \a source.
*/
CvImageConstPtr toCvShare(const sensor_msgs::Image& source,
const boost::shared_ptr<void const>& tracked_object,
const std::string& encoding = std::string());
/**
* \brief Convert a CvImage to another encoding using the same rules as toCvCopy
*/
CvImagePtr cvtColor(const CvImageConstPtr& source,
const std::string& encoding);
struct CvtColorForDisplayOptions {
CvtColorForDisplayOptions() : do_dynamic_scaling(false), min_image_value(0.0), max_image_value(0.0), colormap(-1) {}
bool do_dynamic_scaling;
double min_image_value;
double max_image_value;
int colormap;
};
/**
* \brief Converts an immutable sensor_msgs::Image message to another CvImage for display purposes,
* using practical conversion rules if needed.
*
* Data will be shared between input and output if possible.
*
* Recall: sensor_msgs::image_encodings::isColor and isMono tell whether an image contains R,G,B,A, mono
* (or any combination/subset) with 8 or 16 bit depth.
*
* The following rules apply:
* - if the output encoding is empty, the fact that the input image is mono or multiple-channel is
* preserved in the ouput image. The bit depth will be 8. it tries to convert to BGR no matter what
* encoding image is passed.
* - if the output encoding is not empty, it must have sensor_msgs::image_encodings::isColor and
* isMono return true. It must also be 8 bit in depth
* - if the input encoding is an OpenCV format (e.g. 8UC1), and if we have 1,3 or 4 channels, it is
* respectively converted to mono, BGR or BGRA.
* - if the input encoding is 32SC1, this estimate that image as label image and will convert it as
* bgr image with different colors for each label.
*
* \param source A shared_ptr to a sensor_msgs::Image message
* \param encoding Either an encoding string that returns true in sensor_msgs::image_encodings::isColor
* isMono or the empty string as explained above.
* \param options (cv_bridge::CvtColorForDisplayOptions) Options to convert the source image with.
* - do_dynamic_scaling If true, the image is dynamically scaled between its minimum and maximum value
* before being converted to its final encoding.
* - min_image_value Independently from do_dynamic_scaling, if min_image_value and max_image_value are
* different, the image is scaled between these two values before being converted to its final encoding.
* - max_image_value Maximum image value
* - colormap Colormap which the source image converted with.
*/
CvImageConstPtr cvtColorForDisplay(const CvImageConstPtr& source,
const std::string& encoding = std::string(),
const CvtColorForDisplayOptions options = CvtColorForDisplayOptions());
/**
* \brief Get the OpenCV type enum corresponding to the encoding.
*
* For example, "bgr8" -> CV_8UC3.
*/
int getCvType(const std::string& encoding);
} // namespace cv_bridge
// CvImage as a first class message type
// The rest of this file hooks into the roscpp serialization API to make CvImage
// a first-class message type you can publish and subscribe to directly.
// Unfortunately this doesn't yet work with image_transport, so don't rewrite all
// your callbacks to use CvImage! It might be useful for specific tasks, like
// processing bag files.
/// @cond DOXYGEN_IGNORE
namespace ros {
namespace message_traits {
template<> struct MD5Sum<cv_bridge::CvImage>
{
static const char* value() { return MD5Sum<sensor_msgs::Image>::value(); }
static const char* value(const cv_bridge::CvImage&) { return value(); }
static const uint64_t static_value1 = MD5Sum<sensor_msgs::Image>::static_value1;
static const uint64_t static_value2 = MD5Sum<sensor_msgs::Image>::static_value2;
// If the definition of sensor_msgs/Image changes, we'll get a compile error here.
ROS_STATIC_ASSERT(MD5Sum<sensor_msgs::Image>::static_value1 == 0x060021388200f6f0ULL);
ROS_STATIC_ASSERT(MD5Sum<sensor_msgs::Image>::static_value2 == 0xf447d0fcd9c64743ULL);
};
template<> struct DataType<cv_bridge::CvImage>
{
static const char* value() { return DataType<sensor_msgs::Image>::value(); }
static const char* value(const cv_bridge::CvImage&) { return value(); }
};
template<> struct Definition<cv_bridge::CvImage>
{
static const char* value() { return Definition<sensor_msgs::Image>::value(); }
static const char* value(const cv_bridge::CvImage&) { return value(); }
};
template<> struct HasHeader<cv_bridge::CvImage> : TrueType {};
} // namespace ros::message_traits
namespace serialization {
template<> struct Serializer<cv_bridge::CvImage>
{
/// @todo Still ignoring endianness...
template<typename Stream>
inline static void write(Stream& stream, const cv_bridge::CvImage& m)
{
stream.next(m.header);
stream.next((uint32_t)m.image.rows); // height
stream.next((uint32_t)m.image.cols); // width
stream.next(m.encoding);
uint8_t is_bigendian = 0;
stream.next(is_bigendian);
stream.next((uint32_t)m.image.step);
size_t data_size = m.image.step*m.image.rows;
stream.next((uint32_t)data_size);
if (data_size > 0)
memcpy(stream.advance(data_size), m.image.data, data_size);
}
template<typename Stream>
inline static void read(Stream& stream, cv_bridge::CvImage& m)
{
stream.next(m.header);
uint32_t height, width;
stream.next(height);
stream.next(width);
stream.next(m.encoding);
uint8_t is_bigendian;
stream.next(is_bigendian);
uint32_t step, data_size;
stream.next(step);
stream.next(data_size);
int type = cv_bridge::getCvType(m.encoding);
// Construct matrix pointing to the stream data, then copy it to m.image
cv::Mat tmp((int)height, (int)width, type, stream.advance(data_size), (size_t)step);
tmp.copyTo(m.image);
}
inline static uint32_t serializedLength(const cv_bridge::CvImage& m)
{
size_t data_size = m.image.step*m.image.rows;
return serializationLength(m.header) + serializationLength(m.encoding) + 17 + data_size;
}
};
} // namespace ros::serialization
namespace message_operations {
template<> struct Printer<cv_bridge::CvImage>
{
template<typename Stream>
static void stream(Stream& s, const std::string& indent, const cv_bridge::CvImage& m)
{
/// @todo Replicate printing for sensor_msgs::Image
}
};
} // namespace ros::message_operations
} // namespace ros
namespace cv_bridge {
inline std::ostream& operator<<(std::ostream& s, const CvImage& m)
{
ros::message_operations::Printer<CvImage>::stream(s, "", m);
return s;
}
} // namespace cv_bridge
/// @endcond
#endif
| [
"[email protected]"
] | |
0a51aa13aeb43d964e7ec59c3569554d78aaadbc | f5cae300681b72f0003e046b4f93cff3f1b80c3e | /tasks/2.cpp | 0d32e65f81e1da56dd5cd9cf7080bebbac7662e5 | [] | no_license | farit2000/OpenMP_tests | 714bdec641b040e74708153e5c4d7a8a08199b9c | 967aa1bc0d419ce41136492caa5db72d8ae0ade8 | refs/heads/master | 2023-01-03T03:42:02.568502 | 2020-10-26T21:19:51 | 2020-10-26T21:19:51 | 307,507,337 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 495 | cpp | #include <iostream>
#include <omp.h>
#pragma clang diagnostic push
#pragma ide diagnostic ignored "openmp-use-default-none"
void second()
{
int n = 3;
omp_set_num_threads(3);
#pragma omp parallel if(n > 2)
{
printf("Tread(%d) of %d\n", omp_get_thread_num(), omp_get_num_threads());
}
omp_set_num_threads(2);
#pragma omp parallel if(n > 2)
{
printf("Tread(%d) of %d\n", omp_get_thread_num(), omp_get_num_threads());
}
}
#pragma clang diagnostic pop
| [
"[email protected]"
] | |
83ee0d7abfac62771e8f852e947be2195572294d | c53bbbdb65378437e05ef1e0de0041684e1797cb | /CONTRIB/LLVM/src/lib/Dbg/DWARF/DWARFDebugLoc.cpp | cd6fbefd05dd1d75c1da0d6c716ddde7e14dbd8e | [
"Apache-2.0"
] | permissive | Maeiky/CpcdosOS2.1-1 | b4d087b85f137f44fc34a521ebede3a5fc1d6c59 | 95910f2fe0cfeda592d6c47d8fa29f380b2b4d08 | refs/heads/main | 2023-03-26T08:39:40.606756 | 2021-03-16T05:57:00 | 2021-03-16T05:57:00 | 345,801,854 | 0 | 0 | Apache-2.0 | 2021-03-08T21:36:06 | 2021-03-08T21:36:06 | null | UTF-8 | C++ | false | false | 4,290 | cpp | //===-- DWARFDebugLoc.cpp -------------------------------------------------===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "llvm/DebugInfo/DWARF/DWARFDebugLoc.h"
#include "llvm/Support/Compiler.h"
#include "llvm/Support/Dwarf.h"
#include "llvm/Support/Format.h"
#include "llvm/Support/raw_ostream.h"
using namespace llvm;
void DWARFDebugLoc::dump(raw_ostream &OS) const {
for (const LocationList &L : Locations) {
OS << format("0x%8.8x: ", L.Offset);
const unsigned Indent = 12;
for (const Entry &E : L.Entries) {
if (&E != L.Entries.begin())
OS.indent(Indent);
OS << "Beginning address offset: " << format("0x%016" PRIx64, E.Begin)
<< '\n';
OS.indent(Indent) << " Ending address offset: "
<< format("0x%016" PRIx64, E.End) << '\n';
OS.indent(Indent) << " Location description: ";
for (unsigned char Loc : E.Loc) {
OS << format("%2.2x ", Loc);
}
OS << "\n\n";
}
}
}
void DWARFDebugLoc::parse(DataExtractor data, unsigned AddressSize) {
uint32_t Offset = 0;
while (data.isValidOffset(Offset+AddressSize-1)) {
Locations.resize(Locations.size() + 1);
LocationList &Loc = Locations.back();
Loc.Offset = Offset;
// 2.6.2 Location Lists
// A location list entry consists of:
while (true) {
Entry E;
RelocAddrMap::const_iterator AI = RelocMap.find(Offset);
// 1. A beginning address offset. ...
E.Begin = data.getUnsigned(&Offset, AddressSize);
if (AI != RelocMap.end())
E.Begin += AI->second.second;
AI = RelocMap.find(Offset);
// 2. An ending address offset. ...
E.End = data.getUnsigned(&Offset, AddressSize);
if (AI != RelocMap.end())
E.End += AI->second.second;
// The end of any given location list is marked by an end of list entry,
// which consists of a 0 for the beginning address offset and a 0 for the
// ending address offset.
if (E.Begin == 0 && E.End == 0)
break;
unsigned Bytes = data.getU16(&Offset);
// A single location description describing the location of the object...
StringRef str = data.getData().substr(Offset, Bytes);
Offset += Bytes;
E.Loc.append(str.begin(), str.end());
Loc.Entries.push_back(std::move(E));
}
}
if (data.isValidOffset(Offset))
llvm::errs() << "error: failed to consume entire .debug_loc section\n";
}
void DWARFDebugLocDWO::parse(DataExtractor data) {
uint32_t Offset = 0;
while (data.isValidOffset(Offset)) {
Locations.resize(Locations.size() + 1);
LocationList &Loc = Locations.back();
Loc.Offset = Offset;
dwarf::LocationListEntry Kind;
while ((Kind = static_cast<dwarf::LocationListEntry>(
data.getU8(&Offset))) != dwarf::DW_LLE_end_of_list_entry) {
if (Kind != dwarf::DW_LLE_start_length_entry) {
llvm::errs() << "error: dumping support for LLE of kind " << (int)Kind
<< " not implemented\n";
return;
}
Entry E;
E.Start = data.getULEB128(&Offset);
E.Length = data.getU32(&Offset);
unsigned Bytes = data.getU16(&Offset);
// A single location description describing the location of the object...
StringRef str = data.getData().substr(Offset, Bytes);
Offset += Bytes;
E.Loc.resize(str.size());
std::copy(str.begin(), str.end(), E.Loc.begin());
Loc.Entries.push_back(std::move(E));
}
}
}
void DWARFDebugLocDWO::dump(raw_ostream &OS) const {
for (const LocationList &L : Locations) {
OS << format("0x%8.8x: ", L.Offset);
const unsigned Indent = 12;
for (const Entry &E : L.Entries) {
if (&E != L.Entries.begin())
OS.indent(Indent);
OS << "Beginning address index: " << E.Start << '\n';
OS.indent(Indent) << " Length: " << E.Length << '\n';
OS.indent(Indent) << " Location description: ";
for (unsigned char Loc : E.Loc)
OS << format("%2.2x ", Loc);
OS << "\n\n";
}
}
}
| [
"[email protected]"
] | |
a8f53fc77debcf1b05c43e5091e0faae1bc27f52 | 6b29d831cbedab25b491f8bc65ada1a492c905ab | /MainGame/UI/UI.h | d892fe6a702821ffa95cbbcd578ad05aa50a07bb | [] | no_license | preun/GoonZu | 375dd23485627322b7c67d044ad55a6186686675 | 93ff9c170107d15b3621fc0fe8af943114aa502a | refs/heads/master | 2020-04-17T10:58:59.737850 | 2019-03-15T03:09:50 | 2019-03-15T03:09:50 | 166,521,901 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 334 | h | #pragma once
#include "gameNode.h"
class UI :
public gameNode
{
int* _maxHP;
int* _currentHP;
int* _maxMP;
int* _currentMP;
int* _level;
int* _exp;
public:
UI();
~UI();
HRESULT init(int* maxHP, int* currentHP, int* maxMP, int* currentMP, int* level, int* exp);
void release();
void update() ;
void render() ;
};
| [
"[email protected]"
] | |
edab06d11c08ca24c5f48083fafcea594fcf3882 | e234e0bb9e9f6a482caab3b495b69841dc4ed8df | /day00/ex01/Phonebook.class.cpp | 5612f30cd6a3487af2220150e0fdb4dae38ab8ee | [] | no_license | Minumu/CPP-pool | cbe4407d9c0f0d10a7e0b16dd5325b4c2f5049de | 9e68ddf4cf1569f05a4fabc380947a41d77a8df3 | refs/heads/master | 2020-03-27T07:14:07.250160 | 2018-08-26T11:41:14 | 2018-08-26T11:41:14 | 146,173,795 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 5,007 | cpp | // ************************************************************************** //
// //
// ::: :::::::: //
// Phonebook.class.cpp :+: :+: :+: //
// +:+ +:+ +:+ //
// By: tshevchu <[email protected]> +#+ +:+ +#+ //
// +#+#+#+#+#+ +#+ //
// Created: 2018/06/19 20:31:04 by tshevchu #+# #+# //
// Updated: 2018/06/19 20:31:26 by tshevchu ### ########.fr //
// //
// ************************************************************************** //
#include "Phonebook.class.hpp"
#include "Contacts.class.hpp"
Phonebook::Phonebook()
{
this->_idContact = 0;
start();
}
Phonebook::~Phonebook()
{
return;
}
void Phonebook::start()
{
std::cout << "Hello! This is an awesome phonebook!" << std::endl;
std::cout << "You can add 8 contacts. Seriously, it's maximum that I can." << std::endl;
std::cout << "I know 'ADD', 'SEARCH' and 'EXIT' commands. Hope, you understand what they mean." << std::endl;
std::cout << "Let's go! Write your command! I'm waiting..." << std::endl;
while (1)
{
std::cout << "command: ";
std::getline(std::cin, this->command);
if (this->command.compare("ADD") == 0)
this->add();
else if (this->command.compare("SEARCH") == 0)
this->search();
else if (this->command.compare("EXIT") == 0)
exit(0);
else
std::cout << "Only three commands are available: 'ADD', 'SEARCH', 'EXIT'. Try again" << std::endl;
}
}
void Phonebook::add()
{
if (this->_idContact < 8)
{
std::cout << "Contact #" << this->_idContact + 1 << std::endl;
_contacts[this->_idContact].setFirstName();
_contacts[this->_idContact].setLastName();
_contacts[this->_idContact].setNickname();
_contacts[this->_idContact].setLogin();
_contacts[this->_idContact].setPostalAddress();
_contacts[this->_idContact].setEmailAddress();
_contacts[this->_idContact].setPhoneNumber();
_contacts[this->_idContact].setBirthdayDate();
_contacts[this->_idContact].setFavoriteMeal();
_contacts[this->_idContact].setUnderwearColor();
_contacts[this->_idContact].setDarkestSecret();
this->_idContact++;
}
else
std::cout << "Oops, it's ninth contact. I can't add it. I told you." << std::endl;
}
void Phonebook::search()
{
if (this->_idContact > 0)
{
this->printContacts();
this->printOneContact();
}
else
{
std::cout << "This awesome phonebook (it's me, yes) doesn't have any contact. You need to add at least one." << std::endl;
}
}
void Phonebook::printContacts()
{
for (int i = 0; i < this->_idContact; i++)
{
std::cout << "|" << std::setw(10) << i + 1 << "|";
this->checkLength(this->_contacts[i].getFirstName());
this->checkLength(this->_contacts[i].getLastName());
this->checkLength(this->_contacts[i].getNickname());
std::cout << std::endl;
}
}
void Phonebook::checkLength(std::string input)
{
if (input.length() > 10)
{
std::cout << input.substr(0, 9) << ".|";
}
else
{
std::cout << std::setw(10) << input << "|";
}
}
void Phonebook::printOneContact()
{
std::string idCont;
int id;
std::cout << "You can see full information about one of this contacts." << std::endl;
while (1)
{
std::cout << "Enter ID of the desired one: ";
std::getline(std::cin, idCont);
if (idCont.length() == 1 && std::isdigit(idCont[0]))
{
id = atoi(idCont.c_str());
if (id > 0 && id <= this->_idContact)
{
std::cout << "First name :" << this->_contacts[id - 1].getFirstName() << std::endl;
std::cout << "Last name :" << this->_contacts[id - 1].getLastName() << std::endl;
std::cout << "Nick name :" << this->_contacts[id - 1].getNickname() << std::endl;
std::cout << "Login :" << this->_contacts[id - 1].getLogin() << std::endl;
std::cout << "Postal address :" << this->_contacts[id - 1].getPostalAddress() << std::endl;
std::cout << "Email address :" << this->_contacts[id - 1].getEmailAddress() << std::endl;
std::cout << "Phone number :" << this->_contacts[id - 1].getPhoneNumber() << std::endl;
std::cout << "Birthday date :" << this->_contacts[id - 1].getBirthdayDate() << std::endl;
std::cout << "Favorite meal :" << this->_contacts[id - 1].getFavoriteMeal() << std::endl;
std::cout << "Underwear color:" << this->_contacts[id - 1].getUnderwearColor() << std::endl;
std::cout << "Darkest secret :" << this->_contacts[id - 1].getDarkestSecret() << std::endl;
return;
}
else
{
std::cout << "Ooops, seems like you enter invalid ID. Try again. I'm patient..." << std::endl;
}
}
else
{
std::cout << "Ooops, seems like you enter invalid ID. Try again. I'm patient..." << std::endl;
}
}
}
| [
"[email protected]"
] | |
f3d7df3257e01c75311dc00b7b43e94808674f99 | 3758f9f68b5209efe200e96a0e4b09c320ecb927 | /ClientShellDLL/WinUtil.cpp | fa17aa0bddb2605ead77a5b3d82eba45533c05ef | [] | no_license | haekb/ltel-shogo | 7cd915b2c6887a06502b971dab6065bfb93a94b6 | ae99dbb75b3a7439f990a1019bcec3e143a84b4e | refs/heads/master | 2023-01-06T07:14:48.596336 | 2020-11-08T18:54:32 | 2020-11-08T18:54:32 | 311,132,229 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 3,529 | cpp | #include "Windows.h"
#include "stdio.h"
#include "sys\stat.h"
#include "winutil.h"
#include <time.h>
#include <direct.h>
#include "basedefs_de.h"
BOOL CWinUtil::GetMoviesPath (char* strPath)
{
char chDrive = 'A';
strPath[0] = '\0';
char strTemp[256];
if (_getcwd (strTemp, 255))
{
char strFile[270];
if (strTemp[strlen(strTemp) - 1] != '\\') strcat (strTemp, "\\");
SAFE_STRCPY(strFile, strTemp);
strcat (strFile, "intro.smk");
if (FileExist (strFile))
{
SAFE_STRCPY(strPath, strTemp);
return TRUE;
}
}
while (chDrive <= 'Z')
{
sprintf(strPath, "%c:\\", chDrive);
if (GetDriveType(strPath) == DRIVE_CDROM)
{
strcat(strPath, "Movies\\");
if (DirExist (strPath)) return TRUE;
}
chDrive++;
}
strPath[0] = '\0';
return FALSE;
}
BOOL CWinUtil::DirExist (char* strPath)
{
if (!strPath || !*strPath) return FALSE;
BOOL bDirExists = FALSE;
BOOL bRemovedBackSlash = FALSE;
if (strPath[strlen(strPath) - 1] == '\\')
{
strPath[strlen(strPath) - 1] = '\0';
bRemovedBackSlash = TRUE;
}
UINT oldErrorMode = SetErrorMode (SEM_FAILCRITICALERRORS | SEM_NOOPENFILEERRORBOX);
struct stat statbuf;
int error = stat (strPath, &statbuf);
SetErrorMode (oldErrorMode);
if (error != -1) bDirExists = TRUE;
if (bRemovedBackSlash)
{
strPath[strlen(strPath)] = '\\';
}
return bDirExists;
}
BOOL CWinUtil::CreateDir (char* strPath)
{
if (DirExist (strPath)) return TRUE;
if (strPath[strlen(strPath) - 1] == ':') return FALSE; // special case
char strPartialPath[MAX_PATH];
strPartialPath[0] = '\0';
char* token = strtok (strPath, "\\");
while (token)
{
strcat (strPartialPath, token);
if (!DirExist (strPartialPath) && strPartialPath[strlen(strPartialPath) - 1] != ':')
{
if (!CreateDirectory (strPartialPath, NULL)) return FALSE;
}
strcat (strPartialPath, "\\");
token = strtok (NULL, "\\");
}
return TRUE;
}
BOOL CWinUtil::FileExist (char* strPath)
{
OFSTRUCT ofs;
HFILE hFile = OpenFile (strPath, &ofs, OF_EXIST);
if (hFile == HFILE_ERROR) return FALSE;
return TRUE;
}
DWORD CWinUtil::WinGetPrivateProfileString (char* lpAppName, char* lpKeyName, char* lpDefault, char* lpReturnedString, DWORD nSize, char* lpFileName)
{
return GetPrivateProfileString (lpAppName, lpKeyName, lpDefault, lpReturnedString, nSize, lpFileName);
}
DWORD CWinUtil::WinWritePrivateProfileString (char* lpAppName, char* lpKeyName, char* lpString, char* lpFileName)
{
return WritePrivateProfileString (lpAppName, lpKeyName, lpString, lpFileName);
}
void CWinUtil::DebugOut (char* str)
{
OutputDebugString (str);
}
void CWinUtil::DebugBreak()
{
::DebugBreak();
}
float CWinUtil::GetTime()
{
return (float)GetTickCount() / 1000.0f;
}
char* CWinUtil::GetFocusWindow()
{
static char strText[128];
HWND hWnd = GetFocus();
if (!hWnd)
{
hWnd = GetForegroundWindow();
if (!hWnd) return NULL;
}
GetWindowText (hWnd, strText, 127);
return strText;
}
void CWinUtil::WriteToDebugFile (char *strText)
{
FILE* pFile = fopen ("c:\\shodebug.txt", "a+t");
if (!pFile) return;
time_t seconds;
time (&seconds);
struct tm* timedate = localtime (&seconds);
if (!timedate) return;
char strTimeDate[128];
sprintf (strTimeDate, "[%02d/%02d/%02d %02d:%02d:%02d] ", timedate->tm_mon + 1, timedate->tm_mday, (timedate->tm_year + 1900) % 100, timedate->tm_hour, timedate->tm_min, timedate->tm_sec);
fwrite (strTimeDate, strlen(strTimeDate), 1, pFile);
fwrite (strText, strlen(strText), 1, pFile);
fwrite ("\n", 1, 1, pFile);
fclose (pFile);
}
| [
"[email protected]"
] | |
41449837d54aa3bd46db8ea55549118f13123f36 | dfb6c1f525908ae85e575babe292c6c54431a947 | /Classes/Scene/Map/UnitSprite.cpp | d8d10d1e594eb235f0490e25d952c5cf100832dd | [] | no_license | momons/hateru_cocos2dx | c3fe616ee28b25ae6c00e43dc42da9b67bceaee2 | 184ebb03f9a03774ee207b6a4efaaf562e31de3a | refs/heads/master | 2020-04-15T14:29:40.459659 | 2019-04-25T12:54:29 | 2019-04-25T12:54:29 | 60,107,035 | 4 | 1 | null | null | null | null | UTF-8 | C++ | false | false | 3,042 | cpp | //
// UnitSpite.cpp
// hateru
//
// Created by HaraKazunari on 2016/08/15.
//
//
#include "UnitSprite.h"
#include <iostream>
#include <iomanip>
#include "Manager/GameCharaManager.h"
#include "Const/GameConst.h"
/**
* クラス作成
*
* @param entity キャラEntity
*
* @return クラス
*/
UnitSprite *UnitSprite::create(const GameCharaEntity &entity) {
auto sprite = new UnitSprite();
if(sprite && sprite->init()){
sprite->Node::autorelease();
sprite->setup(entity);
return sprite;
}else {
delete sprite;
sprite = nullptr;
return nullptr;
}
}
/**
* コンストラクタ
*/
UnitSprite::UnitSprite() {
}
/**
* デストラクタ
*/
UnitSprite::~UnitSprite() {
}
/**
* セットアップ
*
* @param entity キャラEntity
*/
void UnitSprite::setup(const GameCharaEntity &entity) {
// 退避
this->entity = entity;
// 初期設定
x = 0;
y = 0;
mapX = 0;
mapY = 0;
directionType = DirectionType::Down;
isStopWalk = false;
walkCount = 0;
scheduleCount = 0;
// 画像を変更
setSpriteFrame(getSpriteFrame());
// スケジュール設定
scheduleUpdate();
}
/**
* スケジュール更新
*
* @param delta delta
*/
void UnitSprite::update(float delta) {
// カウントアップ
scheduleCount = (scheduleCount + 1) % GameConst::frameRate;
// 歩くカウント設定
if (scheduleCount == 0 && !isStopWalk) {
walkCount = (walkCount + 1) % 2;
// 画像を変更
setSpriteFrame(getSpriteFrame());
}
}
/**
* 画像Id取得
*
* @param directionType 向き
*
* @return 画像インデックス
*/
int UnitSprite::getImageId(DirectionType directionType) {
return entity.imageIds[ENUM_INT(directionType) * 2 + walkCount];
}
/**
* SpriteFrame取得
*
* @return SpriteFrame
*/
SpriteFrame *UnitSprite::getSpriteFrame() {
auto filePath = GameCharaManager::getImageFilePath(getImageId(directionType));
auto frame = SpriteFrameCache::getInstance()->getSpriteFrameByName(filePath);
return frame;
}
#pragma mark - getter setter
/**
* 向きを設定
*
* @param direction 向きタイプ
*/
void UnitSprite::setDirectionType(DirectionType directionType) {
// 向きが一緒
if (this->directionType == directionType) {
return;
}
// 画像が一緒
if (getImageId(this->directionType) == getImageId(directionType)) {
return;
}
// 退避
this->directionType = directionType;
// 画像を変更
setSpriteFrame(getSpriteFrame());
}
/**
* マップ座標を設定する
*
* @param mapX マップX座標
* @param mapY マップY座標
*/
void UnitSprite::setMapLocation(int mapX, int mapY) {
this->mapX = mapX;
this->mapY = mapY;
x = mapX * GameConst::mapOnePanelDot;
y = mapY * GameConst::mapOnePanelDot;
}
/**
* 向きを取得
*
* @return 向きタイプ
*/
DirectionType UnitSprite::getDirectionType() {
return directionType;
}
/**
* 歩きストップ設定
*
* @param isStopWalk 歩きストップフラグ
*/
void UnitSprite::setStopWalk(bool isStopWalk) {
this->isStopWalk = isStopWalk;
}
| [
"[email protected]"
] | |
d6f7bb65f32033a16f3de6ba51b09e5236d75719 | c926141eb06ea1b84d50662ffa27160f55afe954 | /sde_problems/Day3/n^x.cpp | 469a975815ae7cbcb8db83876e8a2abd1ff0ed8b | [] | no_license | Kunal-khanwalkar/coding-practise | 85bd69668685924e9435168d03129c5911851458 | d78d18eb824a1b0043eee3a4d0f1f07bdacc1c0e | refs/heads/master | 2022-12-07T06:41:55.532778 | 2020-09-02T12:32:53 | 2020-09-02T12:32:53 | 292,277,819 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 481 | cpp | #include<iostream>
using namespace std;
int mypower(float n, int x)
{
if(x==0)
return 1;
int result = 1;
for(int i=1;i<=x;i++)
result *= n;
return result;
}
float logpower(float n, int x)
{
float temp;
if(x==0)
return 1;
temp = logpower(n,x/2);
if(x%2==0)
return temp*temp;
else
{
if(x>0)
return n*temp*temp;
else
return (temp*temp)/n;
}
}
int main()
{
float n = 2;
int x = 5;
cout<<mypower(n,x);
cout<<'\n'<<logpower(n,x);
return 0;
} | [
"[email protected]"
] | |
dedcc0e91a93b6866cb5becabafffd4719b1949d | 8191864909f7d8b896f97ff353ce475757f4fbd1 | /deps/chakrashim/core/lib/Backend/GlobOptIntBounds.cpp | 2e99194b776f08b82294abe5a5fa416aed60b1c4 | [
"MIT",
"BSD-3-Clause",
"LicenseRef-scancode-unicode",
"LicenseRef-scancode-openssl",
"LicenseRef-scancode-unknown-license-reference",
"Artistic-2.0",
"NAIST-2003",
"NTP",
"ICU",
"ISC",
"Zlib",
"LicenseRef-scancode-public-domain",
"BSD-2-Clause"
] | permissive | mozilla/spidernode | df5a1e58b54da5bfbc35a585fc4bbb15678f8ca0 | aafa9e5273f954f272bb4382fc007af14674b4c2 | refs/heads/master | 2023-08-26T19:45:35.703738 | 2019-06-18T19:01:53 | 2019-06-18T19:01:53 | 55,816,013 | 618 | 69 | NOASSERTION | 2019-06-18T18:59:28 | 2016-04-08T23:38:28 | JavaScript | UTF-8 | C++ | false | false | 136,110 | cpp | //-------------------------------------------------------------------------------------------------------
// Copyright (C) Microsoft. All rights reserved.
// Licensed under the MIT license. See LICENSE.txt file in the project root for full license information.
//-------------------------------------------------------------------------------------------------------
#include "Backend.h"
#if ENABLE_DEBUG_CONFIG_OPTIONS && DBG_DUMP
#define TRACE_PHASE_VERBOSE(phase, indent, ...) \
if(PHASE_VERBOSE_TRACE(phase, this->func)) \
{ \
for(int i = 0; i < static_cast<int>(indent); ++i) \
{ \
Output::Print(_u(" ")); \
} \
Output::Print(__VA_ARGS__); \
Output::Flush(); \
}
#else
#define TRACE_PHASE_VERBOSE(phase, indent, ...)
#endif
void GlobOpt::AddSubConstantInfo::Set(
StackSym *const srcSym,
Value *const srcValue,
const bool srcValueIsLikelyConstant,
const int32 offset)
{
Assert(srcSym);
Assert(!srcSym->IsTypeSpec());
Assert(srcValue);
Assert(srcValue->GetValueInfo()->IsLikelyInt());
this->srcSym = srcSym;
this->srcValue = srcValue;
this->srcValueIsLikelyConstant = srcValueIsLikelyConstant;
this->offset = offset;
}
void GlobOpt::ArrayLowerBoundCheckHoistInfo::SetCompatibleBoundCheck(
BasicBlock *const compatibleBoundCheckBlock,
StackSym *const indexSym,
const int offset,
const ValueNumber indexValueNumber)
{
Assert(!Loop());
Assert(compatibleBoundCheckBlock);
Assert(indexSym);
Assert(!indexSym->IsTypeSpec());
Assert(indexValueNumber != InvalidValueNumber);
this->compatibleBoundCheckBlock = compatibleBoundCheckBlock;
this->indexSym = indexSym;
this->offset = offset;
this->indexValueNumber = indexValueNumber;
}
void GlobOpt::ArrayLowerBoundCheckHoistInfo::SetLoop(
::Loop *const loop,
const int indexConstantValue,
const bool isLoopCountBasedBound)
{
Assert(!CompatibleBoundCheckBlock());
Assert(loop);
this->loop = loop;
indexSym = nullptr;
offset = 0;
indexValue = nullptr;
indexConstantBounds = IntConstantBounds(indexConstantValue, indexConstantValue);
this->isLoopCountBasedBound = isLoopCountBasedBound;
loopCount = nullptr;
}
void GlobOpt::ArrayLowerBoundCheckHoistInfo::SetLoop(
::Loop *const loop,
StackSym *const indexSym,
const int offset,
Value *const indexValue,
const IntConstantBounds &indexConstantBounds,
const bool isLoopCountBasedBound)
{
Assert(!CompatibleBoundCheckBlock());
Assert(loop);
Assert(indexSym);
Assert(!indexSym->IsTypeSpec());
Assert(indexValue);
this->loop = loop;
this->indexSym = indexSym;
this->offset = offset;
this->indexValueNumber = indexValue->GetValueNumber();
this->indexValue = indexValue;
this->indexConstantBounds = indexConstantBounds;
this->isLoopCountBasedBound = isLoopCountBasedBound;
loopCount = nullptr;
}
void GlobOpt::ArrayLowerBoundCheckHoistInfo::SetLoopCount(::LoopCount *const loopCount, const int maxMagnitudeChange)
{
Assert(Loop());
Assert(loopCount);
Assert(maxMagnitudeChange != 0);
this->loopCount = loopCount;
this->maxMagnitudeChange = maxMagnitudeChange;
}
void GlobOpt::ArrayUpperBoundCheckHoistInfo::SetCompatibleBoundCheck(
BasicBlock *const compatibleBoundCheckBlock,
const int indexConstantValue)
{
Assert(!Loop());
Assert(compatibleBoundCheckBlock);
this->compatibleBoundCheckBlock = compatibleBoundCheckBlock;
indexSym = nullptr;
offset = -1; // simulate < instead of <=
indexConstantBounds = IntConstantBounds(indexConstantValue, indexConstantValue);
}
void GlobOpt::ArrayUpperBoundCheckHoistInfo::SetLoop(
::Loop *const loop,
const int indexConstantValue,
Value *const headSegmentLengthValue,
const IntConstantBounds &headSegmentLengthConstantBounds,
const bool isLoopCountBasedBound)
{
Assert(!CompatibleBoundCheckBlock());
Assert(loop);
Assert(headSegmentLengthValue);
SetLoop(loop, indexConstantValue, isLoopCountBasedBound);
offset = -1; // simulate < instead of <=
this->headSegmentLengthValue = headSegmentLengthValue;
this->headSegmentLengthConstantBounds = headSegmentLengthConstantBounds;
}
void GlobOpt::ArrayUpperBoundCheckHoistInfo::SetLoop(
::Loop *const loop,
StackSym *const indexSym,
const int offset,
Value *const indexValue,
const IntConstantBounds &indexConstantBounds,
Value *const headSegmentLengthValue,
const IntConstantBounds &headSegmentLengthConstantBounds,
const bool isLoopCountBasedBound)
{
Assert(headSegmentLengthValue);
SetLoop(loop, indexSym, offset, indexValue, indexConstantBounds, isLoopCountBasedBound);
this->headSegmentLengthValue = headSegmentLengthValue;
this->headSegmentLengthConstantBounds = headSegmentLengthConstantBounds;
}
bool ValueInfo::HasIntConstantValue(const bool includeLikelyInt) const
{
int32 constantValue;
return TryGetIntConstantValue(&constantValue, includeLikelyInt);
}
bool ValueInfo::TryGetIntConstantValue(int32 *const intValueRef, const bool includeLikelyInt) const
{
Assert(intValueRef);
if(!(includeLikelyInt ? IsLikelyInt() : IsInt()))
{
return false;
}
switch(structureKind)
{
case ValueStructureKind::IntConstant:
if(!includeLikelyInt || IsInt())
{
*intValueRef = AsIntConstant()->IntValue();
return true;
}
break;
case ValueStructureKind::IntRange:
Assert(includeLikelyInt && !IsInt() || !AsIntRange()->IsConstant());
break;
case ValueStructureKind::IntBounded:
{
const IntConstantBounds bounds(AsIntBounded()->Bounds()->ConstantBounds());
if(bounds.IsConstant())
{
*intValueRef = bounds.LowerBound();
return true;
}
break;
}
}
return false;
}
bool ValueInfo::TryGetIntConstantLowerBound(int32 *const intConstantBoundRef, const bool includeLikelyInt) const
{
Assert(intConstantBoundRef);
if(!(includeLikelyInt ? IsLikelyInt() : IsInt()))
{
return false;
}
switch(structureKind)
{
case ValueStructureKind::IntConstant:
if(!includeLikelyInt || IsInt())
{
*intConstantBoundRef = AsIntConstant()->IntValue();
return true;
}
break;
case ValueStructureKind::IntRange:
if(!includeLikelyInt || IsInt())
{
*intConstantBoundRef = AsIntRange()->LowerBound();
return true;
}
break;
case ValueStructureKind::IntBounded:
*intConstantBoundRef = AsIntBounded()->Bounds()->ConstantLowerBound();
return true;
}
*intConstantBoundRef = IsTaggedInt() ? Js::Constants::Int31MinValue : IntConstMin;
return true;
}
bool ValueInfo::TryGetIntConstantUpperBound(int32 *const intConstantBoundRef, const bool includeLikelyInt) const
{
Assert(intConstantBoundRef);
if(!(includeLikelyInt ? IsLikelyInt() : IsInt()))
{
return false;
}
switch(structureKind)
{
case ValueStructureKind::IntConstant:
if(!includeLikelyInt || IsInt())
{
*intConstantBoundRef = AsIntConstant()->IntValue();
return true;
}
break;
case ValueStructureKind::IntRange:
if(!includeLikelyInt || IsInt())
{
*intConstantBoundRef = AsIntRange()->UpperBound();
return true;
}
break;
case ValueStructureKind::IntBounded:
*intConstantBoundRef = AsIntBounded()->Bounds()->ConstantUpperBound();
return true;
}
*intConstantBoundRef = IsTaggedInt() ? Js::Constants::Int31MaxValue : IntConstMax;
return true;
}
bool ValueInfo::TryGetIntConstantBounds(IntConstantBounds *const intConstantBoundsRef, const bool includeLikelyInt) const
{
Assert(intConstantBoundsRef);
if(!(includeLikelyInt ? IsLikelyInt() : IsInt()))
{
return false;
}
switch(structureKind)
{
case ValueStructureKind::IntConstant:
if(!includeLikelyInt || IsInt())
{
const int32 intValue = AsIntConstant()->IntValue();
*intConstantBoundsRef = IntConstantBounds(intValue, intValue);
return true;
}
break;
case ValueStructureKind::IntRange:
if(!includeLikelyInt || IsInt())
{
*intConstantBoundsRef = *AsIntRange();
return true;
}
break;
case ValueStructureKind::IntBounded:
*intConstantBoundsRef = AsIntBounded()->Bounds()->ConstantBounds();
return true;
}
*intConstantBoundsRef =
IsTaggedInt()
? IntConstantBounds(Js::Constants::Int31MinValue, Js::Constants::Int31MaxValue)
: IntConstantBounds(INT32_MIN, INT32_MAX);
return true;
}
bool ValueInfo::WasNegativeZeroPreventedByBailout() const
{
if(!IsInt())
{
return false;
}
switch(structureKind)
{
case ValueStructureKind::IntRange:
return AsIntRange()->WasNegativeZeroPreventedByBailout();
case ValueStructureKind::IntBounded:
return AsIntBounded()->WasNegativeZeroPreventedByBailout();
}
return false;
}
bool ValueInfo::IsEqualTo(
const Value *const src1Value,
const int32 min1,
const int32 max1,
const Value *const src2Value,
const int32 min2,
const int32 max2)
{
const bool result =
IsEqualTo_NoConverse(src1Value, min1, max1, src2Value, min2, max2) ||
IsEqualTo_NoConverse(src2Value, min2, max2, src1Value, min1, max1);
Assert(!result || !IsNotEqualTo_NoConverse(src1Value, min1, max1, src2Value, min2, max2));
Assert(!result || !IsNotEqualTo_NoConverse(src2Value, min2, max2, src1Value, min1, max1));
return result;
}
bool ValueInfo::IsNotEqualTo(
const Value *const src1Value,
const int32 min1,
const int32 max1,
const Value *const src2Value,
const int32 min2,
const int32 max2)
{
const bool result =
IsNotEqualTo_NoConverse(src1Value, min1, max1, src2Value, min2, max2) ||
IsNotEqualTo_NoConverse(src2Value, min2, max2, src1Value, min1, max1);
Assert(!result || !IsEqualTo_NoConverse(src1Value, min1, max1, src2Value, min2, max2));
Assert(!result || !IsEqualTo_NoConverse(src2Value, min2, max2, src1Value, min1, max1));
return result;
}
bool ValueInfo::IsEqualTo_NoConverse(
const Value *const src1Value,
const int32 min1,
const int32 max1,
const Value *const src2Value,
const int32 min2,
const int32 max2)
{
return
IsGreaterThanOrEqualTo(src1Value, min1, max1, src2Value, min2, max2) &&
IsLessThanOrEqualTo(src1Value, min1, max1, src2Value, min2, max2);
}
bool ValueInfo::IsNotEqualTo_NoConverse(
const Value *const src1Value,
const int32 min1,
const int32 max1,
const Value *const src2Value,
const int32 min2,
const int32 max2)
{
return
IsGreaterThan(src1Value, min1, max1, src2Value, min2, max2) ||
IsLessThan(src1Value, min1, max1, src2Value, min2, max2);
}
bool ValueInfo::IsGreaterThanOrEqualTo(
const Value *const src1Value,
const int32 min1,
const int32 max1,
const Value *const src2Value,
const int32 min2,
const int32 max2)
{
return IsGreaterThanOrEqualTo(src1Value, min1, max1, src2Value, min2, max2, 0);
}
bool ValueInfo::IsGreaterThan(
const Value *const src1Value,
const int32 min1,
const int32 max1,
const Value *const src2Value,
const int32 min2,
const int32 max2)
{
return IsGreaterThanOrEqualTo(src1Value, min1, max1, src2Value, min2, max2, 1);
}
bool ValueInfo::IsLessThanOrEqualTo(
const Value *const src1Value,
const int32 min1,
const int32 max1,
const Value *const src2Value,
const int32 min2,
const int32 max2)
{
return IsLessThanOrEqualTo(src1Value, min1, max1, src2Value, min2, max2, 0);
}
bool ValueInfo::IsLessThan(
const Value *const src1Value,
const int32 min1,
const int32 max1,
const Value *const src2Value,
const int32 min2,
const int32 max2)
{
return IsLessThanOrEqualTo(src1Value, min1, max1, src2Value, min2, max2, -1);
}
bool ValueInfo::IsGreaterThanOrEqualTo(
const Value *const src1Value,
const int32 min1,
const int32 max1,
const Value *const src2Value,
const int32 min2,
const int32 max2,
const int src2Offset)
{
return
IsGreaterThanOrEqualTo_NoConverse(src1Value, min1, max1, src2Value, min2, max2, src2Offset) ||
src2Offset == IntConstMin ||
IsLessThanOrEqualTo_NoConverse(src2Value, min2, max2, src1Value, min1, max1, -src2Offset);
}
bool ValueInfo::IsLessThanOrEqualTo(
const Value *const src1Value,
const int32 min1,
const int32 max1,
const Value *const src2Value,
const int32 min2,
const int32 max2,
const int src2Offset)
{
return
IsLessThanOrEqualTo_NoConverse(src1Value, min1, max1, src2Value, min2, max2, src2Offset) ||
(
src2Offset != IntConstMin &&
IsGreaterThanOrEqualTo_NoConverse(src2Value, min2, max2, src1Value, min1, max1, -src2Offset)
);
}
bool ValueInfo::IsGreaterThanOrEqualTo_NoConverse(
const Value *const src1Value,
const int32 min1,
const int32 max1,
const Value *const src2Value,
const int32 min2,
const int32 max2,
const int src2Offset)
{
Assert(src1Value || min1 == max1);
Assert(!src1Value || src1Value->GetValueInfo()->IsLikelyInt());
Assert(src2Value || min2 == max2);
Assert(!src2Value || src2Value->GetValueInfo()->IsLikelyInt());
if(src1Value)
{
if(src2Value && src1Value->GetValueNumber() == src2Value->GetValueNumber())
{
return src2Offset <= 0;
}
ValueInfo *const src1ValueInfo = src1Value->GetValueInfo();
if(src1ValueInfo->structureKind == ValueStructureKind::IntBounded)
{
const IntBounds *const bounds = src1ValueInfo->AsIntBounded()->Bounds();
return
src2Value
? bounds->IsGreaterThanOrEqualTo(src2Value, src2Offset)
: bounds->IsGreaterThanOrEqualTo(min2, src2Offset);
}
}
return IntBounds::IsGreaterThanOrEqualTo(min1, max2, src2Offset);
}
bool ValueInfo::IsLessThanOrEqualTo_NoConverse(
const Value *const src1Value,
const int32 min1,
const int32 max1,
const Value *const src2Value,
const int32 min2,
const int32 max2,
const int src2Offset)
{
Assert(src1Value || min1 == max1);
Assert(!src1Value || src1Value->GetValueInfo()->IsLikelyInt());
Assert(src2Value || min2 == max2);
Assert(!src2Value || src2Value->GetValueInfo()->IsLikelyInt());
if(src1Value)
{
if(src2Value && src1Value->GetValueNumber() == src2Value->GetValueNumber())
{
return src2Offset >= 0;
}
ValueInfo *const src1ValueInfo = src1Value->GetValueInfo();
if(src1ValueInfo->structureKind == ValueStructureKind::IntBounded)
{
const IntBounds *const bounds = src1ValueInfo->AsIntBounded()->Bounds();
return
src2Value
? bounds->IsLessThanOrEqualTo(src2Value, src2Offset)
: bounds->IsLessThanOrEqualTo(min2, src2Offset);
}
}
return IntBounds::IsLessThanOrEqualTo(max1, min2, src2Offset);
}
void GlobOpt::UpdateIntBoundsForEqualBranch(
Value *const src1Value,
Value *const src2Value,
const int32 src2ConstantValue)
{
Assert(src1Value);
if(!DoPathDependentValues() || src2Value && src1Value->GetValueNumber() == src2Value->GetValueNumber())
{
return;
}
#if DBG
if(!IsLoopPrePass() && DoAggressiveIntTypeSpec() && DoConstFold())
{
IntConstantBounds src1ConstantBounds, src2ConstantBounds;
AssertVerify(src1Value->GetValueInfo()->TryGetIntConstantBounds(&src1ConstantBounds, true));
if(src2Value)
{
AssertVerify(src2Value->GetValueInfo()->TryGetIntConstantBounds(&src2ConstantBounds, true));
}
else
{
src2ConstantBounds = IntConstantBounds(src2ConstantValue, src2ConstantValue);
}
Assert(
!ValueInfo::IsEqualTo(
src1Value,
src1ConstantBounds.LowerBound(),
src1ConstantBounds.UpperBound(),
src2Value,
src2ConstantBounds.LowerBound(),
src2ConstantBounds.UpperBound()));
Assert(
!ValueInfo::IsNotEqualTo(
src1Value,
src1ConstantBounds.LowerBound(),
src1ConstantBounds.UpperBound(),
src2Value,
src2ConstantBounds.LowerBound(),
src2ConstantBounds.UpperBound()));
}
#endif
SetPathDependentInfo(
true,
PathDependentInfo(PathDependentRelationship::Equal, src1Value, src2Value, src2ConstantValue));
SetPathDependentInfo(
false,
PathDependentInfo(PathDependentRelationship::NotEqual, src1Value, src2Value, src2ConstantValue));
}
void GlobOpt::UpdateIntBoundsForNotEqualBranch(
Value *const src1Value,
Value *const src2Value,
const int32 src2ConstantValue)
{
Assert(src1Value);
if(!DoPathDependentValues() || src2Value && src1Value->GetValueNumber() == src2Value->GetValueNumber())
{
return;
}
#if DBG
if(!IsLoopPrePass() && DoAggressiveIntTypeSpec() && DoConstFold())
{
IntConstantBounds src1ConstantBounds, src2ConstantBounds;
AssertVerify(src1Value->GetValueInfo()->TryGetIntConstantBounds(&src1ConstantBounds, true));
if(src2Value)
{
AssertVerify(src2Value->GetValueInfo()->TryGetIntConstantBounds(&src2ConstantBounds, true));
}
else
{
src2ConstantBounds = IntConstantBounds(src2ConstantValue, src2ConstantValue);
}
Assert(
!ValueInfo::IsEqualTo(
src1Value,
src1ConstantBounds.LowerBound(),
src1ConstantBounds.UpperBound(),
src2Value,
src2ConstantBounds.LowerBound(),
src2ConstantBounds.UpperBound()));
Assert(
!ValueInfo::IsNotEqualTo(
src1Value,
src1ConstantBounds.LowerBound(),
src1ConstantBounds.UpperBound(),
src2Value,
src2ConstantBounds.LowerBound(),
src2ConstantBounds.UpperBound()));
}
#endif
SetPathDependentInfo(
true, PathDependentInfo(PathDependentRelationship::NotEqual, src1Value, src2Value, src2ConstantValue));
SetPathDependentInfo(
false, PathDependentInfo(PathDependentRelationship::Equal, src1Value, src2Value, src2ConstantValue));
}
void GlobOpt::UpdateIntBoundsForGreaterThanOrEqualBranch(Value *const src1Value, Value *const src2Value)
{
Assert(src1Value);
Assert(src2Value);
if(!DoPathDependentValues() || src1Value->GetValueNumber() == src2Value->GetValueNumber())
{
return;
}
#if DBG
if(!IsLoopPrePass() && DoAggressiveIntTypeSpec() && DoConstFold())
{
IntConstantBounds src1ConstantBounds, src2ConstantBounds;
AssertVerify(src1Value->GetValueInfo()->TryGetIntConstantBounds(&src1ConstantBounds, true));
AssertVerify(src2Value->GetValueInfo()->TryGetIntConstantBounds(&src2ConstantBounds, true));
Assert(
!ValueInfo::IsGreaterThanOrEqualTo(
src1Value,
src1ConstantBounds.LowerBound(),
src1ConstantBounds.UpperBound(),
src2Value,
src2ConstantBounds.LowerBound(),
src2ConstantBounds.UpperBound()));
Assert(
!ValueInfo::IsLessThan(
src1Value,
src1ConstantBounds.LowerBound(),
src1ConstantBounds.UpperBound(),
src2Value,
src2ConstantBounds.LowerBound(),
src2ConstantBounds.UpperBound()));
}
#endif
SetPathDependentInfo(true, PathDependentInfo(PathDependentRelationship::GreaterThanOrEqual, src1Value, src2Value));
SetPathDependentInfo(false, PathDependentInfo(PathDependentRelationship::LessThan, src1Value, src2Value));
}
void GlobOpt::UpdateIntBoundsForGreaterThanBranch(Value *const src1Value, Value *const src2Value)
{
return UpdateIntBoundsForLessThanBranch(src2Value, src1Value);
}
void GlobOpt::UpdateIntBoundsForLessThanOrEqualBranch(Value *const src1Value, Value *const src2Value)
{
return UpdateIntBoundsForGreaterThanOrEqualBranch(src2Value, src1Value);
}
void GlobOpt::UpdateIntBoundsForLessThanBranch(Value *const src1Value, Value *const src2Value)
{
Assert(src1Value);
Assert(src2Value);
if(!DoPathDependentValues() || src1Value->GetValueNumber() == src2Value->GetValueNumber())
{
return;
}
#if DBG
if(!IsLoopPrePass() && DoAggressiveIntTypeSpec() && DoConstFold())
{
IntConstantBounds src1ConstantBounds, src2ConstantBounds;
AssertVerify(src1Value->GetValueInfo()->TryGetIntConstantBounds(&src1ConstantBounds, true));
AssertVerify(src2Value->GetValueInfo()->TryGetIntConstantBounds(&src2ConstantBounds, true));
Assert(
!ValueInfo::IsGreaterThanOrEqualTo(
src1Value,
src1ConstantBounds.LowerBound(),
src1ConstantBounds.UpperBound(),
src2Value,
src2ConstantBounds.LowerBound(),
src2ConstantBounds.UpperBound()));
Assert(
!ValueInfo::IsLessThan(
src1Value,
src1ConstantBounds.LowerBound(),
src1ConstantBounds.UpperBound(),
src2Value,
src2ConstantBounds.LowerBound(),
src2ConstantBounds.UpperBound()));
}
#endif
SetPathDependentInfo(true, PathDependentInfo(PathDependentRelationship::LessThan, src1Value, src2Value));
SetPathDependentInfo(false, PathDependentInfo(PathDependentRelationship::GreaterThanOrEqual, src1Value, src2Value));
}
IntBounds *GlobOpt::GetIntBoundsToUpdate(
const ValueInfo *const valueInfo,
const IntConstantBounds &constantBounds,
const bool isSettingNewBound,
const bool isBoundConstant,
const bool isSettingUpperBound,
const bool isExplicit)
{
Assert(valueInfo);
Assert(valueInfo->IsLikelyInt());
if(!DoTrackRelativeIntBounds())
{
return nullptr;
}
if(valueInfo->IsIntBounded())
{
const IntBounds *const bounds = valueInfo->AsIntBounded()->Bounds();
if(bounds->RequiresIntBoundedValueInfo(valueInfo->Type()))
{
return bounds->Clone();
}
}
if(valueInfo->IsInt())
{
if(constantBounds.IsConstant())
{
// Don't start tracking relative bounds for int constant values, just retain existing relative bounds. Will use
// IntConstantValueInfo instead.
return nullptr;
}
if(isBoundConstant)
{
// There are no relative bounds to track
if(!(isSettingUpperBound && isExplicit))
{
// We are not setting a constant upper bound that is established explicitly, will use IntRangeValueInfo instead
return nullptr;
}
}
else if(!isSettingNewBound)
{
// New relative bounds are not being set, will use IntRangeValueInfo instead
return nullptr;
}
}
return IntBounds::New(constantBounds, false, alloc);
}
ValueInfo *GlobOpt::UpdateIntBoundsForEqual(
Value *const value,
const IntConstantBounds &constantBounds,
Value *const boundValue,
const IntConstantBounds &boundConstantBounds,
const bool isExplicit)
{
Assert(value || constantBounds.IsConstant());
Assert(boundValue || boundConstantBounds.IsConstant());
if(!value)
{
return nullptr;
}
Assert(!boundValue || value->GetValueNumber() != boundValue->GetValueNumber());
ValueInfo *const valueInfo = value->GetValueInfo();
IntBounds *const bounds =
GetIntBoundsToUpdate(valueInfo, constantBounds, true, boundConstantBounds.IsConstant(), true, isExplicit);
if(bounds)
{
if(boundValue)
{
const ValueNumber valueNumber = value->GetValueNumber();
bounds->SetLowerBound(valueNumber, boundValue, isExplicit);
bounds->SetUpperBound(valueNumber, boundValue, isExplicit);
}
else
{
bounds->SetLowerBound(boundConstantBounds.LowerBound());
bounds->SetUpperBound(boundConstantBounds.LowerBound(), isExplicit);
}
if(bounds->RequiresIntBoundedValueInfo(valueInfo->Type()))
{
return NewIntBoundedValueInfo(valueInfo, bounds);
}
bounds->Delete();
}
if(!valueInfo->IsInt())
{
return nullptr;
}
const int32 newMin = max(constantBounds.LowerBound(), boundConstantBounds.LowerBound());
const int32 newMax = min(constantBounds.UpperBound(), boundConstantBounds.UpperBound());
return newMin <= newMax ? NewIntRangeValueInfo(valueInfo, newMin, newMax) : nullptr;
}
ValueInfo *GlobOpt::UpdateIntBoundsForNotEqual(
Value *const value,
const IntConstantBounds &constantBounds,
Value *const boundValue,
const IntConstantBounds &boundConstantBounds,
const bool isExplicit)
{
Assert(value || constantBounds.IsConstant());
Assert(boundValue || boundConstantBounds.IsConstant());
if(!value)
{
return nullptr;
}
Assert(!boundValue || value->GetValueNumber() != boundValue->GetValueNumber());
ValueInfo *const valueInfo = value->GetValueInfo();
IntBounds *const bounds =
GetIntBoundsToUpdate(
valueInfo,
constantBounds,
false,
boundConstantBounds.IsConstant(),
boundConstantBounds.IsConstant() && boundConstantBounds.LowerBound() == constantBounds.UpperBound(),
isExplicit);
if(bounds)
{
if(boundValue
? bounds->SetIsNot(boundValue, isExplicit)
: bounds->SetIsNot(boundConstantBounds.LowerBound(), isExplicit))
{
if(bounds->RequiresIntBoundedValueInfo(valueInfo->Type()))
{
return NewIntBoundedValueInfo(valueInfo, bounds);
}
}
else
{
bounds->Delete();
return nullptr;
}
bounds->Delete();
}
if(!valueInfo->IsInt() || !boundConstantBounds.IsConstant())
{
return nullptr;
}
const int32 constantBound = boundConstantBounds.LowerBound();
// The value is not equal to a constant, so narrow the range if the constant is equal to the value's lower or upper bound
int32 newMin = constantBounds.LowerBound(), newMax = constantBounds.UpperBound();
if(constantBound == newMin)
{
Assert(newMin <= newMax);
if(newMin == newMax)
{
return nullptr;
}
++newMin;
}
else if(constantBound == newMax)
{
Assert(newMin <= newMax);
if(newMin == newMax)
{
return nullptr;
}
--newMax;
}
else
{
return nullptr;
}
return NewIntRangeValueInfo(valueInfo, newMin, newMax);
}
ValueInfo *GlobOpt::UpdateIntBoundsForGreaterThanOrEqual(
Value *const value,
const IntConstantBounds &constantBounds,
Value *const boundValue,
const IntConstantBounds &boundConstantBounds,
const bool isExplicit)
{
return UpdateIntBoundsForGreaterThanOrEqual(value, constantBounds, boundValue, boundConstantBounds, 0, isExplicit);
}
ValueInfo *GlobOpt::UpdateIntBoundsForGreaterThanOrEqual(
Value *const value,
const IntConstantBounds &constantBounds,
Value *const boundValue,
const IntConstantBounds &boundConstantBounds,
const int boundOffset,
const bool isExplicit)
{
Assert(value || constantBounds.IsConstant());
Assert(boundValue || boundConstantBounds.IsConstant());
if(!value)
{
return nullptr;
}
Assert(!boundValue || value->GetValueNumber() != boundValue->GetValueNumber());
ValueInfo *const valueInfo = value->GetValueInfo();
IntBounds *const bounds =
GetIntBoundsToUpdate(valueInfo, constantBounds, true, boundConstantBounds.IsConstant(), false, isExplicit);
if(bounds)
{
if(boundValue)
{
bounds->SetLowerBound(value->GetValueNumber(), boundValue, boundOffset, isExplicit);
}
else
{
bounds->SetLowerBound(boundConstantBounds.LowerBound(), boundOffset);
}
if(bounds->RequiresIntBoundedValueInfo(valueInfo->Type()))
{
return NewIntBoundedValueInfo(valueInfo, bounds);
}
bounds->Delete();
}
if(!valueInfo->IsInt())
{
return nullptr;
}
int32 adjustedBoundMin;
if(boundOffset == 0)
{
adjustedBoundMin = boundConstantBounds.LowerBound();
}
else if(boundOffset == 1)
{
if(boundConstantBounds.LowerBound() + 1 <= boundConstantBounds.LowerBound())
{
return nullptr;
}
adjustedBoundMin = boundConstantBounds.LowerBound() + 1;
}
else if(Int32Math::Add(boundConstantBounds.LowerBound(), boundOffset, &adjustedBoundMin))
{
return nullptr;
}
const int32 newMin = max(constantBounds.LowerBound(), adjustedBoundMin);
return
newMin <= constantBounds.UpperBound()
? NewIntRangeValueInfo(valueInfo, newMin, constantBounds.UpperBound())
: nullptr;
}
ValueInfo *GlobOpt::UpdateIntBoundsForGreaterThan(
Value *const value,
const IntConstantBounds &constantBounds,
Value *const boundValue,
const IntConstantBounds &boundConstantBounds,
const bool isExplicit)
{
return UpdateIntBoundsForGreaterThanOrEqual(value, constantBounds, boundValue, boundConstantBounds, 1, isExplicit);
}
ValueInfo *GlobOpt::UpdateIntBoundsForLessThanOrEqual(
Value *const value,
const IntConstantBounds &constantBounds,
Value *const boundValue,
const IntConstantBounds &boundConstantBounds,
const bool isExplicit)
{
return UpdateIntBoundsForLessThanOrEqual(value, constantBounds, boundValue, boundConstantBounds, 0, isExplicit);
}
ValueInfo *GlobOpt::UpdateIntBoundsForLessThanOrEqual(
Value *const value,
const IntConstantBounds &constantBounds,
Value *const boundValue,
const IntConstantBounds &boundConstantBounds,
const int boundOffset,
const bool isExplicit)
{
Assert(value || constantBounds.IsConstant());
Assert(boundValue || boundConstantBounds.IsConstant());
if(!value)
{
return nullptr;
}
Assert(!boundValue || value->GetValueNumber() != boundValue->GetValueNumber());
ValueInfo *const valueInfo = value->GetValueInfo();
IntBounds *const bounds =
GetIntBoundsToUpdate(valueInfo, constantBounds, true, boundConstantBounds.IsConstant(), true, isExplicit);
if(bounds)
{
if(boundValue)
{
bounds->SetUpperBound(value->GetValueNumber(), boundValue, boundOffset, isExplicit);
}
else
{
bounds->SetUpperBound(boundConstantBounds.LowerBound(), boundOffset, isExplicit);
}
if(bounds->RequiresIntBoundedValueInfo(valueInfo->Type()))
{
return NewIntBoundedValueInfo(valueInfo, bounds);
}
bounds->Delete();
}
if(!valueInfo->IsInt())
{
return nullptr;
}
int32 adjustedBoundMax;
if(boundOffset == 0)
{
adjustedBoundMax = boundConstantBounds.UpperBound();
}
else if(boundOffset == -1)
{
if(boundConstantBounds.UpperBound() - 1 >= boundConstantBounds.UpperBound())
{
return nullptr;
}
adjustedBoundMax = boundConstantBounds.UpperBound() - 1;
}
else if(Int32Math::Add(boundConstantBounds.UpperBound(), boundOffset, &adjustedBoundMax))
{
return nullptr;
}
const int32 newMax = min(constantBounds.UpperBound(), adjustedBoundMax);
return
newMax >= constantBounds.LowerBound()
? NewIntRangeValueInfo(valueInfo, constantBounds.LowerBound(), newMax)
: nullptr;
}
ValueInfo *GlobOpt::UpdateIntBoundsForLessThan(
Value *const value,
const IntConstantBounds &constantBounds,
Value *const boundValue,
const IntConstantBounds &boundConstantBounds,
const bool isExplicit)
{
return UpdateIntBoundsForLessThanOrEqual(value, constantBounds, boundValue, boundConstantBounds, -1, isExplicit);
}
void GlobOpt::TrackIntSpecializedAddSubConstant(
IR::Instr *const instr,
const AddSubConstantInfo *const addSubConstantInfo,
Value *const dstValue,
const bool updateSourceBounds)
{
Assert(instr);
Assert(dstValue);
if(addSubConstantInfo)
{
Assert(addSubConstantInfo->HasInfo());
Assert(!ignoredIntOverflowForCurrentInstr);
do
{
if(!IsLoopPrePass() || !DoBoundCheckHoist())
{
break;
}
Assert(
instr->m_opcode == Js::OpCode::Incr_A ||
instr->m_opcode == Js::OpCode::Decr_A ||
instr->m_opcode == Js::OpCode::Add_A ||
instr->m_opcode == Js::OpCode::Sub_A);
StackSym *sym = instr->GetDst()->AsRegOpnd()->m_sym;
bool isPostfixIncDecPattern = false;
if(addSubConstantInfo->SrcSym() != sym)
{
// Check for the following patterns.
//
// This pattern is used for postfix inc/dec operators:
// s2 = Conv_Num s1
// s1 = Inc s2
//
// This pattern is used for prefix inc/dec operators:
// s2 = Inc s1
// s1 = Ld s2
IR::Instr *const prevInstr = instr->m_prev;
Assert(prevInstr);
if(prevInstr->m_opcode == Js::OpCode::Conv_Num &&
prevInstr->GetSrc1()->IsRegOpnd() &&
prevInstr->GetSrc1()->AsRegOpnd()->m_sym == sym &&
prevInstr->GetDst()->AsRegOpnd()->m_sym == addSubConstantInfo->SrcSym())
{
// s2 will get a new value number, since Conv_Num cannot transfer in the prepass. For the purposes of
// induction variable tracking however, it doesn't matter, so record this case and use s1's value in the
// current block.
isPostfixIncDecPattern = true;
}
else
{
IR::Instr *const nextInstr = instr->m_next;
Assert(nextInstr);
if(nextInstr->m_opcode != Js::OpCode::Ld_A ||
!nextInstr->GetSrc1()->IsRegOpnd() ||
nextInstr->GetSrc1()->AsRegOpnd()->m_sym != sym)
{
break;
}
sym = addSubConstantInfo->SrcSym();
if(nextInstr->GetDst()->AsRegOpnd()->m_sym != sym)
{
break;
}
// In the prefix inc/dec pattern, the result of Ld currently gets a new value number, which will cause the
// induction variable info to become indeterminate. Indicate that the value number should be updated in the
// induction variable info.
// Consider: Remove this once loop prepass value transfer scheme is fixed
updateInductionVariableValueNumber = true;
}
}
// Track induction variable info
ValueNumber srcValueNumber;
if(isPostfixIncDecPattern)
{
Value *const value = FindValue(sym);
Assert(value);
srcValueNumber = value->GetValueNumber();
}
else
{
srcValueNumber = addSubConstantInfo->SrcValue()->GetValueNumber();
}
InductionVariableSet *const inductionVariables = blockData.inductionVariables;
Assert(inductionVariables);
InductionVariable *inductionVariable;
if(!inductionVariables->TryGetReference(sym->m_id, &inductionVariable))
{
// Only track changes in the current loop's prepass. In subsequent prepasses, the info is only being propagated
// for use by the parent loop, so changes in the current loop have already been tracked.
if(prePassLoop != currentBlock->loop)
{
updateInductionVariableValueNumber = false;
break;
}
// Ensure that the sym is live in the landing pad, and that its value has not changed in an unknown way yet
Value *const landingPadValue = FindValue(currentBlock->loop->landingPad->globOptData.symToValueMap, sym);
if(!landingPadValue || srcValueNumber != landingPadValue->GetValueNumber())
{
updateInductionVariableValueNumber = false;
break;
}
inductionVariables->Add(
InductionVariable(sym, dstValue->GetValueNumber(), addSubConstantInfo->Offset()));
break;
}
if(!inductionVariable->IsChangeDeterminate())
{
updateInductionVariableValueNumber = false;
break;
}
if(srcValueNumber != inductionVariable->SymValueNumber())
{
// The sym's value has changed since the last time induction variable info was recorded for it. Due to the
// unknown change, mark the info as indeterminate.
inductionVariable->SetChangeIsIndeterminate();
updateInductionVariableValueNumber = false;
break;
}
// Only track changes in the current loop's prepass. In subsequent prepasses, the info is only being propagated for
// use by the parent loop, so changes in the current loop have already been tracked. Induction variable value
// numbers are updated as changes occur, but their change bounds are preserved from the first prepass over the loop.
inductionVariable->SetSymValueNumber(dstValue->GetValueNumber());
if(prePassLoop != currentBlock->loop)
{
break;
}
if(!inductionVariable->Add(addSubConstantInfo->Offset()))
{
updateInductionVariableValueNumber = false;
}
} while(false);
if(updateSourceBounds && addSubConstantInfo->Offset() != IntConstMin)
{
// Track bounds for add or sub with a constant. For instance, consider (b = a + 2). The value of 'b' should track
// that it is equal to (the value of 'a') + 2. That part has been done above. Similarly, the value of 'a' should
// also track that it is equal to (the value of 'b') - 2.
Value *const value = addSubConstantInfo->SrcValue();
const ValueInfo *const valueInfo = value->GetValueInfo();
Assert(valueInfo->IsInt());
IntConstantBounds constantBounds;
AssertVerify(valueInfo->TryGetIntConstantBounds(&constantBounds));
IntBounds *const bounds =
GetIntBoundsToUpdate(
valueInfo,
constantBounds,
true,
dstValue->GetValueInfo()->HasIntConstantValue(),
true,
true);
if(bounds)
{
const ValueNumber valueNumber = value->GetValueNumber();
const int32 dstOffset = -addSubConstantInfo->Offset();
bounds->SetLowerBound(valueNumber, dstValue, dstOffset, true);
bounds->SetUpperBound(valueNumber, dstValue, dstOffset, true);
ChangeValueInfo(nullptr, value, NewIntBoundedValueInfo(valueInfo, bounds));
}
}
return;
}
if(!updateInductionVariableValueNumber)
{
return;
}
// See comment above where this is set to true
// Consider: Remove this once loop prepass value transfer scheme is fixed
updateInductionVariableValueNumber = false;
Assert(IsLoopPrePass());
Assert(instr->m_opcode == Js::OpCode::Ld_A);
Assert(
instr->m_prev->m_opcode == Js::OpCode::Incr_A ||
instr->m_prev->m_opcode == Js::OpCode::Decr_A ||
instr->m_prev->m_opcode == Js::OpCode::Add_A ||
instr->m_prev->m_opcode == Js::OpCode::Sub_A);
Assert(instr->m_prev->GetDst()->AsRegOpnd()->m_sym == instr->GetSrc1()->AsRegOpnd()->m_sym);
InductionVariable *inductionVariable;
AssertVerify(blockData.inductionVariables->TryGetReference(instr->GetDst()->AsRegOpnd()->m_sym->m_id, &inductionVariable));
inductionVariable->SetSymValueNumber(dstValue->GetValueNumber());
}
void GlobOpt::CloneBoundCheckHoistBlockData(
BasicBlock *const toBlock,
GlobOptBlockData *const toData,
BasicBlock *const fromBlock,
GlobOptBlockData *const fromData)
{
Assert(DoBoundCheckHoist());
Assert(toBlock);
Assert(toData);
Assert(toData == &toBlock->globOptData || toData == &blockData);
Assert(fromBlock);
Assert(fromData);
Assert(fromData == &fromBlock->globOptData);
Assert(fromData->availableIntBoundChecks);
toData->availableIntBoundChecks = fromData->availableIntBoundChecks->Clone();
if(toBlock->isLoopHeader)
{
Assert(fromBlock == toBlock->loop->landingPad);
if(prePassLoop == toBlock->loop)
{
// When the current prepass loop is the current loop, the loop header's induction variable set needs to start off
// empty to track changes in the current loop
toData->inductionVariables = JitAnew(alloc, InductionVariableSet, alloc);
return;
}
if(!IsLoopPrePass())
{
return;
}
// After the prepass on this loop, if we're still in a prepass, this must be an inner loop. Merge the landing pad info
// for use by the parent loop.
Assert(fromBlock->loop);
Assert(fromData->inductionVariables);
toData->inductionVariables = fromData->inductionVariables->Clone();
return;
}
if(!toBlock->loop || !IsLoopPrePass())
{
return;
}
Assert(fromBlock->loop);
Assert(toBlock->loop->IsDescendentOrSelf(fromBlock->loop));
Assert(fromData->inductionVariables);
toData->inductionVariables = fromData->inductionVariables->Clone();
}
void GlobOpt::MergeBoundCheckHoistBlockData(
BasicBlock *const toBlock,
GlobOptBlockData *const toData,
BasicBlock *const fromBlock,
GlobOptBlockData *const fromData)
{
Assert(DoBoundCheckHoist());
Assert(toBlock);
Assert(toData);
Assert(toData == &toBlock->globOptData || toData == &blockData);
Assert(fromBlock);
Assert(fromData);
Assert(fromData == &fromBlock->globOptData);
Assert(toData->availableIntBoundChecks);
for(auto it = toData->availableIntBoundChecks->GetIteratorWithRemovalSupport(); it.IsValid(); it.MoveNext())
{
const IntBoundCheck &toDataIntBoundCheck = it.CurrentValue();
const IntBoundCheck *fromDataIntBoundCheck;
if(!fromData->availableIntBoundChecks->TryGetReference(
toDataIntBoundCheck.CompatibilityId(),
&fromDataIntBoundCheck) ||
fromDataIntBoundCheck->Instr() != toDataIntBoundCheck.Instr())
{
it.RemoveCurrent();
}
}
InductionVariableSet *mergeInductionVariablesInto;
if(toBlock->isLoopHeader)
{
Assert(fromBlock->loop == toBlock->loop); // The flow is such that you cannot have back-edges from an inner loop
if(IsLoopPrePass())
{
// Collect info for the parent loop. Any changes to induction variables in this inner loop need to be expanded in
// the same direction for the parent loop, so merge expanded info from back-edges. Info about induction variables
// that changed before the loop but not inside the loop, can be kept intact because the landing pad dominates the
// loop.
Assert(prePassLoop != toBlock->loop);
Assert(fromData->inductionVariables);
Assert(toData->inductionVariables);
InductionVariableSet *const mergedInductionVariables = toData->inductionVariables;
for(auto it = fromData->inductionVariables->GetIterator(); it.IsValid(); it.MoveNext())
{
InductionVariable backEdgeInductionVariable = it.CurrentValue();
backEdgeInductionVariable.ExpandInnerLoopChange();
StackSym *const sym = backEdgeInductionVariable.Sym();
InductionVariable *mergedInductionVariable;
if(mergedInductionVariables->TryGetReference(sym->m_id, &mergedInductionVariable))
{
mergedInductionVariable->Merge(backEdgeInductionVariable);
continue;
}
// Ensure that the sym is live in the parent loop's landing pad, and that its value has not changed in an
// unknown way between the parent loop's landing pad and the current loop's landing pad.
Value *const parentLandingPadValue =
FindValue(currentBlock->loop->parent->landingPad->globOptData.symToValueMap, sym);
if(!parentLandingPadValue)
{
continue;
}
Value *const landingPadValue = FindValue(currentBlock->loop->landingPad->globOptData.symToValueMap, sym);
Assert(landingPadValue);
if(landingPadValue->GetValueNumber() == parentLandingPadValue->GetValueNumber())
{
mergedInductionVariables->Add(backEdgeInductionVariable);
}
}
return;
}
// Collect info for the current loop. We want to merge only the back-edge info without the landing pad info, such that
// the loop's induction variable set reflects changes made inside this loop.
Assert(fromData->inductionVariables);
InductionVariableSet *&loopInductionVariables = toBlock->loop->inductionVariables;
if(!loopInductionVariables)
{
loopInductionVariables = fromData->inductionVariables->Clone();
return;
}
mergeInductionVariablesInto = loopInductionVariables;
}
else if(toBlock->loop && IsLoopPrePass())
{
Assert(fromBlock->loop);
Assert(toBlock->loop->IsDescendentOrSelf(fromBlock->loop));
mergeInductionVariablesInto = toData->inductionVariables;
}
else
{
return;
}
const InductionVariableSet *const fromDataInductionVariables = fromData->inductionVariables;
InductionVariableSet *const mergedInductionVariables = mergeInductionVariablesInto;
Assert(fromDataInductionVariables);
Assert(mergedInductionVariables);
for(auto it = mergedInductionVariables->GetIterator(); it.IsValid(); it.MoveNext())
{
InductionVariable &mergedInductionVariable = it.CurrentValueReference();
if(!mergedInductionVariable.IsChangeDeterminate())
{
continue;
}
StackSym *const sym = mergedInductionVariable.Sym();
const InductionVariable *fromDataInductionVariable;
if(fromDataInductionVariables->TryGetReference(sym->m_id, &fromDataInductionVariable))
{
mergedInductionVariable.Merge(*fromDataInductionVariable);
continue;
}
// Ensure that the sym is live in the landing pad, and that its value has not changed in an unknown way yet on the path
// where the sym is not already marked as an induction variable.
Value *const fromDataValue = FindValue(fromData->symToValueMap, sym);
if(fromDataValue)
{
Value *const landingPadValue = FindValue(toBlock->loop->landingPad->globOptData.symToValueMap, sym);
if(landingPadValue && fromDataValue->GetValueNumber() == landingPadValue->GetValueNumber())
{
mergedInductionVariable.Merge(InductionVariable(sym, ZeroValueNumber, 0));
continue;
}
}
mergedInductionVariable.SetChangeIsIndeterminate();
}
for(auto it = fromDataInductionVariables->GetIterator(); it.IsValid(); it.MoveNext())
{
const InductionVariable &fromDataInductionVariable = it.CurrentValue();
StackSym *const sym = fromDataInductionVariable.Sym();
if(mergedInductionVariables->ContainsKey(sym->m_id))
{
continue;
}
// Ensure that the sym is live in the landing pad, and that its value has not changed in an unknown way yet on the path
// where the sym is not already marked as an induction variable.
bool indeterminate = true;
Value *const toDataValue = FindValue(toData->symToValueMap, sym);
if(toDataValue)
{
Value *const landingPadValue = FindValue(toBlock->loop->landingPad->globOptData.symToValueMap, sym);
if(landingPadValue && toDataValue->GetValueNumber() == landingPadValue->GetValueNumber())
{
indeterminate = false;
}
}
InductionVariable mergedInductionVariable(sym, ZeroValueNumber, 0);
if(indeterminate)
{
mergedInductionVariable.SetChangeIsIndeterminate();
}
else
{
mergedInductionVariable.Merge(fromDataInductionVariable);
}
mergedInductionVariables->Add(mergedInductionVariable);
}
}
void GlobOpt::DetectUnknownChangesToInductionVariables(GlobOptBlockData *const blockData)
{
Assert(DoBoundCheckHoist());
Assert(IsLoopPrePass());
Assert(blockData);
Assert(blockData->inductionVariables);
// Check induction variable value numbers, and mark those that changed in an unknown way as indeterminate. They must remain
// in the set though, for merging purposes.
GlobHashTable *const symToValueMap = blockData->symToValueMap;
for(auto it = blockData->inductionVariables->GetIterator(); it.IsValid(); it.MoveNext())
{
InductionVariable &inductionVariable = it.CurrentValueReference();
if(!inductionVariable.IsChangeDeterminate())
{
continue;
}
Value *const value = FindValue(symToValueMap, inductionVariable.Sym());
if(!value || value->GetValueNumber() != inductionVariable.SymValueNumber())
{
inductionVariable.SetChangeIsIndeterminate();
}
}
}
void GlobOpt::SetInductionVariableValueNumbers(GlobOptBlockData *const blockData)
{
Assert(DoBoundCheckHoist());
Assert(IsLoopPrePass());
Assert(blockData == &this->blockData);
Assert(blockData->inductionVariables);
// Now that all values have been merged, update value numbers in the induction variable info.
GlobHashTable *const symToValueMap = blockData->symToValueMap;
for(auto it = blockData->inductionVariables->GetIterator(); it.IsValid(); it.MoveNext())
{
InductionVariable &inductionVariable = it.CurrentValueReference();
if(!inductionVariable.IsChangeDeterminate())
{
continue;
}
Value *const value = FindValue(symToValueMap, inductionVariable.Sym());
if(value)
{
inductionVariable.SetSymValueNumber(value->GetValueNumber());
}
else
{
inductionVariable.SetChangeIsIndeterminate();
}
}
}
void GlobOpt::FinalizeInductionVariables(Loop *const loop, GlobOptBlockData *const headerData)
{
Assert(DoBoundCheckHoist());
Assert(!IsLoopPrePass());
Assert(loop);
Assert(loop->GetHeadBlock() == currentBlock);
Assert(loop->inductionVariables);
Assert(currentBlock->isLoopHeader);
Assert(headerData == &this->blockData);
// Clean up induction variables and for each, install a relationship between its values inside and outside the loop.
GlobHashTable *const symToValueMap = headerData->symToValueMap;
GlobOptBlockData &landingPadBlockData = loop->landingPad->globOptData;
GlobHashTable *const landingPadSymToValueMap = landingPadBlockData.symToValueMap;
for(auto it = loop->inductionVariables->GetIterator(); it.IsValid(); it.MoveNext())
{
InductionVariable &inductionVariable = it.CurrentValueReference();
if(!inductionVariable.IsChangeDeterminate())
{
continue;
}
if(!inductionVariable.IsChangeUnidirectional())
{
inductionVariable.SetChangeIsIndeterminate();
continue;
}
StackSym *const sym = inductionVariable.Sym();
if(!IsInt32TypeSpecialized(sym, headerData))
{
inductionVariable.SetChangeIsIndeterminate();
continue;
}
Assert(IsInt32TypeSpecialized(sym, &landingPadBlockData));
Value *const value = FindValue(symToValueMap, sym);
if(!value)
{
inductionVariable.SetChangeIsIndeterminate();
continue;
}
Value *const landingPadValue = FindValue(landingPadSymToValueMap, sym);
Assert(landingPadValue);
IntConstantBounds constantBounds, landingPadConstantBounds;
AssertVerify(value->GetValueInfo()->TryGetIntConstantBounds(&constantBounds));
AssertVerify(landingPadValue->GetValueInfo()->TryGetIntConstantBounds(&landingPadConstantBounds, true));
// For an induction variable i, update the value of i inside the loop to indicate that it is bounded by the value of i
// just before the loop.
if(inductionVariable.ChangeBounds().LowerBound() >= 0)
{
ValueInfo *const newValueInfo =
UpdateIntBoundsForGreaterThanOrEqual(value, constantBounds, landingPadValue, landingPadConstantBounds, true);
ChangeValueInfo(nullptr, value, newValueInfo);
if(inductionVariable.ChangeBounds().UpperBound() == 0)
{
AssertVerify(newValueInfo->TryGetIntConstantBounds(&constantBounds, true));
}
}
if(inductionVariable.ChangeBounds().UpperBound() <= 0)
{
ValueInfo *const newValueInfo =
UpdateIntBoundsForLessThanOrEqual(value, constantBounds, landingPadValue, landingPadConstantBounds, true);
ChangeValueInfo(nullptr, value, newValueInfo);
}
}
}
bool GlobOpt::DetermineSymBoundOffsetOrValueRelativeToLandingPad(
StackSym *const sym,
const bool landingPadValueIsLowerBound,
ValueInfo *const valueInfo,
const IntBounds *const bounds,
GlobHashTable *const landingPadSymToValueMap,
int *const boundOffsetOrValueRef)
{
Assert(sym);
Assert(!sym->IsTypeSpec());
Assert(valueInfo);
Assert(landingPadSymToValueMap);
Assert(boundOffsetOrValueRef);
Assert(valueInfo->IsInt());
int constantValue;
if(valueInfo->TryGetIntConstantValue(&constantValue))
{
// The sym's constant value is the constant bound value, so just return that. This is possible in loops such as
// for(; i === 1; ++i){...}, where 'i' is an induction variable but has a constant value inside the loop, or in blocks
// inside the loop such as if(i === 1){...}
*boundOffsetOrValueRef = constantValue;
return true; // 'true' indicates that *boundOffsetOrValueRef contains the constant bound value
}
Value *const landingPadValue = FindValue(landingPadSymToValueMap, sym);
Assert(landingPadValue);
Assert(landingPadValue->GetValueInfo()->IsInt());
int landingPadConstantValue;
if(landingPadValue->GetValueInfo()->TryGetIntConstantValue(&landingPadConstantValue))
{
// The sym's bound already takes the landing pad constant value into consideration, unless the landing pad value was
// updated to have a more aggressive range (and hence, now a constant value) as part of hoisting a bound check or some
// other hoisting operation. The sym's bound also takes into consideration the change to the sym so far inside the loop,
// and the landing pad constant value does not, so use the sym's bound by default.
int constantBound;
if(bounds)
{
constantBound = landingPadValueIsLowerBound ? bounds->ConstantLowerBound() : bounds->ConstantUpperBound();
}
else
{
AssertVerify(
landingPadValueIsLowerBound
? valueInfo->TryGetIntConstantLowerBound(&constantBound)
: valueInfo->TryGetIntConstantUpperBound(&constantBound));
}
if(landingPadValueIsLowerBound ? landingPadConstantValue > constantBound : landingPadConstantValue < constantBound)
{
// The landing pad value became a constant value as part of a hoisting operation. The landing pad constant value is
// a more aggressive bound, so use that instead, and take into consideration the change to the sym so far inside the
// loop, using the relative bound to the landing pad value.
AnalysisAssert(bounds);
const ValueRelativeOffset *bound;
AssertVerify(
(landingPadValueIsLowerBound ? bounds->RelativeLowerBounds() : bounds->RelativeUpperBounds())
.TryGetReference(landingPadValue->GetValueNumber(), &bound));
constantBound = landingPadConstantValue + bound->Offset();
}
*boundOffsetOrValueRef = constantBound;
return true; // 'true' indicates that *boundOffsetOrValueRef contains the constant bound value
}
AnalysisAssert(bounds);
const ValueRelativeOffset *bound;
AssertVerify(
(landingPadValueIsLowerBound ? bounds->RelativeLowerBounds() : bounds->RelativeUpperBounds())
.TryGetReference(landingPadValue->GetValueNumber(), &bound));
*boundOffsetOrValueRef = bound->Offset();
// 'false' indicates that *boundOffsetOrValueRef contains the bound offset, which must be added to the sym's value in the
// landing pad to get the bound value
return false;
}
void GlobOpt::DetermineDominatingLoopCountableBlock(Loop *const loop, BasicBlock *const headerBlock)
{
Assert(DoLoopCountBasedBoundCheckHoist());
Assert(!IsLoopPrePass());
Assert(loop);
Assert(headerBlock);
Assert(headerBlock->isLoopHeader);
Assert(headerBlock->loop == loop);
// Determine if the loop header has a unique successor that is inside the loop. If so, then all other paths out of the loop
// header exit the loop, allowing a loop count to be established and used from the unique in-loop successor block.
Assert(!loop->dominatingLoopCountableBlock);
FOREACH_SUCCESSOR_BLOCK(successor, headerBlock)
{
if(successor->loop != loop)
{
Assert(!successor->loop || successor->loop->IsDescendentOrSelf(loop->parent));
continue;
}
if(loop->dominatingLoopCountableBlock)
{
// Found a second successor inside the loop
loop->dominatingLoopCountableBlock = nullptr;
break;
}
loop->dominatingLoopCountableBlock = successor;
} NEXT_SUCCESSOR_BLOCK;
}
void GlobOpt::DetermineLoopCount(Loop *const loop)
{
Assert(DoLoopCountBasedBoundCheckHoist());
Assert(loop);
GlobOptBlockData &landingPadBlockData = loop->landingPad->globOptData;
GlobHashTable *const landingPadSymToValueMap = landingPadBlockData.symToValueMap;
const InductionVariableSet *const inductionVariables = loop->inductionVariables;
Assert(inductionVariables);
for(auto inductionVariablesIterator = inductionVariables->GetIterator(); inductionVariablesIterator.IsValid(); inductionVariablesIterator.MoveNext())
{
InductionVariable &inductionVariable = inductionVariablesIterator.CurrentValueReference();
if(!inductionVariable.IsChangeDeterminate())
{
continue;
}
// Determine the minimum-magnitude change per iteration, and verify that the change is nonzero and finite
Assert(inductionVariable.IsChangeUnidirectional());
int minMagnitudeChange = inductionVariable.ChangeBounds().LowerBound();
if(minMagnitudeChange >= 0)
{
if(minMagnitudeChange == 0 || minMagnitudeChange == IntConstMax)
{
continue;
}
}
else
{
minMagnitudeChange = inductionVariable.ChangeBounds().UpperBound();
Assert(minMagnitudeChange <= 0);
if(minMagnitudeChange == 0 || minMagnitudeChange == IntConstMin)
{
continue;
}
}
StackSym *const inductionVariableVarSym = inductionVariable.Sym();
if(!IsInt32TypeSpecialized(inductionVariableVarSym, &blockData))
{
inductionVariable.SetChangeIsIndeterminate();
continue;
}
Assert(IsInt32TypeSpecialized(inductionVariableVarSym, &landingPadBlockData));
Value *const inductionVariableValue = FindValue(inductionVariableVarSym);
if(!inductionVariableValue)
{
inductionVariable.SetChangeIsIndeterminate();
continue;
}
ValueInfo *const inductionVariableValueInfo = inductionVariableValue->GetValueInfo();
const IntBounds *const inductionVariableBounds =
inductionVariableValueInfo->IsIntBounded() ? inductionVariableValueInfo->AsIntBounded()->Bounds() : nullptr;
// Look for an invariant bound in the direction of change
StackSym *boundBaseVarSym = nullptr;
int boundOffset = 0;
{
bool foundBound = false;
if(inductionVariableBounds)
{
// Look for a relative bound
for(auto it =
(
minMagnitudeChange >= 0
? inductionVariableBounds->RelativeUpperBounds()
: inductionVariableBounds->RelativeLowerBounds()
).GetIterator();
it.IsValid();
it.MoveNext())
{
const ValueRelativeOffset &bound = it.CurrentValue();
StackSym *currentBoundBaseVarSym = bound.BaseSym();
if(!currentBoundBaseVarSym || !IsInt32TypeSpecialized(currentBoundBaseVarSym, &landingPadBlockData))
{
continue;
}
Value *const boundBaseValue = FindValue(currentBoundBaseVarSym);
const ValueNumber boundBaseValueNumber = bound.BaseValueNumber();
if(!boundBaseValue || boundBaseValue->GetValueNumber() != boundBaseValueNumber)
{
continue;
}
Value *const landingPadBoundBaseValue = FindValue(landingPadSymToValueMap, currentBoundBaseVarSym);
if(!landingPadBoundBaseValue || landingPadBoundBaseValue->GetValueNumber() != boundBaseValueNumber)
{
continue;
}
if (foundBound)
{
// We used to pick the first usable bound we saw in this list, but the list contains both
// the loop counter's bound *and* relative bounds of the primary bound. These secondary bounds
// are not guaranteed to be correct, so if the bound we found on a previous iteration is itself
// a bound for the current bound, then choose the current bound.
if (!boundBaseValue->GetValueInfo()->IsIntBounded())
{
continue;
}
// currentBoundBaseVarSym has relative bounds of its own. If we find the saved boundBaseVarSym
// in currentBoundBaseVarSym's relative bounds list, let currentBoundBaseVarSym be the
// chosen bound.
const IntBounds *const currentBounds = boundBaseValue->GetValueInfo()->AsIntBounded()->Bounds();
bool foundSecondaryBound = false;
for (auto it2 =
(
minMagnitudeChange >= 0
? currentBounds->RelativeUpperBounds()
: currentBounds->RelativeLowerBounds()
).GetIterator();
it2.IsValid();
it2.MoveNext())
{
const ValueRelativeOffset &bound2 = it2.CurrentValue();
if (bound2.BaseSym() == boundBaseVarSym)
{
// boundBaseVarSym is a secondary bound. Use currentBoundBaseVarSym instead.
foundSecondaryBound = true;
break;
}
}
if (!foundSecondaryBound)
{
// boundBaseVarSym is not a relative bound of currentBoundBaseVarSym, so continue
// to use boundBaseVarSym.
continue;
}
}
boundBaseVarSym = bound.BaseSym();
boundOffset = bound.Offset();
foundBound = true;
}
}
if(!foundBound)
{
// No useful relative bound found; look for a constant bound. Exclude large constant bounds established implicitly by
// <, <=, >, and >=. For example, for a loop condition (i < n), if 'n' is not invariant and hence can't be used,
// 'i' will still have a constant upper bound of (int32 max - 1) that should be excluded as it's too large. Any
// other constant bounds must have been established explicitly by the loop condition, and are safe to use.
boundBaseVarSym = nullptr;
if(minMagnitudeChange >= 0)
{
if(inductionVariableBounds)
{
boundOffset = inductionVariableBounds->ConstantUpperBound();
}
else
{
AssertVerify(inductionVariableValueInfo->TryGetIntConstantUpperBound(&boundOffset));
}
if(boundOffset >= IntConstMax - 1)
{
continue;
}
}
else
{
if(inductionVariableBounds)
{
boundOffset = inductionVariableBounds->ConstantLowerBound();
}
else
{
AssertVerify(inductionVariableValueInfo->TryGetIntConstantLowerBound(&boundOffset));
}
if(boundOffset <= IntConstMin + 1)
{
continue;
}
}
}
}
// Determine if the induction variable already changed in the loop, and by how much
int inductionVariableOffset;
StackSym *inductionVariableSymToAdd;
if(DetermineSymBoundOffsetOrValueRelativeToLandingPad(
inductionVariableVarSym,
minMagnitudeChange >= 0,
inductionVariableValueInfo,
inductionVariableBounds,
landingPadSymToValueMap,
&inductionVariableOffset))
{
// The bound value is constant
inductionVariableSymToAdd = nullptr;
}
else
{
// The bound value is not constant, the offset needs to be added to the induction variable in the landing pad
inductionVariableSymToAdd = inductionVariableVarSym->GetInt32EquivSym(nullptr);
Assert(inductionVariableSymToAdd);
}
// Int operands are required
StackSym *boundBaseSym;
if(boundBaseVarSym)
{
boundBaseSym = boundBaseVarSym->IsVar() ? boundBaseVarSym->GetInt32EquivSym(nullptr) : boundBaseVarSym;
Assert(boundBaseSym);
Assert(boundBaseSym->GetType() == TyInt32 || boundBaseSym->GetType() == TyUint32);
}
else
{
boundBaseSym = nullptr;
}
// The loop count is computed as follows. We're actually computing the loop count minus one, because the value is used
// to determine the bound of a secondary induction variable in its direction of change, and at that point the secondary
// induction variable's information already accounts for changes in the first loop iteration.
//
// If the induction variable increases in the loop:
// loopCountMinusOne = (upperBound - inductionVariable) / abs(minMagnitudeChange)
// Or more precisely:
// loopCountMinusOne =
// ((boundBase - inductionVariable) + (boundOffset - inductionVariableOffset)) / abs(minMagnitudeChange)
//
// If the induction variable decreases in the loop, the subtract operands are just reversed to yield a nonnegative
// number, and the rest is similar. The two offsets are also constant and can be folded. So in general:
// loopCountMinusOne = (left - right + offset) / abs(minMagnitudeChange)
// Determine the left and right information
StackSym *leftSym, *rightSym;
int leftOffset, rightOffset;
if(minMagnitudeChange >= 0)
{
leftSym = boundBaseSym;
leftOffset = boundOffset;
rightSym = inductionVariableSymToAdd;
rightOffset = inductionVariableOffset;
}
else
{
minMagnitudeChange = -minMagnitudeChange;
leftSym = inductionVariableSymToAdd;
leftOffset = inductionVariableOffset;
rightSym = boundBaseSym;
rightOffset = boundOffset;
}
// Determine the combined offset, and save the info necessary to generate the loop count
int offset;
if(Int32Math::Sub(leftOffset, rightOffset, &offset))
{
continue;
}
void *const loopCountBuffer = JitAnewArray(this->func->GetTopFunc()->m_fg->alloc, byte, sizeof(LoopCount));
if(!rightSym)
{
if(!leftSym)
{
loop->loopCount = new(loopCountBuffer) LoopCount(offset / minMagnitudeChange);
break;
}
if(offset == 0 && minMagnitudeChange == 1)
{
loop->loopCount = new(loopCountBuffer) LoopCount(leftSym);
break;
}
}
loop->loopCount = new(loopCountBuffer) LoopCount(leftSym, rightSym, offset, minMagnitudeChange);
break;
}
}
void GlobOpt::GenerateLoopCount(Loop *const loop, LoopCount *const loopCount)
{
Assert(DoLoopCountBasedBoundCheckHoist());
Assert(loop);
Assert(loopCount);
Assert(loopCount == loop->loopCount);
Assert(!loopCount->HasBeenGenerated());
// loopCountMinusOne = (left - right + offset) / minMagnitudeChange
// Prepare the landing pad for bailouts and instruction insertion
BailOutInfo *const bailOutInfo = loop->bailOutInfo;
Assert(bailOutInfo);
const IR::BailOutKind bailOutKind = IR::BailOutOnFailedHoistedLoopCountBasedBoundCheck;
IR::Instr *const insertBeforeInstr = bailOutInfo->bailOutInstr;
Assert(insertBeforeInstr);
Func *const func = bailOutInfo->bailOutFunc;
// intermediateValue = left - right
IR::IntConstOpnd *offset =
loopCount->Offset() == 0 ? nullptr : IR::IntConstOpnd::New(loopCount->Offset(), TyInt32, func, true);
StackSym *const rightSym = loopCount->RightSym();
StackSym *intermediateValueSym;
if(rightSym)
{
IR::BailOutInstr *const instr = IR::BailOutInstr::New(Js::OpCode::Sub_I4, bailOutKind, bailOutInfo, func);
instr->SetSrc2(IR::RegOpnd::New(rightSym, rightSym->GetType(), func));
instr->GetSrc2()->SetIsJITOptimizedReg(true);
StackSym *const leftSym = loopCount->LeftSym();
if(leftSym)
{
// intermediateValue = left - right
instr->SetSrc1(IR::RegOpnd::New(leftSym, leftSym->GetType(), func));
instr->GetSrc1()->SetIsJITOptimizedReg(true);
}
else if(offset)
{
// intermediateValue = offset - right
instr->SetSrc1(offset);
offset = nullptr;
}
else
{
// intermediateValue = -right
instr->m_opcode = Js::OpCode::Neg_I4;
instr->SetSrc1(instr->UnlinkSrc2());
}
intermediateValueSym = StackSym::New(TyInt32, func);
instr->SetDst(IR::RegOpnd::New(intermediateValueSym, intermediateValueSym->GetType(), func));
instr->GetDst()->SetIsJITOptimizedReg(true);
instr->SetByteCodeOffset(insertBeforeInstr);
insertBeforeInstr->InsertBefore(instr);
}
else
{
// intermediateValue = left
Assert(loopCount->LeftSym());
intermediateValueSym = loopCount->LeftSym();
}
// intermediateValue += offset
if(offset)
{
IR::BailOutInstr *const instr = IR::BailOutInstr::New(Js::OpCode::Add_I4, bailOutKind, bailOutInfo, func);
instr->SetSrc1(IR::RegOpnd::New(intermediateValueSym, intermediateValueSym->GetType(), func));
instr->GetSrc1()->SetIsJITOptimizedReg(true);
if(offset->GetValue() < 0 && offset->GetValue() != IntConstMin)
{
instr->m_opcode = Js::OpCode::Sub_I4;
offset->SetValue(-offset->GetValue());
}
instr->SetSrc2(offset);
if(intermediateValueSym == loopCount->LeftSym())
{
intermediateValueSym = StackSym::New(TyInt32, func);
}
instr->SetDst(IR::RegOpnd::New(intermediateValueSym, intermediateValueSym->GetType(), func));
instr->GetDst()->SetIsJITOptimizedReg(true);
instr->SetByteCodeOffset(insertBeforeInstr);
insertBeforeInstr->InsertBefore(instr);
}
// intermediateValue /= minMagnitudeChange
const int minMagnitudeChange = loopCount->MinMagnitudeChange();
if(minMagnitudeChange != 1)
{
IR::Instr *const instr = IR::Instr::New(Js::OpCode::Div_I4, func);
instr->SetSrc1(IR::RegOpnd::New(intermediateValueSym, intermediateValueSym->GetType(), func));
instr->GetSrc1()->SetIsJITOptimizedReg(true);
Assert(minMagnitudeChange != 0); // bailout is not needed
instr->SetSrc2(IR::IntConstOpnd::New(minMagnitudeChange, TyInt32, func, true));
if(intermediateValueSym == loopCount->LeftSym())
{
intermediateValueSym = StackSym::New(TyInt32, func);
}
instr->SetDst(IR::RegOpnd::New(intermediateValueSym, intermediateValueSym->GetType(), func));
instr->GetDst()->SetIsJITOptimizedReg(true);
instr->SetByteCodeOffset(insertBeforeInstr);
insertBeforeInstr->InsertBefore(instr);
}
else
{
Assert(intermediateValueSym != loopCount->LeftSym());
}
// loopCountMinusOne = intermediateValue
loopCount->SetLoopCountMinusOneSym(intermediateValueSym);
}
void GlobOpt::GenerateLoopCountPlusOne(Loop *const loop, LoopCount *const loopCount)
{
Assert(loop);
Assert(loopCount);
Assert(loopCount == loop->loopCount);
if (loopCount->HasGeneratedLoopCountSym())
{
return;
}
if (!loopCount->HasBeenGenerated())
{
GenerateLoopCount(loop, loopCount);
}
Assert(loopCount->HasBeenGenerated());
// If this is null then the loop count is a constant and there is nothing more to do here
if (loopCount->LoopCountMinusOneSym())
{
// Prepare the landing pad for bailouts and instruction insertion
BailOutInfo *const bailOutInfo = loop->bailOutInfo;
Assert(bailOutInfo);
IR::Instr *const insertBeforeInstr = bailOutInfo->bailOutInstr;
Assert(insertBeforeInstr);
Func *const func = bailOutInfo->bailOutFunc;
IRType type = loopCount->LoopCountMinusOneSym()->GetType();
// loop count is off by one, so add one
IR::RegOpnd *loopCountOpnd = IR::RegOpnd::New(type, func);
IR::RegOpnd *minusOneOpnd = IR::RegOpnd::New(loopCount->LoopCountMinusOneSym(), type, func);
minusOneOpnd->SetIsJITOptimizedReg(true);
insertBeforeInstr->InsertBefore(IR::Instr::New(Js::OpCode::Add_I4,
loopCountOpnd,
minusOneOpnd,
IR::IntConstOpnd::New(1, type, func, true),
func));
loopCount->SetLoopCountSym(loopCountOpnd->GetStackSym());
}
}
void GlobOpt::GenerateSecondaryInductionVariableBound(
Loop *const loop,
StackSym *const inductionVariableSym,
const LoopCount *const loopCount,
const int maxMagnitudeChange,
StackSym *const boundSym)
{
Assert(loop);
Assert(inductionVariableSym);
Assert(inductionVariableSym->GetType() == TyInt32 || inductionVariableSym->GetType() == TyUint32);
Assert(loopCount);
Assert(loopCount == loop->loopCount);
Assert(loopCount->LoopCountMinusOneSym());
Assert(maxMagnitudeChange != 0);
Assert(maxMagnitudeChange >= -InductionVariable::ChangeMagnitudeLimitForLoopCountBasedHoisting);
Assert(maxMagnitudeChange <= InductionVariable::ChangeMagnitudeLimitForLoopCountBasedHoisting);
Assert(boundSym);
Assert(boundSym->IsInt32());
// bound = inductionVariable + loopCountMinusOne * maxMagnitudeChange
// Prepare the landing pad for bailouts and instruction insertion
BailOutInfo *const bailOutInfo = loop->bailOutInfo;
Assert(bailOutInfo);
const IR::BailOutKind bailOutKind = IR::BailOutOnFailedHoistedLoopCountBasedBoundCheck;
IR::Instr *const insertBeforeInstr = bailOutInfo->bailOutInstr;
Assert(insertBeforeInstr);
Func *const func = bailOutInfo->bailOutFunc;
// intermediateValue = loopCount * maxMagnitudeChange
StackSym *intermediateValueSym;
if(maxMagnitudeChange == 1 || maxMagnitudeChange == -1)
{
intermediateValueSym = loopCount->LoopCountMinusOneSym();
}
else
{
IR::BailOutInstr *const instr = IR::BailOutInstr::New(Js::OpCode::Mul_I4, bailOutKind, bailOutInfo, func);
instr->SetSrc1(
IR::RegOpnd::New(loopCount->LoopCountMinusOneSym(), loopCount->LoopCountMinusOneSym()->GetType(), func));
instr->GetSrc1()->SetIsJITOptimizedReg(true);
instr->SetSrc2(IR::IntConstOpnd::New(maxMagnitudeChange, TyInt32, func, true));
intermediateValueSym = boundSym;
instr->SetDst(IR::RegOpnd::New(intermediateValueSym, intermediateValueSym->GetType(), func));
instr->GetDst()->SetIsJITOptimizedReg(true);
instr->SetByteCodeOffset(insertBeforeInstr);
insertBeforeInstr->InsertBefore(instr);
}
// bound = intermediateValue + inductionVariable
{
IR::BailOutInstr *const instr = IR::BailOutInstr::New(Js::OpCode::Add_I4, bailOutKind, bailOutInfo, func);
instr->SetSrc1(IR::RegOpnd::New(intermediateValueSym, intermediateValueSym->GetType(), func));
instr->GetSrc1()->SetIsJITOptimizedReg(true);
instr->SetSrc2(IR::RegOpnd::New(inductionVariableSym, inductionVariableSym->GetType(), func));
instr->GetSrc2()->SetIsJITOptimizedReg(true);
if(maxMagnitudeChange == -1)
{
// bound = inductionVariable - intermediateValue[loopCount]
instr->m_opcode = Js::OpCode::Sub_I4;
instr->SwapOpnds();
}
instr->SetDst(IR::RegOpnd::New(boundSym, boundSym->GetType(), func));
instr->GetDst()->SetIsJITOptimizedReg(true);
instr->SetByteCodeOffset(insertBeforeInstr);
insertBeforeInstr->InsertBefore(instr);
}
}
void GlobOpt::DetermineArrayBoundCheckHoistability(
bool needLowerBoundCheck,
bool needUpperBoundCheck,
ArrayLowerBoundCheckHoistInfo &lowerHoistInfo,
ArrayUpperBoundCheckHoistInfo &upperHoistInfo,
const bool isJsArray,
StackSym *const indexSym,
Value *const indexValue,
const IntConstantBounds &indexConstantBounds,
StackSym *const headSegmentLengthSym,
Value *const headSegmentLengthValue,
const IntConstantBounds &headSegmentLengthConstantBounds,
Loop *const headSegmentLengthInvariantLoop,
bool &failedToUpdateCompatibleLowerBoundCheck,
bool &failedToUpdateCompatibleUpperBoundCheck)
{
Assert(DoBoundCheckHoist());
Assert(needLowerBoundCheck || needUpperBoundCheck);
Assert(!lowerHoistInfo.HasAnyInfo());
Assert(!upperHoistInfo.HasAnyInfo());
Assert(!indexSym == !indexValue);
Assert(!needUpperBoundCheck || headSegmentLengthSym);
Assert(!headSegmentLengthSym == !headSegmentLengthValue);
Assert(!failedToUpdateCompatibleLowerBoundCheck);
Assert(!failedToUpdateCompatibleUpperBoundCheck);
Loop *const currentLoop = currentBlock->loop;
if(!indexValue)
{
Assert(!needLowerBoundCheck);
Assert(needUpperBoundCheck);
Assert(indexConstantBounds.IsConstant());
// The index is a constant value, so a bound check on it can be hoisted as far as desired. Just find a compatible bound
// check that is already available, or the loop in which the head segment length is invariant.
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
2,
_u("Index is constant, looking for a compatible upper bound check\n"));
const int indexConstantValue = indexConstantBounds.LowerBound();
Assert(indexConstantValue != IntConstMax);
const IntBoundCheck *compatibleBoundCheck;
if(blockData.availableIntBoundChecks->TryGetReference(
IntBoundCheckCompatibilityId(ZeroValueNumber, headSegmentLengthValue->GetValueNumber()),
&compatibleBoundCheck))
{
// We need:
// index < headSegmentLength
// Normalize the offset such that:
// 0 <= headSegmentLength + compatibleBoundCheckOffset
// Where (compatibleBoundCheckOffset = -1 - index), and -1 is to simulate < instead of <=.
const int compatibleBoundCheckOffset = -1 - indexConstantValue;
if(compatibleBoundCheck->SetBoundOffset(compatibleBoundCheckOffset))
{
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
3,
_u("Found in block %u\n"),
compatibleBoundCheck->Block()->GetBlockNum());
upperHoistInfo.SetCompatibleBoundCheck(compatibleBoundCheck->Block(), indexConstantValue);
return;
}
failedToUpdateCompatibleUpperBoundCheck = true;
}
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 3, _u("Not found\n"));
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 2, _u("Looking for invariant head segment length\n"));
Loop *invariantLoop;
Value *landingPadHeadSegmentLengthValue = nullptr;
if(headSegmentLengthInvariantLoop)
{
invariantLoop = headSegmentLengthInvariantLoop;
landingPadHeadSegmentLengthValue =
FindValue(invariantLoop->landingPad->globOptData.symToValueMap, headSegmentLengthSym);
}
else if(currentLoop)
{
invariantLoop = nullptr;
for(Loop *loop = currentLoop; loop; loop = loop->parent)
{
GlobOptBlockData &landingPadBlockData = loop->landingPad->globOptData;
GlobHashTable *const landingPadSymToValueMap = landingPadBlockData.symToValueMap;
Value *const value = FindValue(landingPadSymToValueMap, headSegmentLengthSym);
if(!value)
{
break;
}
invariantLoop = loop;
landingPadHeadSegmentLengthValue = value;
}
if(!invariantLoop)
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 3, _u("Not found\n"));
return;
}
}
else
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 3, _u("Not found, block is not in a loop\n"));
return;
}
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
3,
_u("Found in loop %u landing pad block %u\n"),
invariantLoop->GetLoopNumber(),
invariantLoop->landingPad->GetBlockNum());
IntConstantBounds landingPadHeadSegmentLengthConstantBounds;
AssertVerify(
landingPadHeadSegmentLengthValue
->GetValueInfo()
->TryGetIntConstantBounds(&landingPadHeadSegmentLengthConstantBounds));
if(isJsArray)
{
// index >= headSegmentLength is currently not possible for JS arrays (except when index == int32 max, which is
// covered above).
Assert(
!ValueInfo::IsGreaterThanOrEqualTo(
nullptr,
indexConstantValue,
indexConstantValue,
landingPadHeadSegmentLengthValue,
landingPadHeadSegmentLengthConstantBounds.LowerBound(),
landingPadHeadSegmentLengthConstantBounds.UpperBound()));
}
else if(
ValueInfo::IsGreaterThanOrEqualTo(
nullptr,
indexConstantValue,
indexConstantValue,
landingPadHeadSegmentLengthValue,
landingPadHeadSegmentLengthConstantBounds.LowerBound(),
landingPadHeadSegmentLengthConstantBounds.UpperBound()))
{
// index >= headSegmentLength in the landing pad, can't use the index sym. This is possible for typed arrays through
// conditions on array.length in user code.
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 2, _u("Index >= head segment length\n"));
return;
}
upperHoistInfo.SetLoop(
invariantLoop,
indexConstantValue,
landingPadHeadSegmentLengthValue,
landingPadHeadSegmentLengthConstantBounds);
return;
}
Assert(!indexConstantBounds.IsConstant());
ValueInfo *const indexValueInfo = indexValue->GetValueInfo();
const IntBounds *const indexBounds = indexValueInfo->IsIntBounded() ? indexValueInfo->AsIntBounded()->Bounds() : nullptr;
{
// See if a compatible bound check is already available
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
2,
_u("Looking for compatible bound checks for index bounds\n"));
bool searchingLower = needLowerBoundCheck;
bool searchingUpper = needUpperBoundCheck;
Assert(searchingLower || searchingUpper);
bool foundLowerBoundCheck = false;
const IntBoundCheck *lowerBoundCheck = nullptr;
ValueNumber lowerHoistBlockIndexValueNumber = InvalidValueNumber;
int lowerBoundOffset = 0;
if(searchingLower &&
blockData.availableIntBoundChecks->TryGetReference(
IntBoundCheckCompatibilityId(ZeroValueNumber, indexValue->GetValueNumber()),
&lowerBoundCheck))
{
if(lowerBoundCheck->SetBoundOffset(0))
{
foundLowerBoundCheck = true;
lowerHoistBlockIndexValueNumber = indexValue->GetValueNumber();
lowerBoundOffset = 0;
searchingLower = false;
}
else
{
failedToUpdateCompatibleLowerBoundCheck = true;
}
}
bool foundUpperBoundCheck = false;
const IntBoundCheck *upperBoundCheck = nullptr;
ValueNumber upperHoistBlockIndexValueNumber = InvalidValueNumber;
int upperBoundOffset = 0;
if(searchingUpper &&
blockData.availableIntBoundChecks->TryGetReference(
IntBoundCheckCompatibilityId(indexValue->GetValueNumber(), headSegmentLengthValue->GetValueNumber()),
&upperBoundCheck))
{
if(upperBoundCheck->SetBoundOffset(-1)) // -1 is to simulate < instead of <=
{
foundUpperBoundCheck = true;
upperHoistBlockIndexValueNumber = indexValue->GetValueNumber();
upperBoundOffset = 0;
searchingUpper = false;
}
else
{
failedToUpdateCompatibleUpperBoundCheck = true;
}
}
if(indexBounds)
{
searchingLower = searchingLower && indexBounds->RelativeLowerBounds().Count() != 0;
searchingUpper = searchingUpper && indexBounds->RelativeUpperBounds().Count() != 0;
if(searchingLower || searchingUpper)
{
for(auto it = blockData.availableIntBoundChecks->GetIterator(); it.IsValid(); it.MoveNext())
{
const IntBoundCheck &boundCheck = it.CurrentValue();
if(searchingLower && boundCheck.LeftValueNumber() == ZeroValueNumber)
{
lowerHoistBlockIndexValueNumber = boundCheck.RightValueNumber();
const ValueRelativeOffset *bound;
if(indexBounds->RelativeLowerBounds().TryGetReference(lowerHoistBlockIndexValueNumber, &bound))
{
// We need:
// 0 <= boundBase + boundOffset
const int offset = bound->Offset();
if(boundCheck.SetBoundOffset(offset))
{
foundLowerBoundCheck = true;
lowerBoundCheck = &boundCheck;
lowerBoundOffset = offset;
searchingLower = false;
if(!searchingUpper)
{
break;
}
}
else
{
failedToUpdateCompatibleLowerBoundCheck = true;
}
}
}
if(searchingUpper && boundCheck.RightValueNumber() == headSegmentLengthValue->GetValueNumber())
{
upperHoistBlockIndexValueNumber = boundCheck.LeftValueNumber();
const ValueRelativeOffset *bound;
if(indexBounds->RelativeUpperBounds().TryGetReference(upperHoistBlockIndexValueNumber, &bound))
{
// We need:
// boundBase + boundOffset < headSegmentLength
// Normalize the offset such that:
// boundBase <= headSegmentLength + compatibleBoundCheckOffset
// Where (compatibleBoundCheckOffset = -1 - boundOffset), and -1 is to simulate < instead of <=.
const int offset = -1 - bound->Offset();
if(boundCheck.SetBoundOffset(offset))
{
foundUpperBoundCheck = true;
upperBoundCheck = &boundCheck;
upperBoundOffset = bound->Offset();
searchingUpper = false;
if(!searchingLower)
{
break;
}
}
else
{
failedToUpdateCompatibleUpperBoundCheck = true;
}
}
}
}
}
}
if(foundLowerBoundCheck)
{
// A bound check takes the form src1 <= src2 + dst
Assert(lowerBoundCheck->Instr()->GetSrc2());
Assert(
lowerBoundCheck->Instr()->GetSrc2()->AsRegOpnd()->m_sym->GetType() == TyInt32 ||
lowerBoundCheck->Instr()->GetSrc2()->AsRegOpnd()->m_sym->GetType() == TyUint32);
StackSym *boundCheckIndexSym = lowerBoundCheck->Instr()->GetSrc2()->AsRegOpnd()->m_sym;
if(boundCheckIndexSym->IsTypeSpec())
{
boundCheckIndexSym = boundCheckIndexSym->GetVarEquivSym(nullptr);
Assert(boundCheckIndexSym);
}
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
3,
_u("Found lower bound (s%u + %d) in block %u\n"),
boundCheckIndexSym->m_id,
lowerBoundOffset,
lowerBoundCheck->Block()->GetBlockNum());
lowerHoistInfo.SetCompatibleBoundCheck(
lowerBoundCheck->Block(),
boundCheckIndexSym,
lowerBoundOffset,
lowerHoistBlockIndexValueNumber);
Assert(!searchingLower);
needLowerBoundCheck = false;
if(!needUpperBoundCheck)
{
return;
}
}
if(foundUpperBoundCheck)
{
// A bound check takes the form src1 <= src2 + dst
Assert(upperBoundCheck->Instr()->GetSrc1());
Assert(
upperBoundCheck->Instr()->GetSrc1()->AsRegOpnd()->m_sym->GetType() == TyInt32 ||
upperBoundCheck->Instr()->GetSrc1()->AsRegOpnd()->m_sym->GetType() == TyUint32);
StackSym *boundCheckIndexSym = upperBoundCheck->Instr()->GetSrc1()->AsRegOpnd()->m_sym;
if(boundCheckIndexSym->IsTypeSpec())
{
boundCheckIndexSym = boundCheckIndexSym->GetVarEquivSym(nullptr);
Assert(boundCheckIndexSym);
}
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
3,
_u("Found upper bound (s%u + %d) in block %u\n"),
boundCheckIndexSym->m_id,
upperBoundOffset,
upperBoundCheck->Block()->GetBlockNum());
upperHoistInfo.SetCompatibleBoundCheck(
upperBoundCheck->Block(),
boundCheckIndexSym,
-1 - upperBoundOffset,
upperHoistBlockIndexValueNumber);
Assert(!searchingUpper);
needUpperBoundCheck = false;
if(!needLowerBoundCheck)
{
return;
}
}
Assert(needLowerBoundCheck || needUpperBoundCheck);
Assert(!needLowerBoundCheck || !lowerHoistInfo.CompatibleBoundCheckBlock());
Assert(!needUpperBoundCheck || !upperHoistInfo.CompatibleBoundCheckBlock());
}
if(!currentLoop)
{
return;
}
// Check if the index sym is invariant in the loop, or if the index value in the landing pad is a lower/upper bound of the
// index value in the current block
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 2, _u("Looking for invariant index or index bounded by itself\n"));
bool searchingLower = needLowerBoundCheck, searchingUpper = needUpperBoundCheck;
for(Loop *loop = currentLoop; loop; loop = loop->parent)
{
GlobOptBlockData &landingPadBlockData = loop->landingPad->globOptData;
GlobHashTable *const landingPadSymToValueMap = landingPadBlockData.symToValueMap;
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
3,
_u("Trying loop %u landing pad block %u\n"),
loop->GetLoopNumber(),
loop->landingPad->GetBlockNum());
Value *const landingPadIndexValue = FindValue(landingPadSymToValueMap, indexSym);
if(!landingPadIndexValue)
{
break;
}
IntConstantBounds landingPadIndexConstantBounds;
const bool landingPadIndexValueIsLikelyInt =
landingPadIndexValue->GetValueInfo()->TryGetIntConstantBounds(&landingPadIndexConstantBounds, true);
int lowerOffset = 0, upperOffset = 0;
if(indexValue->GetValueNumber() == landingPadIndexValue->GetValueNumber())
{
Assert(landingPadIndexValueIsLikelyInt);
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Index is invariant\n"));
}
else
{
if(!landingPadIndexValueIsLikelyInt)
{
break;
}
if(searchingLower)
{
if(lowerHoistInfo.Loop() && indexValue->GetValueNumber() == lowerHoistInfo.IndexValueNumber())
{
// Prefer using the invariant sym
needLowerBoundCheck = searchingLower = false;
if(!needUpperBoundCheck)
{
return;
}
if(!searchingUpper)
{
break;
}
}
else
{
bool foundBound = false;
if(indexBounds)
{
const ValueRelativeOffset *bound;
if(indexBounds->RelativeLowerBounds().TryGetReference(landingPadIndexValue->GetValueNumber(), &bound))
{
foundBound = true;
lowerOffset = bound->Offset();
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
4,
_u("Found lower bound (index + %d)\n"),
lowerOffset);
}
}
if(!foundBound)
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Lower bound was not found\n"));
searchingLower = false;
if(!searchingUpper)
{
break;
}
}
}
}
if(searchingUpper)
{
if(upperHoistInfo.Loop() && indexValue->GetValueNumber() == upperHoistInfo.IndexValueNumber())
{
// Prefer using the invariant sym
needUpperBoundCheck = searchingUpper = false;
if(!needLowerBoundCheck)
{
return;
}
if(!searchingLower)
{
break;
}
}
else
{
bool foundBound = false;
if(indexBounds)
{
const ValueRelativeOffset *bound;
if(indexBounds->RelativeUpperBounds().TryGetReference(landingPadIndexValue->GetValueNumber(), &bound))
{
foundBound = true;
upperOffset = bound->Offset();
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
4,
_u("Found upper bound (index + %d)\n"),
upperOffset);
}
}
if(!foundBound)
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Upper bound was not found\n"));
searchingUpper = false;
if(!searchingLower)
{
break;
}
}
}
}
}
if(searchingLower)
{
if(ValueInfo::IsLessThan(
landingPadIndexValue,
landingPadIndexConstantBounds.LowerBound(),
landingPadIndexConstantBounds.UpperBound(),
nullptr,
0,
0))
{
// index < 0 in the landing pad; can't use the index sym
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 5, _u("Index < 0\n"));
searchingLower = false;
if(!searchingUpper)
{
break;
}
}
else
{
lowerHoistInfo.SetLoop(
loop,
indexSym,
lowerOffset,
landingPadIndexValue,
landingPadIndexConstantBounds);
}
}
if(!searchingUpper)
{
continue;
}
// Check if the head segment length sym is available in the landing pad
Value *const landingPadHeadSegmentLengthValue = FindValue(landingPadSymToValueMap, headSegmentLengthSym);
if(!landingPadHeadSegmentLengthValue)
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 5, _u("Head segment length is not invariant\n"));
searchingUpper = false;
if(!searchingLower)
{
break;
}
continue;
}
IntConstantBounds landingPadHeadSegmentLengthConstantBounds;
AssertVerify(
landingPadHeadSegmentLengthValue
->GetValueInfo()
->TryGetIntConstantBounds(&landingPadHeadSegmentLengthConstantBounds));
if(ValueInfo::IsGreaterThanOrEqualTo(
landingPadIndexValue,
landingPadIndexConstantBounds.LowerBound(),
landingPadIndexConstantBounds.UpperBound(),
landingPadHeadSegmentLengthValue,
landingPadHeadSegmentLengthConstantBounds.LowerBound(),
landingPadHeadSegmentLengthConstantBounds.UpperBound()))
{
// index >= headSegmentLength in the landing pad; can't use the index sym
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 5, _u("Index >= head segment length\n"));
searchingUpper = false;
if(!searchingLower)
{
break;
}
continue;
}
// We need:
// boundBase + boundOffset < headSegmentLength
// Normalize the offset such that:
// boundBase <= headSegmentLength + offset
// Where (offset = -1 - boundOffset), and -1 is to simulate < instead of <=.
upperOffset = -1 - upperOffset;
upperHoistInfo.SetLoop(
loop,
indexSym,
upperOffset,
landingPadIndexValue,
landingPadIndexConstantBounds,
landingPadHeadSegmentLengthValue,
landingPadHeadSegmentLengthConstantBounds);
}
if(needLowerBoundCheck && lowerHoistInfo.Loop())
{
needLowerBoundCheck = false;
if(!needUpperBoundCheck)
{
return;
}
}
if(needUpperBoundCheck && upperHoistInfo.Loop())
{
needUpperBoundCheck = false;
if(!needLowerBoundCheck)
{
return;
}
}
// Find an invariant lower/upper bound of the index that can be used for hoisting the bound checks
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 2, _u("Looking for invariant index bounds\n"));
searchingLower = needLowerBoundCheck;
searchingUpper = needUpperBoundCheck;
for(Loop *loop = currentLoop; loop; loop = loop->parent)
{
GlobOptBlockData &landingPadBlockData = loop->landingPad->globOptData;
GlobHashTable *const landingPadSymToValueMap = landingPadBlockData.symToValueMap;
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
3,
_u("Trying loop %u landing pad block %u\n"),
loop->GetLoopNumber(),
loop->landingPad->GetBlockNum());
Value *landingPadHeadSegmentLengthValue = nullptr;
IntConstantBounds landingPadHeadSegmentLengthConstantBounds;
if(searchingUpper)
{
// Check if the head segment length sym is available in the landing pad
landingPadHeadSegmentLengthValue = FindValue(landingPadSymToValueMap, headSegmentLengthSym);
if(landingPadHeadSegmentLengthValue)
{
AssertVerify(
landingPadHeadSegmentLengthValue
->GetValueInfo()
->TryGetIntConstantBounds(&landingPadHeadSegmentLengthConstantBounds));
}
else
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Head segment length is not invariant\n"));
searchingUpper = false;
if(!searchingLower)
{
break;
}
}
}
// Look for a relative bound
if(indexBounds)
{
for(int j = 0; j < 2; ++j)
{
const bool searchingRelativeLowerBounds = j == 0;
if(!(searchingRelativeLowerBounds ? searchingLower : searchingUpper))
{
continue;
}
for(auto it =
(
searchingRelativeLowerBounds
? indexBounds->RelativeLowerBounds()
: indexBounds->RelativeUpperBounds()
).GetIterator();
it.IsValid();
it.MoveNext())
{
const ValueRelativeOffset &indexBound = it.CurrentValue();
StackSym *const indexBoundBaseSym = indexBound.BaseSym();
if(!indexBoundBaseSym)
{
continue;
}
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
4,
_u("Found %S bound (s%u + %d)\n"),
searchingRelativeLowerBounds ? "lower" : "upper",
indexBoundBaseSym->m_id,
indexBound.Offset());
if(!indexBound.WasEstablishedExplicitly())
{
// Don't use a bound that was not established explicitly, as it may be too aggressive. For instance, an
// index sym used in an array will obtain an upper bound of the array's head segment length - 1. That
// bound is not established explicitly because the bound assertion is not enforced by the source code.
// Rather, it is assumed and enforced by the JIT using bailout check. Incrementing the index and using
// it in a different array may otherwise cause it to use the first array's head segment length as the
// upper bound on which to do the bound check against the second array, and that bound check would
// always fail when the arrays are the same size.
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 5, _u("Bound was established implicitly\n"));
continue;
}
Value *const landingPadIndexBoundBaseValue = FindValue(landingPadSymToValueMap, indexBoundBaseSym);
if(!landingPadIndexBoundBaseValue ||
landingPadIndexBoundBaseValue->GetValueNumber() != indexBound.BaseValueNumber())
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 5, _u("Bound is not invariant\n"));
continue;
}
IntConstantBounds landingPadIndexBoundBaseConstantBounds;
AssertVerify(
landingPadIndexBoundBaseValue
->GetValueInfo()
->TryGetIntConstantBounds(&landingPadIndexBoundBaseConstantBounds, true));
int offset = indexBound.Offset();
if(searchingRelativeLowerBounds)
{
if(offset == IntConstMin ||
ValueInfo::IsLessThan(
landingPadIndexBoundBaseValue,
landingPadIndexBoundBaseConstantBounds.LowerBound(),
landingPadIndexBoundBaseConstantBounds.UpperBound(),
nullptr,
-offset,
-offset))
{
// indexBoundBase + indexBoundOffset < 0; can't use this bound
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 5, _u("Bound < 0\n"));
continue;
}
lowerHoistInfo.SetLoop(
loop,
indexBoundBaseSym,
offset,
landingPadIndexBoundBaseValue,
landingPadIndexBoundBaseConstantBounds);
break;
}
if(ValueInfo::IsLessThanOrEqualTo(
landingPadHeadSegmentLengthValue,
landingPadHeadSegmentLengthConstantBounds.LowerBound(),
landingPadHeadSegmentLengthConstantBounds.UpperBound(),
landingPadIndexBoundBaseValue,
landingPadIndexBoundBaseConstantBounds.LowerBound(),
landingPadIndexBoundBaseConstantBounds.UpperBound(),
offset))
{
// indexBoundBase + indexBoundOffset >= headSegmentLength; can't use this bound
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 5, _u("Bound >= head segment length\n"));
continue;
}
// We need:
// boundBase + boundOffset < headSegmentLength
// Normalize the offset such that:
// boundBase <= headSegmentLength + offset
// Where (offset = -1 - boundOffset), and -1 is to simulate < instead of <=.
offset = -1 - offset;
upperHoistInfo.SetLoop(
loop,
indexBoundBaseSym,
offset,
landingPadIndexBoundBaseValue,
landingPadIndexBoundBaseConstantBounds,
landingPadHeadSegmentLengthValue,
landingPadHeadSegmentLengthConstantBounds);
break;
}
}
}
if(searchingLower && lowerHoistInfo.Loop() != loop)
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Lower bound was not found\n"));
searchingLower = false;
if(!searchingUpper)
{
break;
}
}
if(searchingUpper && upperHoistInfo.Loop() != loop)
{
// No useful relative bound found; look for a constant bound if the index is an induction variable. Exclude constant
// bounds of non-induction variables because those bounds may have been established through means other than a loop
// exit condition, such as math or bitwise operations. Exclude constant bounds established implicitly by <,
// <=, >, and >=. For example, for a loop condition (i < n - 1), if 'n' is not invariant and hence can't be used,
// 'i' will still have a constant upper bound of (int32 max - 2) that should be excluded.
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Relative upper bound was not found\n"));
const InductionVariable *indexInductionVariable;
if(!upperHoistInfo.Loop() &&
currentLoop->inductionVariables &&
currentLoop->inductionVariables->TryGetReference(indexSym->m_id, &indexInductionVariable) &&
indexInductionVariable->IsChangeDeterminate())
{
if(!(indexBounds && indexBounds->WasConstantUpperBoundEstablishedExplicitly()))
{
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
4,
_u("Constant upper bound was established implicitly\n"));
}
else
{
// See if a compatible bound check is already available
const int indexConstantBound = indexBounds->ConstantUpperBound();
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
4,
_u("Found constant upper bound %d, looking for a compatible bound check\n"),
indexConstantBound);
const IntBoundCheck *boundCheck;
if(blockData.availableIntBoundChecks->TryGetReference(
IntBoundCheckCompatibilityId(ZeroValueNumber, headSegmentLengthValue->GetValueNumber()),
&boundCheck))
{
// We need:
// indexConstantBound < headSegmentLength
// Normalize the offset such that:
// 0 <= headSegmentLength + compatibleBoundCheckOffset
// Where (compatibleBoundCheckOffset = -1 - indexConstantBound), and -1 is to simulate < instead of <=.
const int compatibleBoundCheckOffset = -1 - indexConstantBound;
if(boundCheck->SetBoundOffset(compatibleBoundCheckOffset))
{
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
5,
_u("Found in block %u\n"),
boundCheck->Block()->GetBlockNum());
upperHoistInfo.SetCompatibleBoundCheck(boundCheck->Block(), indexConstantBound);
needUpperBoundCheck = searchingUpper = false;
if(!needLowerBoundCheck)
{
return;
}
if(!searchingLower)
{
break;
}
}
else
{
failedToUpdateCompatibleUpperBoundCheck = true;
}
}
if(searchingUpper)
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 5, _u("Not found\n"));
upperHoistInfo.SetLoop(
loop,
indexConstantBound,
landingPadHeadSegmentLengthValue,
landingPadHeadSegmentLengthConstantBounds);
}
}
}
else if(!upperHoistInfo.Loop())
{
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
4,
_u("Index is not an induction variable, not using constant upper bound\n"));
}
if(searchingUpper && upperHoistInfo.Loop() != loop)
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Upper bound was not found\n"));
searchingUpper = false;
if(!searchingLower)
{
break;
}
}
}
}
if(needLowerBoundCheck && lowerHoistInfo.Loop())
{
needLowerBoundCheck = false;
if(!needUpperBoundCheck)
{
return;
}
}
if(needUpperBoundCheck && upperHoistInfo.Loop())
{
needUpperBoundCheck = false;
if(!needLowerBoundCheck)
{
return;
}
}
// Try to use the loop count to calculate a missing lower/upper bound that in turn can be used for hoisting a bound check
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
2,
_u("Looking for loop count based bound for loop %u landing pad block %u\n"),
currentLoop->GetLoopNumber(),
currentLoop->landingPad->GetBlockNum());
LoopCount *const loopCount = currentLoop->loopCount;
if(!loopCount)
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 3, _u("Loop was not counted\n"));
return;
}
const InductionVariable *indexInductionVariable;
if(!currentLoop->inductionVariables ||
!currentLoop->inductionVariables->TryGetReference(indexSym->m_id, &indexInductionVariable) ||
!indexInductionVariable->IsChangeDeterminate())
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 3, _u("Index is not an induction variable\n"));
return;
}
// Determine the maximum-magnitude change per iteration, and verify that the change is reasonably finite
Assert(indexInductionVariable->IsChangeUnidirectional());
GlobOptBlockData &landingPadBlockData = currentLoop->landingPad->globOptData;
GlobHashTable *const landingPadSymToValueMap = currentLoop->landingPad->globOptData.symToValueMap;
int maxMagnitudeChange = indexInductionVariable->ChangeBounds().UpperBound();
Value *landingPadHeadSegmentLengthValue;
IntConstantBounds landingPadHeadSegmentLengthConstantBounds;
if(maxMagnitudeChange > 0)
{
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
3,
_u("Index's maximum-magnitude change per iteration is %d\n"),
maxMagnitudeChange);
if(!needUpperBoundCheck || maxMagnitudeChange > InductionVariable::ChangeMagnitudeLimitForLoopCountBasedHoisting)
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Change magnitude is too large\n"));
return;
}
// Check whether the head segment length is available in the landing pad
landingPadHeadSegmentLengthValue = FindValue(landingPadSymToValueMap, headSegmentLengthSym);
Assert(!headSegmentLengthInvariantLoop || landingPadHeadSegmentLengthValue);
if(!landingPadHeadSegmentLengthValue)
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 3, _u("Head segment length is not invariant\n"));
return;
}
AssertVerify(
landingPadHeadSegmentLengthValue
->GetValueInfo()
->TryGetIntConstantBounds(&landingPadHeadSegmentLengthConstantBounds));
}
else
{
maxMagnitudeChange = indexInductionVariable->ChangeBounds().LowerBound();
Assert(maxMagnitudeChange < 0);
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
3,
_u("Index's maximum-magnitude change per iteration is %d\n"),
maxMagnitudeChange);
if(!needLowerBoundCheck || maxMagnitudeChange < -InductionVariable::ChangeMagnitudeLimitForLoopCountBasedHoisting)
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Change magnitude is too large\n"));
return;
}
landingPadHeadSegmentLengthValue = nullptr;
}
// Determine if the index already changed in the loop, and by how much
int indexOffset;
StackSym *indexSymToAdd;
if(DetermineSymBoundOffsetOrValueRelativeToLandingPad(
indexSym,
maxMagnitudeChange >= 0,
indexValueInfo,
indexBounds,
currentLoop->landingPad->globOptData.symToValueMap,
&indexOffset))
{
// The bound value is constant
indexSymToAdd = nullptr;
}
else
{
// The bound value is not constant, the offset needs to be added to the index sym in the landing pad
indexSymToAdd = indexSym;
}
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 3, _u("Index's offset from landing pad is %d\n"), indexOffset);
// The secondary induction variable bound is computed as follows:
// bound = index + indexOffset + loopCountMinusOne * maxMagnitudeChange
//
// If the loop count is constant, (inductionVariableOffset + loopCount * maxMagnitudeChange) can be folded into an offset:
// bound = index + offset
int offset;
StackSym *indexLoopCountBasedBoundBaseSym;
Value *indexLoopCountBasedBoundBaseValue;
IntConstantBounds indexLoopCountBasedBoundBaseConstantBounds;
bool generateLoopCountBasedIndexBound;
if(!loopCount->HasBeenGenerated() || loopCount->LoopCountMinusOneSym())
{
if(loopCount->HasBeenGenerated())
{
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
3,
_u("Loop count is assigned to s%u\n"),
loopCount->LoopCountMinusOneSym()->m_id);
}
else
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 3, _u("Loop count has not been generated yet\n"));
}
offset = indexOffset;
// Check if there is already a loop count based bound sym for the index. If not, generate it.
do
{
const SymID indexSymId = indexSym->m_id;
SymIdToStackSymMap *&loopCountBasedBoundBaseSyms = currentLoop->loopCountBasedBoundBaseSyms;
if(!loopCountBasedBoundBaseSyms)
{
loopCountBasedBoundBaseSyms = JitAnew(alloc, SymIdToStackSymMap, alloc);
}
else if(loopCountBasedBoundBaseSyms->TryGetValue(indexSymId, &indexLoopCountBasedBoundBaseSym))
{
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
3,
_u("Loop count based bound is assigned to s%u\n"),
indexLoopCountBasedBoundBaseSym->m_id);
indexLoopCountBasedBoundBaseValue = FindValue(landingPadSymToValueMap, indexLoopCountBasedBoundBaseSym);
Assert(indexLoopCountBasedBoundBaseValue);
AssertVerify(
indexLoopCountBasedBoundBaseValue
->GetValueInfo()
->TryGetIntConstantBounds(&indexLoopCountBasedBoundBaseConstantBounds));
generateLoopCountBasedIndexBound = false;
break;
}
indexLoopCountBasedBoundBaseSym = StackSym::New(TyInt32, func);
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
3,
_u("Assigning s%u to the loop count based bound\n"),
indexLoopCountBasedBoundBaseSym->m_id);
loopCountBasedBoundBaseSyms->Add(indexSymId, indexLoopCountBasedBoundBaseSym);
indexLoopCountBasedBoundBaseValue = NewValue(ValueInfo::New(alloc, ValueType::GetInt(true)));
SetValue(&landingPadBlockData, indexLoopCountBasedBoundBaseValue, indexLoopCountBasedBoundBaseSym);
indexLoopCountBasedBoundBaseConstantBounds = IntConstantBounds(IntConstMin, IntConstMax);
generateLoopCountBasedIndexBound = true;
} while(false);
}
else
{
// The loop count is constant, fold (indexOffset + loopCountMinusOne * maxMagnitudeChange)
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 3, _u("Loop count is constant, folding\n"));
if(Int32Math::Mul(loopCount->LoopCountMinusOneConstantValue(), maxMagnitudeChange, &offset) ||
Int32Math::Add(offset, indexOffset, &offset))
{
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Folding failed\n"));
return;
}
if(!indexSymToAdd)
{
// The loop count based bound is constant
const int loopCountBasedConstantBound = offset;
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
3,
_u("Loop count based bound is constant: %d\n"),
loopCountBasedConstantBound);
if(maxMagnitudeChange < 0)
{
if(loopCountBasedConstantBound < 0)
{
// Can't use this bound
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Bound < 0\n"));
return;
}
lowerHoistInfo.SetLoop(currentLoop, loopCountBasedConstantBound, true);
return;
}
// loopCountBasedConstantBound >= headSegmentLength is currently not possible, except when
// loopCountBasedConstantBound == int32 max
Assert(
loopCountBasedConstantBound == IntConstMax ||
!ValueInfo::IsGreaterThanOrEqualTo(
nullptr,
loopCountBasedConstantBound,
loopCountBasedConstantBound,
landingPadHeadSegmentLengthValue,
landingPadHeadSegmentLengthConstantBounds.LowerBound(),
landingPadHeadSegmentLengthConstantBounds.UpperBound()));
// See if a compatible bound check is already available
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 3, _u("Looking for a compatible bound check\n"));
const IntBoundCheck *boundCheck;
if(blockData.availableIntBoundChecks->TryGetReference(
IntBoundCheckCompatibilityId(ZeroValueNumber, headSegmentLengthValue->GetValueNumber()),
&boundCheck))
{
// We need:
// loopCountBasedConstantBound < headSegmentLength
// Normalize the offset such that:
// 0 <= headSegmentLength + compatibleBoundCheckOffset
// Where (compatibleBoundCheckOffset = -1 - loopCountBasedConstantBound), and -1 is to simulate < instead of <=.
const int compatibleBoundCheckOffset = -1 - loopCountBasedConstantBound;
if(boundCheck->SetBoundOffset(compatibleBoundCheckOffset, true))
{
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
4,
_u("Found in block %u\n"),
boundCheck->Block()->GetBlockNum());
upperHoistInfo.SetCompatibleBoundCheck(boundCheck->Block(), loopCountBasedConstantBound);
return;
}
failedToUpdateCompatibleUpperBoundCheck = true;
}
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Not found\n"));
upperHoistInfo.SetLoop(
currentLoop,
loopCountBasedConstantBound,
landingPadHeadSegmentLengthValue,
landingPadHeadSegmentLengthConstantBounds,
true);
return;
}
// The loop count based bound is not constant; we need to add the offset of the index sym in the landing pad. Instead
// of adding though, we will treat the index sym as the loop count based bound base sym and adjust the offset that will
// be used in the bound check itself.
indexLoopCountBasedBoundBaseSym = indexSymToAdd;
indexLoopCountBasedBoundBaseValue = FindValue(landingPadSymToValueMap, indexSymToAdd);
Assert(indexLoopCountBasedBoundBaseValue);
AssertVerify(
indexLoopCountBasedBoundBaseValue
->GetValueInfo()
->TryGetIntConstantBounds(&indexLoopCountBasedBoundBaseConstantBounds));
generateLoopCountBasedIndexBound = false;
}
if(maxMagnitudeChange >= 0)
{
// We need:
// indexLoopCountBasedBoundBase + indexOffset < headSegmentLength
// Normalize the offset such that:
// indexLoopCountBasedBoundBase <= headSegmentLength + offset
// Where (offset = -1 - indexOffset), and -1 is to simulate < instead of <=.
offset = -1 - offset;
}
if(!generateLoopCountBasedIndexBound)
{
if(maxMagnitudeChange < 0)
{
if(offset != IntConstMax &&
ValueInfo::IsGreaterThanOrEqualTo(
nullptr,
0,
0,
indexLoopCountBasedBoundBaseValue,
indexLoopCountBasedBoundBaseConstantBounds.LowerBound(),
indexLoopCountBasedBoundBaseConstantBounds.UpperBound(),
offset + 1)) // + 1 to simulate > instead of >=
{
// loopCountBasedBound < 0, can't use this bound
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Bound < 0\n"));
return;
}
}
else if(
ValueInfo::IsGreaterThanOrEqualTo(
indexLoopCountBasedBoundBaseValue,
indexLoopCountBasedBoundBaseConstantBounds.LowerBound(),
indexLoopCountBasedBoundBaseConstantBounds.UpperBound(),
landingPadHeadSegmentLengthValue,
landingPadHeadSegmentLengthConstantBounds.LowerBound(),
landingPadHeadSegmentLengthConstantBounds.UpperBound(),
offset))
{
// loopCountBasedBound >= headSegmentLength, can't use this bound
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Bound >= head segment length\n"));
return;
}
// See if a compatible bound check is already available
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 3, _u("Looking for a compatible bound check\n"));
const ValueNumber indexLoopCountBasedBoundBaseValueNumber = indexLoopCountBasedBoundBaseValue->GetValueNumber();
const IntBoundCheck *boundCheck;
if(blockData.availableIntBoundChecks->TryGetReference(
maxMagnitudeChange < 0
? IntBoundCheckCompatibilityId(
ZeroValueNumber,
indexLoopCountBasedBoundBaseValueNumber)
: IntBoundCheckCompatibilityId(
indexLoopCountBasedBoundBaseValueNumber,
headSegmentLengthValue->GetValueNumber()),
&boundCheck))
{
if(boundCheck->SetBoundOffset(offset, true))
{
TRACE_PHASE_VERBOSE(
Js::Phase::BoundCheckHoistPhase,
4,
_u("Found in block %u\n"),
boundCheck->Block()->GetBlockNum());
if(maxMagnitudeChange < 0)
{
lowerHoistInfo.SetCompatibleBoundCheck(
boundCheck->Block(),
indexLoopCountBasedBoundBaseSym,
offset,
indexLoopCountBasedBoundBaseValueNumber);
}
else
{
upperHoistInfo.SetCompatibleBoundCheck(
boundCheck->Block(),
indexLoopCountBasedBoundBaseSym,
offset,
indexLoopCountBasedBoundBaseValueNumber);
}
return;
}
(maxMagnitudeChange < 0 ? failedToUpdateCompatibleLowerBoundCheck : failedToUpdateCompatibleUpperBoundCheck) = true;
}
TRACE_PHASE_VERBOSE(Js::Phase::BoundCheckHoistPhase, 4, _u("Not found\n"));
}
if(maxMagnitudeChange < 0)
{
lowerHoistInfo.SetLoop(
currentLoop,
indexLoopCountBasedBoundBaseSym,
offset,
indexLoopCountBasedBoundBaseValue,
indexLoopCountBasedBoundBaseConstantBounds,
true);
if(generateLoopCountBasedIndexBound)
{
lowerHoistInfo.SetLoopCount(loopCount, maxMagnitudeChange);
}
return;
}
upperHoistInfo.SetLoop(
currentLoop,
indexLoopCountBasedBoundBaseSym,
offset,
indexLoopCountBasedBoundBaseValue,
indexLoopCountBasedBoundBaseConstantBounds,
landingPadHeadSegmentLengthValue,
landingPadHeadSegmentLengthConstantBounds,
true);
if(generateLoopCountBasedIndexBound)
{
upperHoistInfo.SetLoopCount(loopCount, maxMagnitudeChange);
}
}
| [
"[email protected]"
] | |
c718c9a9fde25277994283393c12471b6b3db259 | ba57cc4a44f5c5d3d8dc4d846f4437741b6fe7c5 | /Rock.cpp | 7eaae870092aa15c4261d4f72069bd8e0f20c296 | [] | no_license | gjstnqkr/BalloonBurster_class | a5dfdac16c24b75d94506e27d63769c8bad660b0 | 4bec43451b0affd72d76ecc79d022d7dd400e5c9 | refs/heads/master | 2023-07-29T05:24:53.669821 | 2021-09-08T14:51:23 | 2021-09-08T14:51:23 | 404,392,889 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,418 | cpp | #include "Rock.h"
#include "HelloworldScene.h"
using namespace cocos2d;
Rock::Rock()
: m_pParentBM(NULL)
, m_RockState(emRockState::Rock_Standby)
{
}
Rock::~Rock()
{
}
Rock* Rock::create(Vec2 _Pos)
{
Rock *sprite = new (std::nothrow) Rock();
if (sprite && sprite->initWithFile("rock.png"))
{
sprite->init_Cocos2dInfo(_Pos);
sprite->autorelease();
return sprite;
}
CC_SAFE_DELETE(sprite);
return nullptr;
}
void Rock::init_Cocos2dInfo(Vec2 _Pos)
{
PhysicsBody* pbody_Balloon = PhysicsBody::createBox(this->getContentSize(), BASIC_MATERIAL);
pbody_Balloon->setContactTestBitmask(0xFFFFFFFF);
pbody_Balloon->setDynamic(false);
this->setPhysicsBody(pbody_Balloon);
this->setPosition(_Pos);
this->setTag(emNameTag::PROJECTTILE);
this->getPhysicsBody()->setGravityEnable(true);
this->setScale(1.0);
}
void Rock::Thrown_Rock(float fDist)
{
this->setVisible(true);
BalloonMaker* pBM = dynamic_cast<BalloonMaker*>(this->getParent());
HelloWorld* pHello = dynamic_cast<HelloWorld*>(this->getParent()->getParent());
removeFromParentAndCleanup(false);
//pBM->eraseRockInList(this);
this->setPosition(pBM->getPosition());
if (pHello == NULL) return;
pHello->addChild(this);
this->setScale(1.0);
//
PhysicsMaterial PhyMat = PhysicsMaterial(1.0f, 0.0f, 1.0f);
PhysicsBody* pbody_Dart = PhysicsBody::createBox(this->getContentSize(), PhyMat);
pbody_Dart->setDynamic(true);
pbody_Dart->setContactTestBitmask(0xFFFFFFFF);
pbody_Dart->applyForce(Vec2(0.0f, 500.0f));
pbody_Dart->setVelocity(Vec2(-160, 80));
this->setPhysicsBody(pbody_Dart);
set_RockState(emRockState::Rock_Throwing);
Call_FuncAfterFewTime(schedule_selector(Rock::explode_Rock), 15.0f);
}
void Rock::explode_Rock(float _dt)
{
set_RockState(emRockState::Rock_explode);
this->stopAllActions();
auto Action = cocos2d::ScaleBy::create(0.3, 4.0f);
auto Action2 = cocos2d::FadeOut::create(0.3f);
this->runAction(Action);
this->runAction(Action2);
removeFromParentAndCleanup(true);
}
void Rock::set_BalloonMaker(BalloonMaker * pArcher)
{
m_pParentBM = pArcher;
}
BalloonMaker * Rock::get_BalloonMaker()
{
return m_pParentBM;
}
void Rock::set_RockState(emRockState _RockState)
{
m_RockState = _RockState;
}
emRockState Rock::get_RockState()
{
return m_RockState;
}
void Rock::Call_FuncAfterFewTime(void(Ref::*SEL_SCHEDULE)(float), float _fSec)
{
this->scheduleOnce(SEL_SCHEDULE, _fSec);
}
| [
"[email protected]"
] | |
67e233560dba7d17bbb13ff0f0332a99f89046a5 | 9dc8db73618cb7acb602e966bc6bf9c82a4717d8 | /simulator/Simulator.h | d60daada9d15d41e976d08ded6dc37211d2ff32a | [] | no_license | Maribib/OS1 | 9fb3995dde58c58c7f1d1a468b44dac90bb923b3 | 55cee1550d6c56b51926f1c7521b60293a53864c | refs/heads/master | 2021-01-20T11:13:04.911817 | 2015-12-11T21:58:09 | 2015-12-11T21:58:09 | 47,415,050 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,056 | h | /*
* Simulator.h
*
* Created on: 5 déc. 2015
* Author: julianschembri
*/
#ifndef SIMULATOR_SIMULATOR_H_
#define SIMULATOR_SIMULATOR_H_
#include <vector>
#include <string>
#include "../datastructure/Task.h"
#include "../pattern/Observable.h"
#include "Ram.h"
#include "SwapMem.h"
class Simulator : public Observable {
public:
Simulator(std::vector<Task>, int, int);
int simulate(bool = true);
Task* getCurrentTask() { return highestPriorityTask; };
int getPreemptionCpt() { return preemptionCpt; };
int getIdleTime() { return idleTime; };
int getSwapTime() { return swapTime; };
float getUtilization() { return utilization; }
int getSwapCpt() { return swapCpt; };
float getSysLoad() { return float(simEnd-idleTime)/simEnd; };
int getSimLength() { return simEnd; };
std::vector<Task>* getTasks() { return &tasks; };
virtual ~Simulator();
private:
float computeUtilisation();
bool meetDeadline(int,Task*);
bool meetAllDeadline(std::vector<Task*>*,int);
bool run(std::vector<Task*>*,int,int,Task* = NULL);
void clean(std::vector<Task*>*);
int gcd(int, int);
int lcm(int, int);
bool setPriorities(bool = true);
void swapPage(int victim, int id);
void swapInOutDelay();
void loadPages(std::vector<Task*>*);
void increaseAllTaskLastUse(std::vector<Task*>*);
Task* taskReleased(std::vector<Task*>*,int,Task*);
bool allPagesInRam(int);
void loadAPage(int);
int findVictim(std::vector<Task*>*,int);
Task* getHighestPriorityTask();
int computeIntervalEnd();
void executeProgram(std::vector<Task*>*,Task*);
void handleLoadOrSwap(std::vector<Task*>*,Task*);
void display(int,Task*);
bool isPreemption(Task*, Task*);
bool eventOccures(int,int,int);
int computeStudyIntervalEnd(std::vector<Task*>*);
bool audsley(std::vector<Task*>*);
int lowestPriorityViable(std::vector<Task*>*);
std::vector<Task> tasks;
int loadTime;
Ram ram;
SwapMem swapMem;
int simEnd;
int preemptionCpt;
int idleTime;
int swapTime;
float utilization;
int swapCpt;
Task* highestPriorityTask;
};
#endif /* SIMULATOR_SIMULATOR_H_ */
| [
"[email protected]"
] | |
ace8fc4e26b129c32caaef277eb4fb4075d264bf | b6c985bd9f493135c4de109f3ad78d38a3059c65 | /src/gvar_module/image/image_listofimages.h | 1484fd70aa45ecbfb8a02bd9618b8639b6c57e2a | [] | no_license | qjhart/qjhart.geostreams | 4a80d85912cb6cdfb004017c841e3902f898fad5 | 7d5ec6a056ce43d2250553b99c7559f15db1d5fb | refs/heads/master | 2021-01-10T18:46:48.653526 | 2015-03-19T00:13:33 | 2015-03-19T00:13:33 | 32,489,398 | 1 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 720 | h | /**
* Defines the data structure for Image_ListofImages.
*
* @author jzhang - created on Apr 26, 2004
*/
#ifndef IMAGE_LISTOFIMAGES_H
#define IMAGE_LISTOFIMAGES_H
#include <list>
#include "image/image.h"
template <class pointType, class TIMESTAMP, class valueType>
class Image_ListofImages {
private:
std::list<Image<pointType, TIMESTAMP, valueType>* >* imageList ;
public:
Image_ListofImages () ;
void append (Image<pointType, TIMESTAMP, valueType> * image) ;
pointType getLowX () ;
pointType getHighX () ;
pointType getLowY () ;
pointType getHighY () ;
int numOfRows () ;
valueType** getData () ;
int getRowSize () ;
void print () ;
} ;
#include "image/image_listofimages.cpp"
#endif
| [
"[email protected]"
] | |
d6824707d94677e525d7d9e70114e073e5b838a7 | cf8ddfc720bf6451c4ef4fa01684327431db1919 | /SDK/ARKSurvivalEvolved_Structure_TaxidermyBase_Small_classes.hpp | 073030bf1036d6861acbab593a09a22e949d7ddc | [
"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 | 890 | hpp | #pragma once
// ARKSurvivalEvolved (329.9) SDK
#ifdef _MSC_VER
#pragma pack(push, 0x8)
#endif
#include "ARKSurvivalEvolved_Structure_TaxidermyBase_Small_structs.hpp"
namespace sdk
{
//---------------------------------------------------------------------------
//Classes
//---------------------------------------------------------------------------
// BlueprintGeneratedClass Structure_TaxidermyBase_Small.Structure_TaxidermyBase_Small_C
// 0x0000 (0x0F11 - 0x0F11)
class AStructure_TaxidermyBase_Small_C : public AStructure_TaxidermyBase_C
{
public:
static UClass* StaticClass()
{
static auto ptr = UObject::FindClass("BlueprintGeneratedClass Structure_TaxidermyBase_Small.Structure_TaxidermyBase_Small_C");
return ptr;
}
void UserConstructionScript();
void ExecuteUbergraph_Structure_TaxidermyBase_Small(int EntryPoint);
};
}
#ifdef _MSC_VER
#pragma pack(pop)
#endif
| [
"[email protected]"
] | |
1f78da77b29ab50736a99795399eefe6a64e508f | fe3d0999a411422fdc5ae8ab5631a5c170d1d962 | /acm/template/树剖模板.cpp | 3fb12df81f2bdf8709c2af2228fa46e454afc38a | [
"MIT"
] | permissive | randoruf/cpp | 7063feb1ea72d59902c5ad1b5f82ed161125a593 | c28bdb79ecb86f44a92971ac259910546dba29a7 | refs/heads/master | 2023-03-18T11:28:24.573297 | 2016-08-01T17:56:29 | 2016-08-01T17:56:29 | null | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,164 | cpp | #include<bits/stdc++.h>
using namespace std;
const int maxn = 100;
int head[maxn];//head[ i]表示edges中的edges[i]边的头节点
int cnt;
struct edge{
int to,next,cost;
}edges[2*maxn];
void addedge(int x,int y,int c){
edge &e = edges[cnt];
e.to = y;
e.next = head[x];
e.cost = c;
head[x]=cnt++;
}
int temp[maxn][3];//记录边值
int son[maxn];//重孩子
int val[maxn];//把边上的权值转移孩子点上的权值
int size[maxn];//子树大小
int id[maxn];//
int top[maxn];//重链顶端
int depth[maxn];//深度
int par[maxn];//父亲节点
int totw;
int bit[maxn];
void add(int i,int x){
while(i<=n+10){
bit[i]+=x;
i+= lowbit(i);
}
}
void dfs1(int u,int fa,int dep){
par[u] = fa;
depth[u] = dep;
int Max = 0,pos = -1;
size[u] = 1;
for(int j = head[u];j!=-1;j=edges[j].next){//遍历含u边的所有边
int v = edges[j].to,c = edges[j].cost;
if(v == fa)continue;
val[v] = c;//为什么把边的权值附给点？？导致树根没有权值就是转移的吧？？？！！！
dfs1(v,u,dep+1);
if(size[v]>Max){//记录最大的子树的大小，和节点
Max = size[v];
pos = v;
}
size[u]+= size[v];//求u的子树大小
}
son[u ] = pos;//重儿子节点
}
void dfs2(int u,int fa){
id[u] =++totw;
add(id[u],val[u]);
if(son[u]!=-1){//先搜重儿子然后再dfs
top[son[u]] = top[u];//向上转移top
dfs2(son[u],u);
}
for(int j = head[u];j!=-1;j = edges[j].next){
int v= edges[j].to,c = edges[j].cost;
if(v == fa||v == son[u])continue;
top[v ]= v;
dfs2(v,u);
}
}
int main(){
int T,ca = 1;
cin>>T;
while(T--){
memset(head,-1,sizeof(head));
cnt = 0;
int n,q;
scanf("%d%d",&n,&q);
for(int i = 0;i<n-1;i++){
int x,y;
scanf("%d%d",&x,&y);
x--;y--;
temp[i][0] = x;
temp[i][1] = y;
temp[i][2] = 0;
addedge(x,y,0);
addedge(y,x,0);
}
for(int i = 0;i<n;i++){cout<<head[i]<<endl;}
for(int i = 0;i<2*(n-1);i++){
cout<<edges[i].next<<edges[i].to<<endl;
}
totw = val[0] = top[0] = 0;
dfs1(0,-1,0);
dfs2(0,-1);
while(q--){
getchar();
string s;
cin>>s;
if(s[3] == '1'){
int x,y,c;
scanf("%d%d%d",&x,&y,&c);
}
}
}
}
| [
"[[email protected]]"
] | |
8edbef5673b81b9c0c75b58c3099fad2b34cca74 | 0b90d18bf8e2000d3c47a17f3403be51b4a8ecd8 | /src/Core/Skinner/Animation.h | 6637e8c175e898ea4cc5bcbebeaf96f70b5ba6bf | [
"MIT"
] | permissive | merced317/scirun4plus | c3d8d65dd68f9d119b43cf084ea8b9d94921ce33 | f29630e03d3cf13c0ce8b327676ad202e3981af0 | refs/heads/master | 2020-12-10T19:20:18.401161 | 2018-06-27T09:21:54 | 2018-06-27T09:21:54 | 233,683,375 | 0 | 0 | null | 2020-01-13T20:09:14 | 2020-01-13T20:09:13 | null | UTF-8 | C++ | false | false | 2,303 | h | //
// For more information, please see: http://software.sci.utah.edu
//
// The MIT License
//
// Copyright (c) 2009 Scientific Computing and Imaging Institute,
// University of Utah.
//
//
// Permission is hereby granted, free of charge, to any person obtaining a
// copy of this software and associated documentation files (the "Software"),
// to deal in the Software without restriction, including without limitation
// the rights to use, copy, modify, merge, publish, distribute, sublicense,
// and/or sell copies of the Software, and to permit persons to whom the
// Software is furnished to do so, subject to the following conditions:
//
// The above copyright notice and this permission notice shall be included
// in all copies or substantial portions of the Software.
//
// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS
// OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
// FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL
// THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
// LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
// FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
// DEALINGS IN THE SOFTWARE.
//
// File : Animation.h
// Author : McKay Davis
// Date : Tue Jul 4 17:47:07 2006
#ifndef SKINNER_ANIMATION_H
#define SKINNER_ANIMATION_H
#include <Core/Skinner/Parent.h>
namespace SCIRun {
namespace Skinner {
class Animation : public Parent {
public:
Animation (Variables *);
virtual ~Animation();
private:
CatcherFunction_t AnimateHeight;
CatcherFunction_t AnimateVariableDescending;
CatcherFunction_t AnimateVariable;
CatcherFunction_t AnimateVariable2;
CatcherFunction_t AnimateVariableAscending;
double variable_begin_;
double variable_end_;
int curvar_;
double start_time_;
double stop_time_;
bool at_start_;
bool ascending_;
TimeThrottle * timer_;
};
}
}
#endif
| [
"[email protected]"
] | |
314485319c96b510dead6099abccf3fed8956287 | 841df6c8c75bfe46bf8921da0fcbab115d608469 | /Functions/array_assign_template.cpp | 4c8aedcd567d718af36334cacb584c9c7a65fa35 | [] | no_license | jimpei8989/APCSC-2021 | d8066e3b61e2afd7498d6f96efc5467730c054fd | 417f7c1034b7bd331d87810d8e20698538380298 | refs/heads/master | 2023-07-10T22:48:01.315330 | 2021-08-10T03:10:29 | 2021-08-10T03:10:29 | 382,114,888 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 293 | cpp | #include <iostream>
void assign(int arr[], int n, int a, int b, int c) {
// Do something
}
int main() {
int arr[10], a, b, c;
std::cin >> a >> b >> c;
assign(arr, 10, a, b, c);
for (int i = 0; i < 10; i++) {
std::cout << arr[i] << (i == 9 ? '\n' : ' ');
}
}
| [
"[email protected]"
] | |
190485a2c9316599b834f4bbfd5c9901664ad17c | e628ac29319ffdfc13dd16500dcb1c21e34dfa0a | /42.알파블렌드/20210702_0/enemyManager.cpp | d7aadb1a4033606b31f8445e64dc3792dbf08a48 | [] | no_license | Rock-and-Stone/academyStorage | af6e211c83045df441abd7983f75c8f3785b1e47 | 23b989219488034ce7a4bec508e7642e852f62a1 | refs/heads/main | 2023-07-12T20:31:54.021002 | 2021-08-18T07:49:10 | 2021-08-18T07:49:10 | 397,496,199 | 0 | 0 | null | null | null | null | UHC | C++ | false | false | 1,996 | cpp | #include "pch.h"
#include "enemyManager.h"
#include "spaceShip.h"
enemyManager::enemyManager()
{
}
enemyManager::~enemyManager()
{
}
HRESULT enemyManager::init()
{
_bullet = new bullet;
_bullet->init("bullet", 30, 700); //총알이미지 키값, 총알맥스값, 사거리
return S_OK;
}
void enemyManager::release()
{
}
void enemyManager::update()
{
for (_viMinion = _vMinion.begin(); _viMinion != _vMinion.end(); ++_viMinion)
{
(*_viMinion)->update();
}
minionBulletFire();
collision();
_bullet->update();
}
void enemyManager::render()
{
for (_viMinion = _vMinion.begin(); _viMinion != _vMinion.end(); ++_viMinion)
{
(*_viMinion)->render();
}
_bullet->render();
}
void enemyManager::setMinion()
{
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 6; j++)
{
enemy* ufo;
ufo = new minion;
ufo->init("enemy", PointMake(80 + j * 80, 80 + i * 100));
_vMinion.push_back(ufo);
}
}
}
void enemyManager::minionBulletFire()
{
for (_viMinion = _vMinion.begin(); _viMinion != _vMinion.end(); ++_viMinion)
{
//값이 true가 되면
if ((*_viMinion)->bulletCountFire())
{
RECT rc = (*_viMinion)->getRect();
//_bullet->fire((rc.left + rc.right) / 2, rc.bottom + 5, -(PI / 2), 7.0f);
_bullet->fire((rc.left + rc.right) / 2,
rc.bottom + 5,
getAngle((rc.left + rc.right) / 2, rc.bottom,
_ship->getShipImage()->getCenterX(),
_ship->getShipImage()->getCenterY()), 7.0f);
}
}
}
void enemyManager::removeMinion(int arrNum)
{
_vMinion.erase(_vMinion.begin() + arrNum);
}
void enemyManager::collision()
{
for (int i = 0; i < _bullet->getVBullet().size(); i++)
{
RECT temp;
RECT rc = RectMake(_ship->getShipImage()->getX(), _ship->getShipImage()->getY(),
_ship->getShipImage()->getWidth(), _ship->getShipImage()->getHeight());
if (IntersectRect(&temp, &_bullet->getVBullet()[i].rc,
&rc))
{
_bullet->removeBullet(i);
_ship->hitDamage(10.0f);
//플레이어 체력깍아주면 됨
break;
}
}
}
| [
"[email protected]"
] | |
a5cb2b432860ee7256fc55e187ffb56c6081a789 | 36a16225826989e979161a89e7f500e44ca80cd9 | /Semana2.cpp | a2ce237d1170ae2153a3204157d826adb56f98f4 | [] | no_license | carlosvelaquez/Semana2 | e6336faf9cedf21fa4d7d14e5b2b33e8cfe97c1d | 1aa4f26955ddcd3e8045f720b5d296812d23d25c | refs/heads/master | 2021-01-01T19:16:41.481945 | 2017-07-27T15:22:37 | 2017-07-27T15:22:37 | 98,551,763 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 2,612 | cpp | #include <iostream>
using namespace std;
//Condicional que para a la recursión: Caso Base
//Condicional que sigue con la recursión: Paso/Caso Recursivo
/* I. Semana 2, Día 1
1. Versión Recursiva Factorial
2. Versión Iteratica Factorial
3. Versión Recursiva Sumatoria
4. Versión Iterativa Sumatoria
*/
int menu();
void cleanBuffer();
int factorialRecursivo(int num, int suma);
int factorialIterativo(int num);
int sumatoriaRecursiva(int num, int suma);
int sumatoriaIterativa(int num);
int main(){
do{
switch(menu()){
case 1:
cout << "Ingrese un numero para calcular su factorial: ";
int num;
cin >> num;
cout << "El factorial de " << num << " es: " << factorialRecursivo(num, 0) << endl;
break;
case 2:
cout << "Ingrese un numero para calcular su factorial: ";
cin >> num;
cout << "El factorial de " << num << " es: " << factorialIterativo(num) << endl;
break;
case 3:
cout << "Ingrese un numero para calcular su sumatoria: ";
cin >> num;
cout << "La sumatoria de " << num << " es: " << sumatoriaRecursiva(num, 0) << endl;
break;
case 4:
cout << "Ingrese un numero para calcular su sumatoria: ";
cin >> num;
cout << "La sumatoria de " << num << " es: " << sumatoriaIterativa(num) << endl;
break;
case 5:
return 0;
default:
cout << "Opción Inválida, por favor intente de nuevo" << endl;
break;
cout << "--------------------------" << endl;
}
}while(true);
}
int menu(){
cleanBuffer();
cout << "--------------------------" << endl << "Menú Principal" << endl << endl
<< "1. Factorial Recursivo" << endl
<< "2. Factorial Iterativo" << endl
<< "3. Sumatoria Recursiva" << endl
<< "4. Sumatoria Iterativa" << endl
<< "5. Salir del Programa" << endl
<< endl << "Ingrese el número de la opción que desea: ";
int resp;
cin >> resp;
cout << "--------------------------" << endl;
return resp;
}
int factorialRecursivo(int num, int suma){
if(num == 0){
return suma*1;
}else{
if(suma == 0){
suma += num;
}else{
suma *= num;
}
return factorialRecursivo(num-1, suma);
}
}
int factorialIterativo(int num){
int suma = 1;
int num2 = num;
for(int i = num; i > 0; i--){
suma *= num2;
num2--;
}
return suma;
}
int sumatoriaRecursiva(int num, int suma){
if(num == 0){
return suma;
}else{
suma += num;
num--;
return sumatoriaRecursiva(num, suma);
}
}
int sumatoriaIterativa(int num){
int suma = 0;
int num2 = num;
for(int i = num; i > 0; i--){
suma += num;
num --;
}
return suma;
}
void cleanBuffer(){
std::cin.clear();
}
| [
"[email protected]"
] | |
d5e2ae76aa58514ff26b1ad0dfa480f89fed1eb7 | 5f7dc639181e627a1e50bdbaf2eeda534653a152 | /oving_6/std_lib_facilities_mac/std_lib_facilities_mac/temperatures.hpp | 323d93b89ec0535e90cfe2950abd4b717acdf6b2 | [] | no_license | joningehe/TDT4102 | eeebc2d906c96f3023b8b085792f039fd2e3cb23 | bef198b37e9d926d619b437848e24a515cf49b57 | refs/heads/master | 2020-04-18T07:59:54.067262 | 2019-04-11T10:25:45 | 2019-04-11T10:25:45 | 167,380,431 | 0 | 0 | null | null | null | null | UTF-8 | C++ | false | false | 368 | hpp | //
// temperatures.hpp
// std_lib_facilities_mac
//
// Created by Jon H on 20/02/2019.
// Copyright © 2019 Lars Musaus. All rights reserved.
//
#pragma once
#include "std_lib_facilities.h"
class Temps {
double max;
double min;
public:
//vector<double> maxtemp;
//vector<double> mintemp;
friend istream& operator>> (istream& is, Temps& t);
};
| [
"[email protected]"
] | |
2540ca5acc8f603727359e309ba0abc83494b4bd | 8bd30da01c1f22f9c360153311b429b7ce65980b | /IUI/Control/Window/UIColorDialog.cpp | ad74c33b8b1b88fd9fb5f21e1b79d7ba01ca35b1 | [
"BSD-2-Clause"
] | permissive | jiaojian8063868/portsip-softphone-windows | 33adf93c21b97a684219d4cc3bf5cad3ea14b008 | df1b6391ff5d074cbc98cb559e52b181ef8e1b17 | refs/heads/master | 2022-11-19T20:22:40.519351 | 2020-07-24T04:06:23 | 2020-07-24T04:06:23 | 282,122,371 | 1 | 2 | BSD-2-Clause | 2020-07-24T04:26:24 | 2020-07-24T04:26:23 | null | UTF-8 | C++ | false | false | 976 | cpp | #include "StdAfx.h"
#ifdef _DEBUG
#define new IUI_DEBUG_NEW
#endif // _DEBUG
namespace IUI
{
CColorDialogUI::CColorDialogUI(
COLORREF clrInit/* = 0*/,
DWORD dwFlags/* = 0*/,
HWND hParent/* = NULL*/)
: m_hParent(hParent)
{
memset(&m_cc, 0, sizeof(m_cc));
m_cc.lStructSize = sizeof(m_cc);
static COLORREF acrCustClr[16] = {0};
m_cc.lpCustColors = (LPDWORD)acrCustClr;
m_cc.Flags = CC_FULLOPEN | CC_RGBINIT | dwFlags;
if ((m_cc.rgbResult = clrInit) != 0)
{
m_cc.Flags |= CC_RGBINIT;
}
m_hWndTop = NULL;
}
CColorDialogUI::~CColorDialogUI()
{
}
INT CColorDialogUI::DoModal()
{
HWND hWnd = GetSafeOwner_(m_hParent, &m_hWndTop);
if (hWnd == NULL)
{
hWnd = m_hParent;
}
m_cc.hwndOwner = hWnd;
BOOL bResult = ::ChooseColor(&m_cc);
return bResult ? bResult : IDCANCEL;
}
COLORREF CColorDialogUI::GetColor()
{
return m_cc.rgbResult;
}
} // namespace IUI
| [
"[email protected]"
] |
Subsets and Splits